Google Colab

How to Clone Large Google Drive Folders: A Simple Script Solution

The Challenge

I recently encountered a common problem: needing to download a large Google Drive folder (around 30 gigabytes!) containing numerous files and subfolders. Manually selecting and downloading each file would take forever. The “Download All” option wasn’t much better, as Google’s zipping process for such a large volume of data also consumes a significant amount of time. To complicate matters, the link owner could delete the files at any moment, creating a sense of urgency. My solution? A script to clone all files from the shared link directly to my Google Drive, allowing me to sync them to my computer at my convenience.

Initial Approaches & The Winning Solution

My first thought was to use gdown, a Python library designed for Google Drive downloads. However, I quickly discovered its limitation: it can only handle up to 50 files per link, making it unsuitable for my situation.

The successful solution came with Google Colab. If you’re unfamiliar with it, Google Colab is a hosted service by Google that allows you to run Python scripts online, leveraging Google’s infrastructure. This means you get direct access to Google resources like Google Cloud and, crucially for this task, Google Drive.

Step-by-Step Guide with Google Colab

Here’s how to use Google Colab to clone large Google Drive folders:

First, open a new notebook on Google Colab.

You’ll need to create three separate code blocks and run them sequentially.

Step 1: Authorize Google Colab

This step grants Google Colab permission to access your Google Drive, enabling it to copy files on your behalf.

1
2
3
4
5
6
7
8
# STEP 1: Authorize Google Colab to access your Google Drive.
from google.colab import auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError

# This will trigger a pop-up window for you to authorize access.
auth.authenticate_user()
drive_service = build('drive', 'v3')
Step 2: Define the Copy Functions

This code block defines the necessary functions to recursively copy folders and their contents from the source to your Google Drive.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
# STEP 2: Define the functions to copy the folder.
def get_folder_id_from_url(url):
    """Extracts the folder ID from a Google Drive folder URL."""
    try:
        return url.split('/')[-1].split('?')[0]
    except:
        return None

def copy_folder_recursive(service, source_folder_id, destination_parent_id, new_folder_name):
    """Recursively copies a folder and its contents."""
    print(f"Creating root folder: '{new_folder_name}'...")
    # Create the root folder in the destination
    file_metadata = {
        'name': new_folder_name,
        'mimeType': 'application/vnd.google-apps.folder',
        'parents': [destination_parent_id]
    }
    try:
        new_root_folder = service.files().create(body=file_metadata, fields='id').execute()
        new_root_folder_id = new_root_folder.get('id')
        print(f"Successfully created root folder with ID: {new_root_folder_id}")
        _copy_children(service, source_folder_id, new_root_folder_id)
        return new_root_folder_id
    except HttpError as error:
        print(f"An error occurred while creating the root folder: {error}")
        return None

def _copy_children(service, source_folder_id, destination_folder_id):
    """Helper function to copy contents of a folder."""
    page_token = None
    while True:
        try:
            response = service.files().list(q=f"'{source_folder_id}' in parents and trashed=false",
                                              spaces='drive',
                                              fields='nextPageToken, files(id, name, mimeType)',
                                              pageToken=page_token).execute()
            for file in response.get('files', []):
                print(f"Found item: {file.get('name')} ({file.get('mimeType')})")
                if file.get('mimeType') == 'application/vnd.google-apps.folder':
                    # It's a folder, create it in the destination and recurse
                    print(f"Creating sub-folder: {file.get('name')}")
                    folder_metadata = {
                        'name': file.get('name'),
                        'mimeType': 'application/vnd.google-apps.folder',
                        'parents': [destination_folder_id]
                    }
                    new_folder = service.files().create(body=folder_metadata, fields='id').execute()
                    print(f"Copying contents of '{file.get('name')}'...")
                    _copy_children(service, file.get('id'), new_folder.get('id'))
                else:
                    # It's a file, copy it
                    print(f"Copying file: {file.get('name')}")
                    file_metadata = {
                        'name': file.get('name'),
                        'parents': [destination_folder_id]
                    }
                    service.files().copy(fileId=file.get('id'), body=file_metadata).execute()
            page_token = response.get('nextPageToken', None)
            if page_token is None:
                break
        except HttpError as error:
            print(f'An error occurred: {error}')
            break
Step 3: Run the Main Process

Finally, execute this code block to initiate the cloning process. You’ll be prompted to enter the Google Drive folder URL and a name for your new folder.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# STEP 3: Run the main process.
def main():
    """Main function to run the folder copy process."""
    source_folder_url = input("Enter the Google Drive folder URL to clone: ")
    source_folder_id = get_folder_id_from_url(source_folder_url)

    if not source_folder_id:
        print("Invalid Google Drive folder URL.")
        return

    new_folder_name = input("Enter the name for your new folder in 'My Drive': ")

    # 'root' is a special alias for the main "My Drive" folder
    destination_parent_id = 'root'

    print(f"Starting clone process...")
    print(f"Source Folder ID: {source_folder_id}")
    print(f"Destination: Your 'My Drive' folder")
    print(f"New Folder Name: {new_folder_name}")

    new_folder_id = copy_folder_recursive(drive_service, source_folder_id, destination_parent_id, new_folder_name)

    if new_folder_id:
        print(f"✅ Successfully cloned folder! You can find '{new_folder_name}' in your Google Drive.")
    else:
        print("❌ Folder cloning failed.")

# Run the script
main()

Conclusion

By following these steps, you can efficiently clone large Google Drive folders directly to your own Google Drive using Google Colab. The “magic” happens in Step 1, where you grant Colab the necessary permissions. This method bypasses the limitations of traditional download methods and ensures you can secure your files quickly.

I hope this guide helps you manage your large Google Drive downloads with ease! Let me know in the comments if you have any questions or run into issues.

JX1 One Click Server Import From VMWARE to PROXMOX

JX1 One Click Tutorial
Part 1: Convert VMWare Disk To Proxmox Disk

In my case, I download the 1Click JX Server From:

So I got the VMWare Disk File

I uploaded the VMWARE Disk to my Proxmox, in this case, I put it in /root/

After that, I log to my Proxmox using SSH. Remember that, if you are trying to create a VM in Promox with ID 111, you’ll use this number in all this tutorial. In my case, it’s 111. Secondly, I’m using zfs, so my storage is local-zfs. You may check your storage by using cmd pvesm status

1
2
3
4
cd /var/lib/vz/images/
mkdir 111
cd 111
qm importdisk 111 /root/1ClickJXv2-cl3.vmdk local-zfs

I’ll got this result like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
root@lenovo:/var/lib/vz/images/111# qm importdisk 111 /root/1ClickJXv2-cl3.vmdk local-zfs
importing disk '/root/1ClickJXv2-cl3.vmdk' to VM 111 ...
transferred 0.0 B of 500.0 GiB (0.00%)
transferred 5.0 GiB of 500.0 GiB (1.00%)
transferred 10.0 GiB of 500.0 GiB (2.00%)
transferred 15.0 GiB of 500.0 GiB (3.00%)
transferred 20.0 GiB of 500.0 GiB (4.00%)
transferred 25.0 GiB of 500.0 GiB (5.00%)
transferred 30.0 GiB of 500.0 GiB (6.00%)
transferred 35.0 GiB of 500.0 GiB (7.00%)
transferred 40.0 GiB of 500.0 GiB (8.00%)
transferred 45.0 GiB of 500.0 GiB (9.00%)
transferred 50.0 GiB of 500.0 GiB (10.00%)
...
Part 2: Create VM

Now I’m going to create a VM in Promox, set the VMID is 111. Do not add Disk while creating.

Back to ssh and run: 

1
2
qm set 111 --scsihw virtio-scsi-pci --scsi0 local-zfs:vm-111-disk-0
qm set 111 --boot order=scsi0
Part 3: Fake VM Machine

Some part of server doesnot support running under virtual machine. So you need to make the machine looks like a real machine.

1
2
3
4
5
qm set 111 --args "-cpu host,-hypervisor -device isa-debug-exit,iobase=0xf4,iosize=0x04"
qm set 111 --vga virtio
qm set 111 --net0 virtio=00:16:3E:12:34:56,bridge=vmbr0
qm set 111 --smbios1 manufacturer=HP,product=EliteBook
qm set 111 --machine pc

Check QM Config by cmd qm config 111. Results should be: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
root@lenovo:/var/lib/vz/images/111# qm config 111
agent: 1
args: -cpu host,-hypervisor -device isa-debug-exit,iobase=0xf4,iosize=0x04
bios: seabios
boot: order=scsi0
cores: 4
cpu: host,hidden=1
machine: pc
memory: 8192
meta: creation-qemu=9.2.0,ctime=1750130769
name: VLTK-1Click
net0: virtio=00:16:3E:12:34:56,bridge=vmbr0,firewall=1
numa: 0
ostype: l26
scsi0: local-zfs:vm-111-disk-0,size=500G
scsihw: virtio-scsi-pci
smbios1: manufacturer=HP,product=EliteBook
sockets: 1
vga: std
vmgenid: 1ad4b2be-0e68-48aa-b7ee-bc7509ab45d9

Now we can start the machine and enjoy the time: qm start 111

Option:

In some time, we may need to check the VM that it’s real machine or not.

For Linux:

lscpu | grep Hypervisor if found something, it’s bad

grep -i hypervisor /proc/cpuinfo if got a flag like hypervisor, it’s bad

Check more 

1
2
sudo dmidecode -s system-product-name
sudo dmidecode -s system-manufacturer

For Windows ( not tested ): using Powershell

1
2
systeminfo | findstr /i "hypervisor"
Get-WmiObject Win32_ComputerSystem

Testing Your Luck: Generating an Ethereum Wallet and Checking Its Balance

Testing Your Luck: Generating an Ethereum Wallet and Checking Its Balance

Have you ever wondered what it would be like to randomly generate an Ethereum wallet and check if it has any balance? Well, let’s be honest—it’s a near-impossible dream, but that doesn’t mean we can’t have some fun testing our luck!

In this blog post, we’ll explore a simple Python script that generates an Ethereum wallet and checks its balance. If you’re the luckiest person in the world, who knows? You might just stumble upon an old wallet with some forgotten ETH!

Setting Up Your Environment

Before running the script, ensure you have Python installed along with the required dependencies. You can install the necessary package using:

1
pip install eth_account --break-system-packages

This will install the eth_account package, which allows us to generate Ethereum wallets programmatically.

Bypassing Public Node Rate Limits

If you want to check balances at scale, relying on public Ethereum nodes isn’t practical since they often limit requests to 5-10 per second. You might consider running your own Ethereum node using services like Infura, Alchemy, or a self-hosted Geth node. This way, you can perform unlimited checks without hitting request limits. Check my lastest post for the tutorial to install Ethereum node. In this example, the IP of Ethereum node is: 192.168.1.150

The Ethereum Wallet Generator

Here’s a simple Python script that generates an Ethereum private key, derives the corresponding public address, and checks the balance:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
import requests
import json
import secrets
import threading
import time
from eth_account import Account

def generate_eth_account():
    """
    Generate a new Ethereum account with a private key.
    
    :return: Tuple (private_key, address)
    """
    private_key = "0x" + secrets.token_hex(32)
    account = Account.from_key(private_key)
    return private_key, account.address

def get_eth_balance(node_url, address):
    """
    Fetch the Ethereum balance of a given address from a JSON-RPC node.
    
    :param node_url: The URL of the Ethereum node (e.g., http://192.168.1.150:8080)
    :param address: The Ethereum address to query
    :return: Balance in Ether (float)
    """
    payload = {
        "jsonrpc": "2.0",
        "method": "eth_getBalance",
        "params": [address, "latest"],
        "id": 1
    }
    
    headers = {"Content-Type": "application/json"}
    
    try:
        response = requests.post(node_url, headers=headers, data=json.dumps(payload))
        response_data = response.json()
        
        if "result" in response_data:
            wei_balance = int(response_data["result"], 16)
            ether_balance = wei_balance / 1e18
            return ether_balance
        else:
            return 0.0
    except requests.exceptions.RequestException as e:
        return 0.0

global_counter = 0
good = 0
counter_lock = threading.Lock()
start_time = time.time()
num_threads = 300 # Adjust the number of threads as needed

def process_account(node_url):
    """
    Generate an Ethereum account, get its balance, and save results to files.
    Runs indefinitely.
    """
    global global_counter, num_threads, good, start_time
    while True:
        private_key, address = generate_eth_account()
        balance = get_eth_balance(node_url, address)
        
        log_entry = f"{address} {private_key} {balance}\n"
        
        with open("log.txt", "a") as log_file:
            log_file.write(log_entry)
        
        if balance != 0.0:
            with open("good.txt", "a") as good_file:
                good_file.write(log_entry)
                good += 1
        
        with counter_lock:
            global_counter += 1
            if global_counter % 1000 == 0:
                elapsed_time = time.time() - start_time
                print(f"{global_counter} checked | Runtime: {elapsed_time:.2f} seconds | Total {num_threads} threads | Total {good} good")
                start_time = time.time()

def main():
    node_url = "http://192.168.1.150:8080"

    
    threads = [threading.Thread(target=process_account, args=(node_url,), daemon=True) for _ in range(num_threads)]
    
    for thread in threads:
        thread.start()
    
    for thread in threads:
        thread.join()

if __name__ == "__main__":
    main()

Why Is This Fun but Unrealistic?

Ethereum addresses are derived from a 256-bit private key space, meaning there are 2^256 possible addresses. The chances of generating an address that already has ETH are astronomically small—essentially impossible. But hey, it’s still fun to dream, right?

Final Thoughts

Give it a shot and let me know if you hit the jackpot (spoiler: you won’t). 😆 Happy coding!

Blockchain Install Guides

Installing an Ethereum Blockchain Node using Geth

Prerequisites

Ensure that your system meets the following requirements:

  • RAM: At least 16GB
  • Storage: At least 2TB
  • Internet: A stable and fast connection

All commands in this guide are executed as the root user.

1. Install Geth

Update and Install Dependencies

Run the following commands to update your system and install essential packages: 

1
2
sudo apt update && sudo apt upgrade -y
sudo apt install -y git build-essential

Install Go (Golang)

Geth requires Go, so install it using the commands below: 

1
2
wget https://go.dev/dl/go1.21.7.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.21.7.linux-amd64.tar.gz

Configure Environment Variables

Edit your ~/.bashrc file: 

1
nano ~/.bashrc

Add the following lines at the end of the file: 

1
2
3
export PATH=$PATH:/usr/local/go/bin
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

Apply the changes: 

1
source ~/.bashrc

Download and Build Geth

1
2
3
4
git clone https://github.com/ethereum/go-ethereum.git
cd go-ethereum
make geth
sudo cp build/bin/geth /usr/local/bin/

2. Running Geth

Create a Data Directory and Start Geth

1
2
3
4
5
6
7
mkdir ~/ethereum
geth --datadir ~/ethereum \
  --http --http.port 8080 --http.addr "0.0.0.0" \
  --syncmode "snap" \
  --authrpc.addr "127.0.0.1" --authrpc.port 8551 \
  --authrpc.jwtsecret ~/ethereum/geth/jwtsecret \
  --maxpeers 100

This will start Geth and expose the JSON-RPC API on port 8080.

(Optional) Disable IPv6

If you experience network issues, disabling IPv6 can help: 

1
2
sudo sysctl -w net.ipv6.conf.all.disable_ipv6=1
sudo sysctl -w net.ipv6.conf.default.disable_ipv6=1

3. Install and Run Lighthouse (Consensus Layer)

Ethereum transitioned to Proof-of-Stake (PoS) in 2022. This means you need both:

  • Execution Layer (EL) → Geth
  • Consensus Layer (CL) → Lighthouse (or another beacon client)

Install Rust and Build Lighthouse

1
2
3
4
5
6
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env
rustup update
git clone https://github.com/sigp/lighthouse.git
cd lighthouse
make

(Troubleshooting) Install Required Dependencies

If you encounter errors while running make, install clang and other required dependencies: 

1
2
3
sudo apt install -y libc6-dev build-essential clang cmake
export CC=gcc
export CFLAGS="-I/usr/include"

Run Lighthouse

1
lighthouse beacon_node --network mainnet --datadir ~/beacon --http --http-address 0.0.0.0 --http-port 5052 --execution-endpoint http://127.0.0.1:8551 --execution-jwt ~/ethereum/geth/jwtsecret --checkpoint-sync-url https://mainnet-checkpoint-sync.attestant.io

You may check more endpoints at: (https://eth-clients.github.io/checkpoint-sync-endpoints/)

⚠️ Make sure Geth is running before starting Lighthouse.

4. Testing Your Ethereum Node

Once both Geth and Lighthouse are running, you can test your node by making an RPC call: 

1
2
3
curl -X POST -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
  http://192.168.1.150:8080

If your node is running correctly, it will return something like: 

1
{"jsonrpc":"2.0","id":1,"result":"0x0"}

(Replace 192.168.1.150 with your actual server IP.)

Final Notes

  • This tutorial sets up an Ethereum full node using Geth and Lighthouse.
  • Your node will synchronize with the Ethereum network, which can take time.
  • Ensure your system meets the hardware requirements to avoid performance issues.

Check status:

Command:

1
geth attach ~/ethereum/geth.ipc

In console:

1
eth.syncing

Example results:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{
  currentBlock: 8959360,
  healedBytecodeBytes: 0,
  healedBytecodes: 0,
  healedTrienodeBytes: 0,
  healedTrienodes: 0,
  healingBytecode: 0,
  healingTrienodes: 0,
  highestBlock: 21971505,
  startingBlock: 0,
  syncedAccountBytes: 29609285538,
  syncedAccounts: 137604971,
  syncedBytecodeBytes: 5151118382,
  syncedBytecodes: 794044,
  syncedStorage: 609184446,
  syncedStorageBytes: 135929810634,
  txIndexFinishedBlocks: 0,
  txIndexRemainingBlocks: 1
}
1
net.peerCount

Hexo Copy Button For Code Block

Add Copy Button For Hexo Code Block

I am using Clipboard.js to achieve this.

Step 1:

Create a clipboard-use.js file in your JavaScript folder. In my case, the path is:
/var/www/myblog/themes/landscape/source/js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
!function (window, document) {
    var initCopyCode = function() {
        var copyHtml = '';
        copyHtml += '<button class="btn-copy" data-clipboard-snippet>';
        copyHtml += '  <i class="fa fa-copy"></i><span>Copy</span>';
        copyHtml += '</button>';
        $(".highlight .code pre").before(copyHtml);
        new ClipboardJS('.btn-copy', {
            target: function(trigger) {
                return trigger.nextElementSibling;
            }
        });
    };
    initCopyCode();
}(window, document);

Step 2:

Add the script tag to the after-footer template. Make sure to place it below the jQuery script tag.
In my case, the file is located at:
/var/www/myblog/themes/landscape/layout/_partial/after-footer.ejs

1
2
3
4
<!-- Load Clipboard.js from CDN -->
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/clipboard.min.js"></script>
<!-- Load your custom script -->
<script type="text/javascript" src="/js/clipboard-use.js"></script>

Step 3:

Add the necessary CSS.
For this demo, I have added the styles in: /var/www/myblog/themes/landscape/source/css/style.styl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//copy button in code block

.highlight{
  position: relative;
}
.btn-copy {
    display: inline-block;
    cursor: pointer;
    background-color: #eee;
    background-image: linear-gradient(#fcfcfc,#eee);
    border: 1px solid #d5d5d5;
    border-radius: 3px;
    -webkit-user-select: none;
    -moz-user-select: none;
    -ms-user-select: none;
    user-select: none;
    -webkit-appearance: none;
    font-size: 13px;
    font-weight: 700;
    line-height: 20px;
    color: #333;
    -webkit-transition: opacity .3s ease-in-out;
    -o-transition: opacity .3s ease-in-out;
    transition: opacity .3s ease-in-out;
    padding: 2px 6px;
    position: absolute;
    right: 5px;
    top: 5px;
    opacity: 0;
}
.highlight:hover .btn-copy{
  opacity: 1;
}
.btn-copy span {
    margin-left: 5px;
}

Step 4:

Run the following commands in your terminal:

1
2
3
cd /var/www/myblog/
hexo clean && hexo g 
hexo server

Done 🎉

Your Hexo blog should now display a Copy button in the code blocks, allowing users to quickly copy the code. 🚀

Software Install Tutorials

Docker and Portainer Install Tutorial

Installing Docker, Docker Compose, and Portainer on Ubuntu

Prerequisites

  • A system running Ubuntu (20.04, 22.04, or later).
  • A user with sudo privileges.

Step 1: Update the System

1
sudo apt update && sudo apt upgrade -y

Step 2: Install Required Dependencies

1
sudo apt install -y apt-transport-https ca-certificates curl software-properties-common

Step 3: Install Docker

Add Docker’s Official GPG Key:

1
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Add the Docker Repository:

1
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Install Docker Engine:

1
2
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

Verify Docker Installation:

1
docker --version

Enable and Start Docker Service:

1
sudo systemctl enable --now docker

Add Your User to the Docker Group (Optional):

1
2
sudo usermod -aG docker $USER
newgrp docker

Step 4: Install Docker Compose

Download and Install Latest Version:

1
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Apply Executable Permissions:

1
sudo chmod +x /usr/local/bin/docker-compose

Verify Installation:

1
docker-compose --version

Step 5: Install Portainer

Create a Docker Volume for Portainer:

1
docker volume create portainer_data

Deploy Portainer Container:

1
2
3
4
5
6
7
docker run -d \
  --name=portainer \
  --restart=always \
  -p 8000:8000 -p 9443:9443 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  portainer/portainer-ce:latest

Access Portainer Web UI:

Open a web browser and go to:

1
https://<your-server-ip>:9443

Create an admin account and start managing your containers.

Conclusion

You have successfully installed Docker, Docker Compose, and Portainer on Ubuntu. 🎉 Happy containerizing!

READ ME FIRST

Who am I

Who am I?

Hi there! I’m just a curious soul who loves dabbling in the world of IT. I enjoy learning about coding, design, and all things tech-related, but let’s be real — I’m more of a “copy and paste” kind of person than a hardcore developer. If there’s a snippet of code or a cool design trick out there, you can bet I’ll grab it, tweak it, and make it my own!

What really gets me excited is playing around with AI. I love using it to mess with computers — whether it’s generating something fun, automating a boring task, or just seeing what crazy things I can make happen. Technology is like a playground for me, and AI is my favorite toy.

So yeah, that’s me in a nutshell: a bit lazy, a lot curious, and always ready to experiment with the next cool thing I find online. Stick around if you’re into quick hacks and AI-powered adventures!

Code Disclaimer

Hey, listen up! Every single piece of code you see on this page? Yup, it’s all copy and paste. I didn’t write it from scratch — I snagged it from somewhere out there in the wild internet, tweaked it a bit, and bam, here it is.

Warning

Big fat warning: I’m not responsible if you take this code and use it for something shady or downright evil. You wanna build a cool thing? Awesome! You wanna cause chaos? Not on my watch — but also not my problem. Use it at your own risk!

So, feel free to grab whatever you like, play with it, break it, or make it better. Just don’t come crying to me if the world explodes because of a misplaced semicolon. Happy coding (or copying)!

Made with laziness and a lot of Ctrl+C / Ctrl+V

Markdown Language Tutorials

Markdown is a lightweight markup language used to format plain text into structured documents, often used for writing documentation, README files, and web content.

Basic Markdown Syntax

Headings

Use # followed by a space for different heading levels:

1
2
3
4
5
6
# Heading 1
## Heading 2
### Heading 3
#### Heading 4
##### Heading 5
###### Heading 6

Bold & Italic

1
2
3
**Bold Text** or __Bold Text__
*Italic Text* or _Italic Text_
***Bold and Italic*** or ___Bold and Italic___

Lists

Unordered List

1
2
3
4
- Item 1
- Item 2
  - Sub-item 1
  - Sub-item 2

Ordered List

1
2
3
4
1. First item
2. Second item
   1. Nested item
   2. Nested item
1
[OpenAI](https://openai.com)

Images

1
![Alt Text](https://example.com/image.jpg)

Code Blocks

1
This is `inline code`.

Example: This is inline code.

Block Code

Use triple backticks (```) for multi-line code blocks:

1
2
3
```python
def hello():
    print("Hello, World!")

Tables

1
2
3
4
| Column 1 | Column 2 | Column 3 |
|----------|----------|----------|
| Row 1    | Data 1   | Data 2   |
| Row 2    | Data 3   | Data 4   |

Task Lists

1
2
3
- [x] Task 1
- [ ] Task 2
- [ ] Task 3

Example:

  • Task 1
  • Task 2
  • Task 3

Horizontal Line

1
---

Footnotes

1
This is a footnote reference[^1].

Example:
This is a footnote reference[^1].

Escaping Characters

Use \ before Markdown symbols to escape them:

1
\*This is not italic\*

Markdown is widely used in GitHub, documentation, and blogging platforms.