Dan's Blog - English

Cloudflare Pages Redirects Working but GSC Not Recognizing? Migration Fix & Bulk Redirects Solution

Fri, 20 Mar 2026 00:00:00 GMT

Introduction

When I migrated my site to a new domain using GSC, I ran into a frustrating issue. I had already set up 301 redirects, but GSC just wouldn’t recognize them. I kept seeing the old pages.dev domain still stealing my traffic. Then I found a solution from a blog called Codemzy—and it actually worked.

Background

When moving a site from *.pages.dev to a custom domain, passing SEO ranking is the key concern. According to the official docs, the ideal approach is using 301 permanent redirects, so Google knows the original URL has permanently moved to the new address and passes the ranking authority over.

Here’s the scenario:

Source: https://dansblog.pages.dev
Target: https://danarnoux.com
Expected: Both browser and search engines receive 301 status code

The Problem

After configuring redirects, testing revealed:

Browser works fine - Visiting dansblog.pages.dev/any-path automatically redirects to danarnoux.com/any-path, seamless for users
GSC error - Google Search Console reports many URLs returning non-301 status codes, migration verification fails
cURL test oddities - Some tools detect status codes that don’t match expectations

Very strange: user access works perfectly, but Google just won’t acknowledge it.

Failed Solutions

Solution 1: _redirects File

Tried configuring in public/_redirects:

https://dansblog.pages.dev/* https://danarnoux.com/:splat 301

Result: Browser redirect works, but GSC still doesn’t recognize it.

Root cause analysis (inference based on Cloudflare official documentation):

1.1 Official Documentation References

Bulk Redirects Docs: https://developers.cloudflare.com/rules/url-forwarding/bulk-redirects/

“Bulk Redirects allow you to define URL redirects at the account level and have them executed at the edge.”

Redirect Rules Docs: https://developers.cloudflare.com/rules/url-forwarding/

Pages _redirects Docs: https://developers.cloudflare.com/pages/platform/redirects/

“You can define redirects by adding a _redirects file to your project.”

How Pages Works: https://developers.cloudflare.com/pages/platform/how-pages-works/

“Cloudflare Pages serves your site through Cloudflare’s global network.”

1.2 Technical Interpretation

According to the documentation, the two redirect mechanisms are fundamentally different:

Mechanism	Processing Level	Execution Location
Pages _redirects	Project-level (injected at build)	Pages Platform
Bulk Redirects	Account-level	Edge Network

_redirects is part of your project, defined via public/_redirects file, processed by the Pages platform at build time
Bulk Redirects are a separate Rules system, executed at edge nodes globally, with higher priority than Pages-level config

1.3 Inference

Based on Cloudflare’s official documentation, we can confirm:

_redirects belongs to Pages project-level redirect configuration
Bulk Redirects belong to the Rules system, executed directly on Cloudflare’s Edge network

With that context, here’s a somewhat conservative inference:

GSC, when performing site migration detection, may more readily recognize 301 redirects returned directly from the Edge layer. For redirects implemented at the Pages layer, it may not consistently recognize them.

Important to note:

Neither Cloudflare nor Google has explicitly explained GSC’s judgment logic
The above conclusions are based solely on documentation structure and actual test results

👉 In practice, Bulk Redirects can reliably pass GSC migration verification.

Solution 2: Worker Approach

Tried writing a Cloudflare Worker to handle redirects.

Result: Works, but has instability risks—Workers can fail due to limits, config changes, or other issues.

The Fix: Bulk Redirects

The final solution uses Cloudflare Bulk Redirects.

Important: Bulk Redirects has a two-step structure:

First create a Redirect List (rule data)
Then create a Redirect Rule (activates the rules)

Step 1: Access Bulk Redirects

Go to Cloudflare Dashboard:

Select your domain (e.g., danarnoux.com)
On the left sidebar: Rules → Redirect Rules
Switch to Bulk Redirects tab

Step 2: Create Bulk Redirect List (Do This First)

Click:

Create Bulk Redirect List

Fill in:

List name: e.g., pages-dev-redirect

Step 3: Add Rules to the List

Add one rule:

Field	Value
Source URL	`https://dansblog.pages.dev/*`
Target URL	`https://danarnoux.com/$1`
Status	301 (or use 302 for testing first)
Preserve query string	Optional
Subpath matching	ON
Preserve path suffix	ON

Key points:

Use * to match all paths
Use $1 to preserve the original path
Recommend using 302 first to test, then switch to 301 when confirmed

note

In “Add URLs”, click “Or, Manually add URL redirects”, then remember to click “Edit parameters”.

About the options:

Subpath matching / Preserve path suffix: Recommend turning these on, otherwise paths may not pass correctly
Preserve query string: Whether to enable depends on your needs (e.g., if you need to keep URL parameters). Disabling it still allows migration to complete normally.

Step 4: Create Bulk Redirect Rule (Activate the Rules)

Go back to Bulk Redirects page:

Click:

Create Bulk Redirect Rule

Configure:

Rule name: e.g., pages.dev redirect
Redirect using list: Select the List you just created

Step 5: Enable the Rule

After saving, make sure:

Rule status is ✅ Enabled (green)

👉 Note:

If you only create a List without a Rule, it won’t take effect

For reference, check the example in step 1—note that Status shows “Active”

Step 6: Wait for Activation

Click Save / Deploy
Usually takes effect within 1-2 minutes

Summary

The correct flow for Bulk Redirects:

List (define rules) → Rule (enable rules) → Edge execution

Key Difference

Essential difference between Bulk Redirects and _redirects:

Bulk Redirects are processed directly at Cloudflare’s network edge (Edge), without going through the Pages layer
Higher priority, more stable rules
More reliable status code returns

Verification

After configuration, verify using these methods:

1. Browser Test

Visit the original URL directly to confirm redirect works.

2. cURL Test

curl -I https://dansblog.pages.dev/blog/test
# Should return 301 + Location: https://danarnoux.com/blog/test

3. GSC Verification

In Google Search Console, re-verify the migration. After success, you should see a prompt: This site is currently being migrated to [danarnoux.com].

Conclusion

When migrating from *.pages.dev to a custom domain, the _redirects method works fine in browsers, but GSC may not recognize it. According to the documentation, Bulk Redirects execute at the Edge layer, making status code returns more stable and reliable—recommended for direct use.

As for why _redirects isn’t recognized by GSC, neither Cloudflare nor Google has explicitly explained GSC’s specific judgment logic. The above is merely an inference based on documentation structure—no absolute conclusion can be drawn. If you value stability, Bulk Redirects is the safer choice.

Original article from Codemzy: https://www.codemzy.com/blog/cloudflare-pages-dev-redirect

OpenClaw Windows Uninstall Guide

Mon, 16 Mar 2026 00:00:00 GMT

Introduction

If you no longer need OpenClaw, you can follow these steps to completely uninstall it. It’s kind of funny—I just made a deployment guide a few days ago!

1. Uninstall OpenClaw

OpenClaw is installed globally via npm, so uninstalling is simple. Open PowerShell and run:

npm uninstall -g openclaw

2. Delete Configuration Files

OpenClaw creates a config directory in your user folder. You can delete it manually.

Windows: Open CMD or PowerShell and run:

rmdir /s /q %USERPROFILE%\.openclaw

Linux / macOS:

rm -rf ~/.openclaw

3. Verify Uninstallation

Run the following command:

openclaw --version

If you see command not found or an error saying the command doesn’t exist, the uninstallation was successful.

OpenClaw Windows Installation & Configuration Guide (MiniMax / Qwen / Ollama)

Tue, 10 Mar 2026 00:00:00 GMT

Introduction

I’ve been thinking about whether to make an OpenClaw deployment tutorial, because the OpenClaw Chinese documentation is already quite detailed. However, I realized that many people might not know that Chinese documentation exists, or still find it confusing even when following the tutorial. Recently, OpenClaw has become extremely popular in China—it’s almost overhyped, like a modern-day “qigong fever.” But I still think it’s worth making a detailed tutorial so you can try deploying it yourself. After all, you won’t know if a product is right for you until you’ve tried it. The idea of having your own Jarvis-like personal AI assistant is quite appealing.

1. What is OpenClaw?

Let me give you a quick overview. OpenClaw (formerly known as Clawdbot—pretty interesting name change, right?) is an open-source AI Agent framework. Simply put, you can think of it as an “AI operating system”—it doesn’t provide AI capabilities itself, but it helps you connect to various large language models to accomplish tasks.

Unlike regular chatbots, OpenClaw can do much more:

Operate on file systems
Execute commands
Write and debug code
Search for information
Integrate with communication tools like Feishu and Telegram

You just need to pair it with the right model, and it can help you get things done.

2. How OpenClaw Works

Let’s clarify an important concept: OpenClaw is just a “shell”—you need to provide your own model.

The workflow looks like this:

You (input) → OpenClaw → AI Model → Return result

You can choose to connect to:

Cloud Models: MiniMax, Qwen (Alibaba Cloud Bailian), OpenAI, Claude, and more
Local Models: Models running locally via Ollama

Each approach has its pros and cons, which I’ll explain in detail later.

Tip: This guide includes a dedicated section on configuring Ollama local models—see Section 5.8.

3. Deployment Options and Model Choices

Official Documentation: For more advanced configuration options, check out the OpenClaw English Documentation.

Before we start installing, let’s understand the two deployment options and how to choose a model.

3.1 Deployment Options Explained

OpenClaw has two deployment options:

Deployment	Description	Best For
Local Deployment	Run on your own Windows PC	Personal use, privacy-first, low cost
Remote Server	Run on a cloud server (e.g., Linux server)	Multi-user sharing, 24/7 operation

This guide focuses on local deployment—running OpenClaw on your own Windows PC. While remote server deployment is convenient (vendors handle everything for you), you might actually want your own personal Jarvis on your private computer. While this comes with more risks, you’ll weigh and accept them yourself.

3.2 Which Model Should You Choose?

Before starting installation, decide which model option you’ll use. This affects the configuration steps.

Cloud APIs (Recommended for Beginners)

Call cloud model APIs with pay-as-you-go pricing (most have free tiers).

Provider	Recommended Model	Features
MiniMax	M2.5	Great cost-performance, well-optimized for Chinese
Qwen	qwen/qwen3-coder / qwen/qwen3-vl	Strong coding abilities, generous free tier from Alibaba Cloud

qwen3-coder is a coding-optimized model released by Alibaba. | OpenAI | GPT-5 series | Strong all-around capabilities |

Pros: No GPU needed, fast responses, reliable capabilities Cons: Requires payment (but usually has free credits)

Local Models (Ollama)

Run models on your own computer, completely free, but requires specific hardware.

Pros: Zero cost, better privacy Cons: Requires a capable GPU, response speed depends on hardware

Honestly, most computers can’t really handle this. You can check your GPU configuration. Even the workstation in our lab didn’t go with the Ollama solution—the main issue isn’t just VRAM being enough to run, you also can’t ignore speed. Plus, my setup is already pretty powerful, but I still didn’t choose Ollama. The API solution is pretty good—you just pay a little.

My Suggestion: Beginners should just use a remote API—MiniMax or Qwen works great. Once configured, you can start using it in 5 minutes.

3.3 How to Choose the Right LLM

Choosing an LLM mainly depends on these factors:

Factor	Description
Price	Cloud APIs charge per usage; different models vary greatly in price
Speed	Response speed depends on model size and network
Context Length	How much text it can process; longer = more expensive
Coding Ability	Some models are specifically optimized for programming
Reasoning Ability	Ability to solve complex problems

Using the OpenRouter Rankings

OpenRouter provides a convenient Model Rankings page where you can filter by:

Performance: Overall benchmark scores
Price: Sorting by input/output prices
Context Length: Maximum supported tokens
Latency: Response speed

When searching for a specific model on OpenRouter, you can view:

Benchmarks: Capability scores in various areas
Pricing: Input and output prices
Context Length: Supported context length

Note: Different ranking systems may use different evaluation methods. For example, some rankings emphasize coding benchmarks while ignoring multimodal capabilities or long context abilities. Rankings should only be used as a reference.

Also, there’s the issue—you can’t ignore pricing just because of model capability. Check your bill later and you’ll be shocked!

Recommended Models with Excellent Overall Performance:

Model	Features
GPT-5 series	Strong all-around, suitable for various scenarios
Claude 4 Sonnet series	Strong long context, great for handling long texts
qwen/qwen3-coder	Strong coding ability, generous free tier
DeepSeek V3 / V3.2	Strong overall capability, great cost-performance
Gemini 3 Flash series	Fast speed, affordable price
Gemini series	Strong all-around, excellent at multimodal tasks

Coding Model Recommendations

If you’re mainly using OpenClaw for programming assistance, here’s how each model performs:

Most capable coding models:

Claude Opus (including Claude 4 Opus series) usually performs exceptionally well on coding tasks
However, there are limitations:
- Higher price
- May be unstable to access in China
- Not as well-optimized for Chinese as domestic models

If you’re interested, check out the OpenClaw Official Anthropic Configuration Documentation.

More practical choices for Chinese users:

Model	Features
MiniMax M2.5	Good Chinese understanding, great cost-performance
qwen/qwen3-coder	Alibaba’s coding-specific model, generous free tier
DeepSeek V3 / V3.2	Strong overall capability, great cost-performance

DeepSeek V3 / V3.2 is the current flagship model in the DeepSeek series with excellent overall capabilities.

Summary: If your network conditions allow and budget is sufficient, Claude Opus is the strongest choice. Otherwise, MiniMax M2.5, qwen/qwen3-coder, or DeepSeek V3/V3.2 are more practical options.

Google Gemini series is also very strong in overall capabilities and multimodal tasks. For example, Nano Banana in the Gemini ecosystem performs exceptionally well in image generation and visual content creation. If your needs involve image generation or multimodal understanding, consider the Gemini series.

Tip: Beginners are recommended to start with MiniMax or Qwen—once configured, you can use it in 5 minutes.

4. Windows Installation Steps

Quick Installation (Recommended)

If you just want to try OpenClaw quickly, you can use the official quick install method. Only two steps!

Step 1: Install OpenClaw

npm install -g openclaw@latest

Step 2: Run the Setup Wizard

openclaw onboard --install-daemon

This command will automatically:

Initialize OpenClaw configuration
Install the Gateway service
Create default config files
Start the OpenClaw service

Yes, you read that right—just these two commands complete the basic installation!

After installation, you can:

Run interactive chat: openclaw
Open the web interface: openclaw dashboard
Configure models: Follow Chapter 5 to configure your preferred models for OpenClaw

Official Documentation: For more details, check out the OpenClaw Official Documentation, especially the Quick Start section.

If you want to understand the complete OpenClaw installation process and what each step does, continue reading the advanced installation tutorial below.

Now let’s start the installation. Just follow the steps in order.

4.1 Environment Preparation

You need to have Node.js installed first (LTS version recommended, 22 or higher).

Installing Node.js

Method 1: Direct Installation

Visit Node.js Official Website
Download Windows Installer (.msi)
Click Next through the wizard
If you encounter network issues, refer to my other article: Node.js detailed installation steps.

Method 2: nvm (Recommended for managing multiple versions)

# Install nvm for Windows
# Visit https://github.com/coreybutler/nvm-windows/releases to download

# After installation, run in PowerShell:
nvm install 22
nvm use 22

Verify:

node -v
# Should show v22.x.x

npm -v
# Should show 8.x.x

Switch npm Registry (Recommended for China Users)

npm config set registry https://registry.npmmirror.com

Install Git (Optional but Recommended)

Some skills depend on Git—it’s recommended to install:

Visit Git Official Website
For configuration issues, refer to my article: Git Configuration
Download and install, click Next through the wizard

4.2 Modify Execution Policy

Windows doesn’t allow running scripts by default—you need to change this setting. Open PowerShell as Administrator and run:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Type Y to confirm.

4.3 Run the Installation Script

Now you can install OpenClaw. Execute in PowerShell:

iwr -useb https://openclaw.ai/install.ps1 | iex

Wait a moment—the script will automatically:

Detect Node.js environment
Download and install OpenClaw
Configure PATH

When you see “OpenClaw installed successfully”, it’s done.

4.4 Setup Wizard

The first run will enter the wizard:

openclaw onboard

The process goes like this:

Risk warning → Type yes
Configuration mode → Select QuickStart
Model selection → Skip for now, configure manually later
Channel selection → Skip for now
Skills package → Select No

4.5 Verify Installation

You can verify the installation:

# Check version
openclaw --version

# Check status
openclaw status

# Run diagnostics
openclaw doctor

# Open web panel
openclaw dashboard

openclaw dashboard will start a local web page, default at http://localhost:8080. You can visually configure it in your browser.

5. Configuring AI Models

Just installing doesn’t mean it’s ready to use—you need to connect it to a model. Below are instructions for several popular options.

Official Documentation: For more configuration details, check out the OpenClaw Official Documentation, which has more detailed provider configuration guides and troubleshooting tips.

5.1 Must-Read Before Configuration: API Concept Explanation

Before configuring models, let me explain some key concepts:

Concept	Description	Example
Provider	Company or platform providing AI model services	MiniMax, Alibaba Cloud, OpenRouter
Base URL	Address of the API server	`https://api.minimaxi.com/v1`
API Key	Key to access the API, like a “password”	`sk-xxxxxx`
Model ID	Name of the specific model	`MiniMax-M2.5`, `qwen-plus`
Config JSON	JSON format for configuration info	Structured config containing the above fields

Why do you need to configure these?

OpenClaw needs to know:

Where to find the model (Base URL)
What credentials to use (API Key)
Which specific model to use (Model ID)

Recommended: Using cc-switch to Manage Multiple Providers

If you plan to configure multiple model providers, it’s recommended to use cc-switch to manage them:

Multi-Provider Management: One interface to manage all API configurations
One-click Switching: Switch between different models anytime without manually changing config
Auto Environment Variables: OpenClaw automatically reads environment variables set by cc-switch

Tip: See Chapter 6 for a detailed introduction to cc-switch. If you don’t want manual configuration, you can skip this chapter’s provider configuration and directly read the cc-switch section.

Configuration Method Overview

There are three ways to configure models:

Method	Difficulty	Best For
Method 1: CLI Commands	Medium	Users familiar with command line
Method 2: Edit Config File	Harder	Users needing batch configuration
Method 3: Web Page Config (Recommended)	Easy	Beginner users

If you’re not familiar with the command line, Web Page Configuration (Method 3) is recommended—visual interface is easier to get started. See details below in section 5.8.

5.2 Configure MiniMax

MiniMax’s M2.5 is quite good—great cost-performance.

Get API Key

Visit MiniMax Open Platform
Register → Real-name authentication
Go to “API Keys” → Create Key
Copy and save—you can only see it once

Configuration Command

# Configure MiniMax
openclaw config set 'models.providers.minimax' --json '{
  "baseUrl": "https://api.minimaxi.com/v1",
  "apiKey": "your_MiniMax_API_Key",
  "api": "openai-completions",
  "models": [
    { "id": "MiniMax-M2.5", "name": "MiniMax M2.5" },
    { "id": "MiniMax-M2.5-highspeed", "name": "MiniMax M2.5 High Speed" }
  ]
}'

# Set as default model
openclaw models set minimax/MiniMax-M2.5

Safer Approach: Environment Variables

Store the key in environment variables instead of writing it in config:

# Temporary (only valid for current terminal)
$env.MINIMAX_API_KEY = "your_Key"

# Or permanent
[System.Environment]::SetEnvironmentVariable("MINIMAX_API_KEY", "your_Key", "User")

When configuring, use $MINIMAX_API_KEY instead of the actual key.

MiniMax Coding Plan (Recommended for Programmers)

If you mainly use it for programming, MiniMax offers a dedicated Coding Plan with better cost-performance.

Get API Key and Activate Coding Plan:

Visit MiniMax Open Platform
Register → Real-name authentication
Go to “API Keys” → Create Key
Go to “Coding Plan” page, activate Coding Plan
Copy and save the API Key

Configuration Command:

# Configure MiniMax Coding Plan
openclaw config set 'models.providers.minimax' --json '{
  "baseUrl": "https://api.minimaxi.com/v1",
  "apiKey": "your_MiniMax_API_Key",
  "api": "openai-completions",
  "models": [
    { "id": "MiniMax-M2.5", "name": "MiniMax M2.5" },
    { "id": "MiniMax-M2.5-highspeed", "name": "MiniMax M2.5 High Speed" }
  ]
}'

# Set as default model
openclaw models set minimax/MiniMax-M2.5

Tip: Coding Plan usually has lower calling prices, suitable for high-frequency users.

5.3 Configure Alibaba Cloud Model Studio

Alibaba Cloud Model Studio is a large model service platform provided by Alibaba Cloud, which you can use to access Qwen models and more. Besides the standard version, there’s also a dedicated Coding Plan for programming users.

Get API Key

Visit Alibaba Cloud Model Studio
Register → Real-name authentication
Go to “API Keys” → Create Key
Copy and save

Activate Coding Plan (Recommended for Programmers)

Visit Alibaba Cloud Bailian
Go to “Coding Plan” page
Activate Coding Plan
Get the dedicated Coding Plan API Key

Configuration Command

Standard Version:

# Configure Alibaba Cloud Model Studio
openclaw config set 'models.providers.qwen' --json '{
  "baseUrl": "https://dashscope.aliyuncs.com/compatible-mode/v1",
  "apiKey": "your_Alibaba_Cloud_API_Key",
  "models": [
    { "id": "qwen/qwen3-coder", "name": "Qwen Coder Model" },
    { "id": "qwen-portal/vision-model", "name": "Qwen Vision Model" },
    { "id": "qwen-plus", "name": "Qwen Plus" },
    { "id": "qwen-max", "name": "Qwen Max" }
  ]
}'

# Set as default
openclaw models set qwen/qwen/qwen3-coder

Coding Plan Version (if using Alibaba Cloud Coding Plan):

openclaw config set 'models.providers.qwen' --json '{
  "baseUrl": "https://coding.dashscope.aliyuncs.com/v1",
  "apiKey": "your_Coding_Plan_Key",
  "models": [
    { "id": "qwen3-max-2026-01-23", "name": "Qwen3 Max" },
    { "id": "MiniMax-M2.5", "name": "MiniMax M2.5" }
  ]
}'

Tip: Coding Plan usually has lower calling prices or free credits, suitable for high-frequency programming users.

5.4 Configure OpenRouter

OpenRouter is a platform that aggregates hundreds of AI models. Through it, you can use a single API Key to access GPT, Claude, DeepSeek, and many other models.

Get API Key

Visit OpenRouter Official Website
Register account
Go to “API Keys” → Create Key
Copy and save—you can only see it once

Configuration Command

openclaw config set 'models.providers.openrouter' --json '{
  "baseUrl": "https://openrouter.ai/api/v1",
  "apiKey": "your_OpenRouter_API_Key",
  "models": [
    { "id": "openai/gpt-5", "name": "GPT-5" },
    { "id": "anthropic/claude-4-sonnet", "name": "Claude 4 Sonnet" },
    { "id": "deepseek/deepseek-v3", "name": "DeepSeek V3" },
    { "id": "google/gemini-3-flash", "name": "Gemini 3 Flash" }
  ]
}'

# Set as default
openclaw models set openrouter/openai/gpt-5

Note: Model IDs on OpenRouter are formatted differently than direct calls—the format is provider/modelname, like openai/gpt-5, anthropic/claude-4-sonnet.

Reference: Check the OpenRouter Rankings to see model ratings and price rankings as a reference for selection.

5.5 Configure SiliconFlow

SiliconFlow is a domestic AI model aggregation platform in China, offering various model interfaces and is quite friendly for China users.

Features

Fast domestic access: Servers in China, low latency
Many model options: Supports Qwen, DeepSeek, Llama, and more
Affordable pricing: Pay-per-use with free credits

Configuration Reference

For detailed configuration tutorials, refer to the official documentation:

SiliconFlow Official Configuration Guide

Basic steps:

Visit SiliconFlow Official Website to register
Get API Key
Configure provider by referring to official docs

5.6 Configure OpenAI

If you have an OpenAI API Key, you can configure it directly.

Get API Key

Visit OpenAI Platform
Go to “API Keys” → Create Key
Copy and save

Note: China users may need to use a VPN to access OpenAI.

Configuration Command

openclaw config set 'models.providers.openai' --json '{
  "apiKey": "your_OpenAI_API_Key",
  "models": [
    { "id": "gpt-5", "name": "OpenAI GPT-5" },
    { "id": "gpt-4o", "name": "GPT-4o" },
    { "id": "gpt-4o-mini", "name": "GPT-4o Mini" }
  ]
}'

# Set as default
openclaw models set openai/gpt-5

5.7 Configure Qwen OAuth (Recommended)

Qwen OAuth is the most recommended configuration method because it has free credits and doesn’t require manually getting an API Key—just authorize with your Alibaba Cloud account.

Configuration Steps

Run the configuration wizard:
```
openclaw onboard
```
When selecting model provider, choose Qwen
Select Qwen OAuth
A browser window will pop up for you to log in with your Alibaba Cloud account for authorization
After successful authorization, select the model you want to use:
- qwen/qwen3-coder: Coding-specific
- qwen-portal/vision-model: Vision understanding

Manual Configuration (if wizard fails)

# Run OAuth authorization
openclaw config set oauth qwen

This will open a browser for you to complete the authorization process. After authorization completes, the configuration is saved automatically.

5.8 Configure Ollama Local Models

If you have a GPU and want to run models locally (zero API fees), you can use Ollama.

Important Concept: Ollama is responsible for running models locally, while OpenClaw needs to connect to Ollama through the Gateway.

5.8.1 Install Ollama

Visit Ollama Official Website
Download the Windows version
Run the installer—it will start automatically

If Ollama website is inaccessible, try these domestic mirror sources:

https://www.newbe.pro/Mirrors/Mirrors-ollama

https://ollama.ruanmao.net/

Ollama defaults to listening at http://localhost:11434.

For China Users: If you’re in Mainland China, you may encounter slow download speeds or unstable connections when downloading models. It’s recommended to configure a domestic mirror source (see below), which can significantly improve download speed.

Configure Domestic Mirror Sources (Optional, Recommended for China)

Domestic Mirror List:

Mirror Site	Address
ModelScope	https://ollama.modelscope.cn
DeepSeek	https://ollama.deepseek.com
Zhejiang University	https://ollama.zju.edu.cn
Domestic Collection	https://www.newbe.pro/Mirrors/Mirrors-ollama

Configuration method (Windows):

# Temporary effect
set OLLAMA_HOST=https://ollama.modelscope.cn

# Permanent effect
setx OLLAMA_HOST https://ollama.modelscope.cn

Linux / macOS:

export OLLAMA_HOST=https://ollama.modelscope.cn

After configuration, you can use commands like ollama pull qwen3 to download models. If download succeeds, the mirror is working.

Quick Tip: If a mirror download fails, try switching to another mirror source.

5.8.2 Download Models

VRAM Note: Larger models require more VRAM. 3B models need about 4-6GB VRAM, 8B models need about 8-12GB VRAM. Choose a suitable model based on your GPU.

Choose based on your PC configuration:

PC Configuration	Recommended Model
Entry-level (no discrete GPU or VRAM < 4GB)	phi3:mini, qwen2.5:1.8b
Mainstream (4-6GB VRAM)	qwen2.5:3b, qwen2.5-coder:3b, qwen3:4b
Mid-to-high end (8GB+ VRAM)	qwen3:8b, qwen3:14b

Tip: If Ollama doesn’t support Qwen3 yet, Qwen2.5 is still a great alternative.

# Check available models
ollama list

# Entry-level model (can run on CPU)
ollama pull phi3:mini

# Mainstream config - Chat model (recommended)
ollama pull qwen2.5:3b

# Mainstream config - Coding model
ollama pull qwen2.5-coder:3b

# Mid-to-high end - Stronger capability
ollama pull qwen3:8b

Tip: If VRAM isn’t enough, Ollama will automatically use a quantized version, or you can manually pull a quantized version like qwen2.5:3b-q4_K_M, which uses less VRAM.

5.8.3 Configure OpenClaw to Connect to Ollama

Configure OpenClaw to connect to local Ollama through Gateway:

openclaw config set 'models.providers.ollama' --json '{
  "baseUrl": "http://localhost:18789/v1",
  "apiKey": "ollama-local",
  "models": [
    { "id": "qwen2.5:3b", "name": "Qwen 2.5 3B" },
    { "id": "qwen2.5-coder:3b", "name": "Qwen 2.5 Coder 3B" },
    { "id": "qwen3:8b", "name": "Qwen 3 8B" },
    { "id": "phi3:mini", "name": "Phi-3 Mini" }
  ]
}'

# Set as default (3B model recommended; use qwen3:8b if you have 8GB+ VRAM)
openclaw models set ollama/qwen2.5:3b

Note: The Gateway address here is http://localhost:18789 (the port you specified when starting Gateway), not Ollama’s direct port 11434. This allows OpenClaw to centrally manage all model connections.

5.8.4 What is Gateway?

Gateway is OpenClaw’s backend service. You can think of it as a “translator”—OpenClaw talks to various models through it.

Simply put:

Gateway is responsible for centrally managing connections to various models
Gateway is responsible for handling authentication
Gateway is responsible for forwarding requests to different model providers

Architecture Diagram:

You
   ↓
OpenClaw CLI (where you enter commands)
   ↓
Gateway (manages connections)
   ↓
Model Providers
(MiniMax / Qwen / OpenRouter / Ollama)

Why is Gateway needed? Through Gateway as a unified entry point, OpenClaw can conveniently connect to various different model providers without configuring separate connection methods for each model.

5.8.5 Install Gateway

Gateway is usually automatically included when you install OpenClaw. If you need to install separately:

npm install -g @openclaw/gateway

5.8.6 Start Gateway

Gateway is OpenClaw’s core running process, responsible for:

Managing model connections
Providing HTTP / WebSocket API
Providing web control interface

Start Gateway (Recommended)

The simplest way is to run:

openclaw gateway run

This command starts the Gateway service. After starting, the default is:

http listener: //127.0.0.1:18789

You can open this address in your browser to access the web control interface for model configuration.

Common Parameters

If you need customization, you can use these parameters:

Parameter	Function	Example
`--port`	Specify port number	`--port 8080`
`--verbose`	Show detailed logs for troubleshooting	`--verbose`
`--force`	Force occupy the port	`--force`

Examples:

# Start with specified port
openclaw gateway run --port 8080

# Show detailed logs
openclaw gateway run --verbose

# Force occupy when port is in use
openclaw gateway run --force

5.8.7 Advanced Configuration (Optional)

If you want to further customize Gateway:

Option	Description
`--hot-reload`	Enable hot-reload, no restart needed for config changes
`SIGUSR1`	Send signal to restart Gateway (Linux/macOS)
`--config`	Specify config file path

Example:

# Hot-reload mode
openclaw gateway --port 18789 --hot-reload

Method 1: CLI Command Configuration

Use openclaw config set command to directly configure model parameters.

# Syntax
openclaw config set 'models.provider_name' --json '{
  "baseUrl": "https://api.example.com/v1",
  "apiKey": "your_API_Key",
  "models": [
    { "id": "model_id", "name": "display_name" }
  ]
}'

Example (Configuring MiniMax):

openclaw config set 'models.providers.minimax' --json '{
  "baseUrl": "https://api.minimaxi.com/v1",
  "apiKey": "your_MiniMax_API_Key",
  "api": "openai-completions",
  "models": [
    { "id": "MiniMax-M2.5", "name": "MiniMax M2.5" }
  ]
}'

Pros: Fast, good for automation scripts Cons: Need to remember command syntax

Method 2: Edit Config File

Directly edit OpenClaw’s config file claude.json.

Config file location:

Windows: %USERPROFILE%\.openclaw\claude.json
macOS/Linux: ~/.openclaw/claude.json

Example Config:

{
  "models": {
    "providers": {
      "minimax": {
        "baseUrl": "https://api.minimaxi.com/v1",
        "apiKey": "your_MiniMax_API_Key",
        "api": "openai-completions",
        "models": [
          { "id": "MiniMax-M2.5", "name": "MiniMax M2.5" }
        ]
      }
    }
  }
}

Pros: Batch configuration easy, easy to backup Cons: Need to manually edit JSON format

Method 3: Web Page Configuration (Recommended for Beginners)

Besides command line and config files, you can also configure models through the Web Interface. This method is more intuitive and suitable for beginners.

Step 1: Start Gateway

Gateway not only provides API services but also has a built-in web control interface. Run in terminal:

openclaw gateway run

This command starts the Gateway service and runs in the background.

Step 2: Open Browser to Access

Gateway’s web interface default address is:

http://127.0.0.1:18789

Open this address in your browser—you’ll see the Gateway management interface.

Step 3: Enter Configuration Page

Find and click in the interface:

Config → Models

Here you can manage all model configurations.

Step 4: Add Provider Configuration

Taking adding MiniMax as an example:

Click Add Provider or similar button
Select or fill in Provider type
Fill in the following information:

Field	Value
Base URL	`https://api.minimaxi.com/v1`
API Key	Your MiniMax API Key

Enable Auth Header option (if needed)
Fill in API Key

Step 5: Save Configuration

Click Save or Update button to save the configuration.

Tip: After saving, Gateway will automatically refresh the config. You may need to restart OpenClaw for changes to take effect.

The benefits of this method:

Visual operation, no need to remember commands
See configuration status in real-time
Suitable for users unfamiliar with command line

6. Using cc-switch to Manage APIs (Recommended)

If you’ve configured multiple model providers, manually changing config each time can be tedious. cc-switch is a cross-platform desktop tool that helps you switch between different AI API configurations with one click. It supports Claude Code, OpenClaw, Gemini, and more.

6.1 Why Use cc-switch?

Problems with manually managing API Keys:

Need to separately configure environment variables for each provider
Switching models requires modifying JSON config
Easy to get confused with multiple accounts/providers

cc-switch advantages:

Visual interface, no need to edit command line configs
One-click provider switching
Supports MCP server management
Supports Skills/Prompts presets

6.2 How cc-switch Works

Important: cc-switch writes the currently enabled provider configuration to environment variables. When OpenClaw starts, it automatically reads these environment variables, so you don’t need to manually edit OpenClaw’s config file.

This is the convenience of cc-switch: you just switch the provider in cc-switch, then start OpenClaw, and it will automatically use the current configuration.

6.3 Install cc-switch

Windows:

Visit cc-switch GitHub Releases
Download CC-Switch-v{version}-Windows.msi or portable version
Run the installer

macOS:

brew tap farion1231/ccswitch
brew install --cask cc-switch

Linux:

Supports .deb, .rpm, .AppImage and other formats.

6.4 Add Provider

Start cc-switch
Click ”+” in the top right or “Add Provider”
Select preset provider (MiniMax, Qwen, etc.)
Fill in your API Key
Click “Add”

6.5 Switch Provider

In the main interface, select the provider you want to use
Click “Enable”
Restart OpenClaw (if it’s running)

6.6 OpenClaw Automatically Uses Current Config

cc-switch writes the currently enabled provider configuration to environment variables. When OpenClaw starts, it automatically reads these environment variables, so you only need to:

# After switching provider, restart OpenClaw
openclaw restart
# or
openclaw serve

OpenClaw will automatically use the API configuration currently enabled in cc-switch.

7. Starting and Using

After configuring the model, you’re ready to use it.

# Interactive chat
openclaw

# Start web service
openclaw serve --port 3000

# Start Gateway (if not auto-started)
openclaw gateway run

# Web panel
openclaw dashboard

Just type text to chat. If tools are configured, it can also help you operate files, search for information, and more.

8. Recommended Configurations

For different scenarios, here’s a reference:

Scenario	Recommended Model	Reason
Programming	qwen/qwen3-coder	Specifically optimized for coding, good GitHub integration
Vision Understanding	qwen-portal/vision-model	Supports image understanding
Daily Chat	MiniMax-M2.5	Good Chinese understanding, great cost-performance
Deep Reasoning	Qwen3-Max	Strong capability
Local Offline	Ollama qwen2.5:3b	Mainstream config usable, completely free

My usual combo: Use MiniMax for daily use, switch to qwen/qwen3-coder for programming.

Switching models is easy:

# Switch to MiniMax
openclaw models set minimax/MiniMax-M2.5

# Switch to Qwen for programming
openclaw models set qwen/qwen/qwen3-coder

# Switch to Qwen Vision
openclaw models set qwen/qwen-portal/vision-model

9. Common Issues

Command Not Found

# Check if installed
npm list -g openclaw

# Restart PowerShell and try again

# If still not working, reinstall
npm install -g openclaw@latest

API Key Error

Check if Key is correct, no extra spaces
Check if there’s still balance
Recommended to use environment variable method

Ollama Connection Failed

# Confirm Ollama is running
ollama list

# Try accessing
curl http://localhost:11434

Gateway Connection Failed

# Confirm Gateway is running
openclaw gateway run

# If port is occupied, add --force to force start
openclaw gateway run --force

# Or specify another port
openclaw gateway run --port 8080

Response Too Slow

Remote API: Check network, or try another model
Ollama: Consider using smaller models like qwen2.5:3b or quantized version qwen2.5:3b-q4_K_M

Installation Script Error

Confirm execution policy is changed:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

10. Alternative: Tencent Workflow AI (WorkBuddy)

If you find OpenClaw deployment too complicated, consider Tencent Workflow AI (also known as WorkBuddy).

What is WorkBuddy?

WorkBuddy is an AI programming assistant released by Tencent, similar to Cursor and Windsurf products. It doesn’t require local deployment—just use VS Code or JetBrains plugins directly.

Features

No deployment needed: Install plugin and use immediately
Generous free credits: Tencent provides free usage quotas
Well-optimized for Chinese: Friendly for Chinese developers
Integrates Tencent ecosystem: Can connect to WeChat, Tencent Cloud, and other services

Who It’s For

Programming beginners who don’t want to deal with environment setup
Those who want a plug-and-play experience
Those who simply want to experience AI programming assistance

Comparison with OpenClaw

Feature	OpenClaw	WorkBuddy
Deployment	Local deployment	No deployment needed
Customization	High	Medium
Learning curve	Higher	Lower
Cost	Free/Paid	Has free credits

Summary: If you just want to experience AI programming assistance, WorkBuddy is a simpler choice. If you want higher customization and scalability, OpenClaw is still the better choice.

Conclusion

This tutorial might still not be detailed enough, but I’ve written a very basic detailed configuration tutorial. I’ll update with more detailed LLM parameter explanations later. I may also update detailed tutorials on integrating OpenClaw with Feishu and more.

Cloudflare Domain Registration Guide

Tue, 17 Feb 2026 00:00:00 GMT

Introduction

I wanted to add some features to my blog lately—GitHub login, Cloudflare ecosystem, SEO optimization, you name it. Problem is, I didn’t have a domain name. Every time I tried to set something up, it just… failed because of that. So I figured, why not just buy one? It’s not that expensive—maybe a few dozen bucks a year. I’ve done this before anyway, just never paid for it myself.

Why Choose Cloudflare for Domain Registration?

Cloudflare Registrar stands out because they don’t markup prices. Unlike traditional registrars that profit from domain sales, Cloudflare uses domains as a gateway to their ecosystem.

True wholesale pricing: Cloudflare promises to sell domains at cost forever. Every penny you pay goes directly to the registry—no hidden fees, and renewal prices stay the same. No “cheap first year, expensive second year” tricks.
Free privacy protection: WHOIS privacy protection comes standard, hiding your name, email, and address. Other registrars often charge extra for this.
Top-tier security: Free enterprise-grade DNSSEC to prevent domain hijacking, plus hardware key support (like YubiKey) for login. Maximum security.
All-in-one management: If you’re deploying on Cloudflare anyway, buying your domain here saves you the DNS wait time. Certificate requests and DNS resolution happen automatically.

Here’s a quick comparison:

Aspect	Cloudflare	Traditional Registrars (Aliyun/Tencent/Namecheap)
Pricing	Cost price, no markup	Market price, cheap first year, expensive renewal
Privacy	Free by default	Free or extra cost
Experience	Developer-friendly, high integration	Feature-spread, more config needed
ICP License	Not supported (China MIIT)	Supported (China MIIT)

One downside: Cloudflare doesn’t support China MIIT ICP filing. Whether you need that depends on your situation. For me, it’s not really necessary—my hosting is on Cloudflare, the only real cost is the domain, and Cloudflare’s CDN works fine in China. If I ever need ICP filing later, I’d need to get a Chinese server and a Chinese domain.

So if you’re not planning to file in China and you’re using Cloudflare’s ecosystem, Cloudflare is the endpoint for domains.

Prerequisites

Cloudflare account
Visa card or PayPal

If you don’t have a Cloudflare account yet, just sign up with your Google or GitHub account.

Payment Prep (ICBC Student Card Example)

For international payments like Visa or PayPal, it can be tricky if you’re in China. If you can’t find someone to help you pay, you’ll need your own solution. Many banks offer Visa cards for students—here’s an example with ICBC’s Star Sign Card (this is just to help fellow students, not an ad).

Application requirements: Undergraduate or above, try to keep student cards under 2-3, online loans (Huabei, Baitiao, etc.) under 2 accounts.

Card features:

UnionPay (CNY) + Visa (foreign currency) combo card, regular card, free annual fee.
Campus version has 0 credit limit in most regions! Non-campus version requires work/internship proof.
11 currency accounts—doesn’t affect credit score.

Application steps:

Open ICBC app, search “星座卡学生办” (Star Sign Student)
Select 宇宙星座卡校园版 (VISA + UnionPay)
Fill in your info and mailing address
Once you get the card, activate it at a nearby branch

Note: Don’t apply in a different city from where you registered. If your bank is in your hometown but you’re studying in another province, you might not be able to activate it. Pick a convenient location.

Converting to USD:

Open ICBC app, search “美元兑换”
Select 结售汇 → 购汇
Buy USD as needed
Check your card’s USD balance after getting the SMS

Don’t just have exactly enough USD for your domain—some international sites have minimum payment amounts. Worth getting a Visa card anyway, you’ll use it eventually.

Cloudflare Domain Registration Steps

Go to https://www.cloudflare.com/products/registrar/ to learn about Cloudflare’s domain registration. You can also find it by searching “Cloudflare domain purchase” or go directly to https://dash.cloudflare.com/domains.

Search for your desired domain. Let’s use danarnoux as example—you’ll see many TLD options.

Here’s a quick reference for common TLDs:

TLD	Type	Best For	Notes
.com	Generic	Top choice. Blogs, brands	Highest recognition, good for SEO.
.net	Generic	Tech blogs, network services	Professional, good .com backup.
.org	Non-profit	Open source, communities	Trustworthy, great for non-profit tech communities.
.io	Tech	Tech blogs, dev tools	Super popular among programmers.
.me	Personal	Resumes, portfolios	Perfect for personal branding.
.info	Info	Knowledge bases, docs	Usually cheaper, good for info sites.
.dev	Developer	Tutorials, code repos	Google-owned, forced HTTPS, very recognizable.

You might notice .uk is much cheaper than .com. My advice? Don’t chase the cheap price.

.uk is the United Kingdom’s country code TLD, managed by Nominet (like .cn for China or .us for the US). You can buy it, but there’s a UK address requirement. Without a UK address, many registrars (including Cloudflare) might reject your registration or require proxy services. If you provide a fake UK address, the domain could get suspended during random audits.

Just pick what you want. Remember to check availability and renewal prices.

Buying the Domain

Select your domain and click Confirm
Choose your billing period (years). Decide whether to enable Automatic renewal
Fill in your details and invoice info
When paying with card, be careful with the security code—three wrong attempts locks your card. You’ll need to report it lost and get a new one.
If your card gets declined, check your USD balance, verify the security code and card number. Contact your bank if needed. One issue I ran into: payment gateway rejected me because of location/IP mismatch. I stopped using Hong Kong nodes and it worked. Try it if you have similar issues—just might be slower.
Check your email for the invoice and card balance.
Go to Domains in the sidebar to confirm your purchased domain is there.

DNS Settings

Click Domains in the sidebar, then the three dots to configure DNS.

You can follow my setup—use CNAME for analysis. The redacted parts aren’t important. Cloudflare Proxy (the orange cloud) should be enabled by default for better speed and security. Don’t forget to save.

Wrapping Up

I won’t go into SSL/TLS details here—Cloudflare sets up a universal certificate by default. I’ll cover more in future posts, like how to do SEO right and GitHub OAuth. Stay tuned!

Video Guide: https://www.bilibili.com/video/BV1tvc6z1EfD/?share_source=copy_web&vd_source=b29b2491306fe84f395d46cf297dc405

How to Get Started with Programming: Tools, Git, and Engineering Thinking

Tue, 17 Feb 2026 00:00:00 GMT

Preface

I’ve always believed this: people can’t imagine things outside what they already know. Even with AI this strong now, you still might not be able to build something you’re truly satisfied with just by prompting. And yes, you might feel anxious too. If AI is so powerful, does learning programming still matter? Won’t programmers be replaced anyway?

I know you have a lot of questions. In my view, times change and answers change every day. Rules that work today may not work tomorrow, and rules that work tomorrow may not work today either. Instead of staying in the dark, I’d rather you understand at least a bit of how things work. Nothing in this world is really that mystical. If possible, touch it with your own hands. I really like this line: “Practice is the only criterion for testing truth.”

Learning a skill is an honorable thing, and it can become a lifelong hobby. Whether you’re in middle school or just entered university, I think it’s worth learning how to use computers well, and even how to code and build projects.

I also think everyone has talent in some area. Sometimes it’s just not discovered yet because of environment or life experience. Maybe I walk past future geniuses every day and they don’t even know it. What I hope is that more students get sparked by one accidental moment when they’re young, then turn that spark into a real hobby.

As for me, I’m from Zhejiang. In high school we had a technical elective, and the information technology part was Python. Back then our school had an OJ problem site. Everyone loved occupying the computers to solve problems, and in free time we explored a lot of fun stuff. We didn’t realize it then, but that was the start of a different life path for many of us.

Whether you’re in engineering or the humanities, I still think it’s useful to understand these core ideas. When you make decisions later, I can’t guarantee you won’t feel confused. Sometimes knowing more actually gives you more confusion first. But then a big question mark appears in your mind, and you finally start thinking in a directed way.

1. What Is Programming

Programming is not as mysterious as it looks. It’s more like an engineering expression skill: break a problem down, arrange the steps, and let the machine execute them reliably.

You don’t need to understand every low-level detail at the beginning. Just remember one thing first: you’re not writing flashy syntax, you’re building a process that can be reproduced, debugged, and maintained.

1.1 Where Programming Sits in the Computer Stack

Think of it as a bottom-up chain. At the bottom is hardware: CPU, memory, and storage. The CPU also has its architecture (x86, ARM), which decides which instruction set the machine can understand.

Above that is the operating system (Windows / Linux / macOS). It manages the hardware and gives programs a unified interface. When your code touches files, network, or windows, the OS is what handles all that underneath.

Programming languages sit in the middle as a translation layer. You write Python or C, but the machine finally executes lower-level instructions. At the top are applications, like the browser or editor you click every day, or the small tools you build yourself.

What are Windows and Linux?

Windows and Linux are operating systems, not programming languages. You can think of them as managers: they allocate hardware resources and define execution rules.

I’ve seen many beginners confuse “I can use Windows” with “I can program.” That’s normal. An OS is more like the runtime environment. It decides how programs access files, request memory, and talk to devices.

The system is the stage, the program is the actor, and the language is how you write the script. Once you separate these roles, a lot of concepts stop mixing together.

1.2 Paths and Directories: Path, Root Directory, Relative Path

You can think of a path as an address and house number. When a program looks for a file, it’s really asking, “Where exactly is it?”

For example, C:\Users\Dan\Desktop\learning\hello.txt is a full address. When you use cd in a terminal, you’re walking to the right floor first, then picking up the file.

Here’s a very common pitfall: Chinese folder names are not always impossible, but with some toolchains, encoding settings, old libraries, or command-line combinations, non-ASCII paths can occasionally cause weird issues. To reduce random trouble, using English folder names is usually safer: short names like test, folder, project, data, output work great.

What is the root directory

In Windows, C:\ is a root. You can treat it like a top-level entry point, then beneath it you have user directories, project directories, and data directories. Long paths are just layers going down from this entry.

What is a relative path

A relative path is written relative to your current directory. An absolute path like C:\Users\Dan\Desktop\learning\hello.txt goes straight to the target. A relative path like .\hello.txt or data\input.txt starts from where you’re standing now.

The most common reason relative paths fail is not that the file doesn’t exist, but that you’re in the wrong directory. You think you’re in learning, but your terminal is still one level above.

Windows users can skip this short part:
On Mac, the root directory is /, and your home directory is usually /Users/your-username.
Relative path rules are the same, typically ./ and ../.

1.3 Architecture Differences: x86 vs ARM

x86 and ARM are two mainstream CPU architectures. You can treat them as two different machine dialects. Traditional PCs have long been mostly x86, phones and tablets are mostly ARM, and new Macs (Apple Silicon) are ARM too.

Your code is always translated into instructions the target architecture can execute. Over time you’ll notice: the same code on different devices can have compatibility differences. Often that’s not your coding mistake, just platform differences underneath.

Where programming languages fit in this system

This is where people mix things up most easily. Python is not an OS, and C is not a CPU. A language is a translation layer that organizes your ideas into something machines can run.

Once this position is clear, terms like “system error,” “interpreter version,” and “architecture compatibility” stop feeling like one tangled ball.

1.4 Core Programming Concepts: Flow, Script, Variables, Coding

A grounded example: batch-renaming images in your Downloads folder. First locate the target directory, then filter .jpg / .png, then define sorting and naming rules, and finally log failed items and retry.

You’ll notice what matters is process design, not how many syntax tricks you memorized. That’s algorithmic thinking. Language is a tool; process is the core.

What is a script?

A script is a small program for a specific task. The point is reducing repetitive work.

Things like organizing your Downloads folder, batch-renaming files, and auto-summarizing text are all script-friendly. It doesn’t have to be complex to be very practical.

What is a variable?

A variable is a name for data. Good names make code readable even days later; random names make code turn into riddles quickly.

If you’re counting images, image_count needs no explanation. If you call it a1, even you may have to guess what it means after three days. I made this mistake when I first wrote scripts: the code ran, but a month later I didn’t even want to touch it.

Variables look small, but they directly affect readability and your debugging speed later.

What is coding?

From another angle, coding is not a typing competition. It’s organization ability. You’re breaking an idea into executable structure: where variables go, how flow moves, how functions split, how modules are separated. Here, “coding” means writing code and turning ideas into programs, not character encodings like UTF-8.

If the structure is clear, future changes are easier. If the structure is messy, every new feature hurts. It’s normal if this still feels vague now. Start from one rule: write code that you yourself can understand later.

1.5 English and Reading Errors: Important, But Don’t Panic

Don’t turn this into an anxiety competition. You don’t need to memorize a whole dictionary before learning programming. I don’t suggest you pause coding to formally “start learning English first”; learn while doing.

But one thing is practical: sooner or later you’ll read English errors, English docs, and English issues. Whether you can extract key information directly affects your debugging speed.

So the goal is not “perfect English.” The goal is: understand core technical words, and understand your own variable names and error messages.

1.6 Common Beginner Mistakes and Mindset

I’ve seen many beginners get stuck in similar places: memorizing syntax without building anything, watching videos without hands-on practice, stopping at the first error, treating AI as magic without verification, or endlessly “preparing” without starting. And for AI specifically, asking it to build a whole website when you don’t know your own requirements is like becoming a vague client; the result often won’t match what you want.

These are usually rhythm problems, not ability problems. Build one tiny runnable result first, then add complexity step by step. Your mindset gets much steadier that way.

Pick the route first, then install tools

Many beginners get stuck on environment setup before writing a single line of code.

I recommend deciding direction first: pick Python as your first language, then run the minimum loop: “write -> run -> fix.”

Once you feel “it runs,” tool details become much easier to digest. Next I’ll talk about language choice first, then environment setup.

2. C or Python?

I’ll give you a stable recommendation here: learn Python first. Whether you’re from humanities, science/engineering, changing careers, or still in school, Python is usually the easiest way to build early positive feedback.

2.1 Why Start with Python

Python’s biggest advantage is fast feedback. You write a few lines and see a result immediately. That’s huge for beginners, because you keep getting the feeling that “I’m actually moving forward.” If you get timely positive feedback while learning, you’re more likely to stay interested and improve faster. I don’t want your first experience to be pure frustration from starting too hard.

Its syntax is also more intuitive, and its resources/community are mature. When you hit problems, there are usually workable answers. I’ve seen many beginners quit not because coding is impossible, but because they get no positive feedback for too long. Python is genuinely friendlier here.

2.2 Python in 10 Minutes (Up to Loops)

Let’s define scope first: this part only takes you up to loops, enough to run your first small program. Functions, lists, dicts, and file operations are intentionally not expanded here. You can verify this later after finishing environment setup, or skip to 2.4 for now.

Think of variables as “naming data.” Clear names make code easier to read.

name = "Dan"
age = 18
print(name, age)

After running, you should see one line like Dan 18.

print() outputs, input() takes input. input() returns a string, so convert with int() before numeric operations.

age = int(input("请输入你的年龄："))
print("明年你是", age + 1, "岁")

After running, enter a number and you’ll see “next year you are xx years old.”

if is conditional branching: only execute that branch when the condition is met.

score = 72
if score >= 60:
    print("及格")
else:
    print("再练练")

After running, you’ll see Pass (because the example score is 72).

for is commonly used for fixed-count repetition. range(5) is 0 to 4; range(1, 6) is 1 to 5.

for i in range(1, 6):
    print(i)

After running, it prints 1 through 5 line by line.

while is for “keep looping while condition is true.” For example, accumulate until reaching 100:

total = 0
n = 1
while total < 100:
    total += n
    n += 1
print(total, n - 1)

After running, it prints the accumulated result and the last added number (something like 105 14).

2.3 Self-Learning Entry and Mini Exercises

Once you can handle loops, you have enough to start. For functions, lists, dicts, files, and modules, learn them next by yourself. The core isn’t “memorize everything”; it’s learning to search, read docs, and verify outputs.

A good place to start is Runoob: https://www.runoob.com/. When you meet new syntax, don’t rush to memorize. Run a minimal example first and see exactly what it does.

Here’s one mini exercise. Get a working result first, then optimize gradually:

Narcissistic numbers (also called Armstrong numbers): for an n-digit number, the sum of each digit to the power of n equals the number itself. For 3-digit numbers, it means the sum of cubes of each digit equals the original number. I want you to find all narcissistic numbers in 100~999.
Hint: split into hundreds/tens/ones, cube each digit, compare with the original number.

2.4 Python Use Cases and Language Comparison

Its use cases are broad. In humanities, you can do text analysis, spreadsheet cleaning, and visualization. In economics/finance, common tasks include indicator calculations and report automation. In geography, you can process cloud maps and spatial data. On the science/engineering side, it’s great for experiment data cleaning, batch plotting, parameter scanning, and simple numerical computation. Move one step further and you’ll see it in automation scripts, web backends, AI preprocessing, and training scripts. You don’t need to master all of this at once. Build one small result in the scenario you care about most first; your learning speed will be much higher.

Python vs C: a minimal example

Same goal: print 1 to 5.

Python:

for i in range(1, 6):
    print(i)

#include <stdio.h>

int main() {
    for (int i = 1; i <= 5; i++) {
        printf("%d\n", i);
    }
    return 0;
}

This example isn’t to say one language is “more advanced.” It’s just to show entry friction differences directly.

2.5 Should You Learn C Later?

Should you learn it? Depends on your direction. Build programming intuition with Python first. If you later move into systems, performance, or low-level work, adding C becomes much smoother.

A minimal starter route

Learn Python basics first (variables, branching, loops, functions).
Build one runnable script (for example, batch rename).
When you hit errors, search, fix, and rerun.

Run this route once, and your foundation is stable.

3. Development Environment Setup

3.1 Editors and IDEs: Why Start with VS Code

If you’re just starting, I’d suggest Visual Studio Code first.

Let’s define IDE quickly. IDE (Integrated Development Environment) is like an all-in-one toolkit: editor, debugger, runner, project management, and so on. PyCharm and Visual Studio are typical IDEs.

I don’t recommend heavy IDEs on day one, not because they’re bad, but because too many features can distract you from the core question: “How does code actually run?” At the beginning, understanding that baseline flow matters more.

VS Code sits between a plain editor and a heavy IDE: lightweight by default, expandable when needed, enough without overload. That balance is very beginner-friendly.

The reasons are practical: cross-language support, mature extension ecosystem, usable integrated terminal, and handy Git integration. One unified toolchain means less mental load early on.

I got stuck during my first setup too. So many options on screen felt overwhelming. That’s normal. Get the toolchain running first; tune habits later.

Official site: https://code.visualstudio.com/.

Install the minimum set of extensions first; enough is enough:

Python (ms-python.python)
Pylance (ms-python.vscode-pylance)
Markdown All in One (yzhang.markdown-all-in-one)
GitLens (eamodio.gitlens, optional)

3.2 Python Extension and Interpreter: What VS Code Actually Does

This part confuses beginners easily. The Python and Pylance extensions mainly provide editor features: syntax highlighting, completion, jump-to-definition, type hints, debugging entry, etc.

They make writing smoother, but they are not the Python interpreter itself. The key sentence again: installing Python extension in VS Code does not mean Python is installed on your computer.

One layer deeper: VS Code is mostly your “write code and organize projects” workstation, not the runtime itself. It can call your system terminal, interpreter, and Git, but it does not install Python for you. Whether python runs in VS Code depends on whether your system has a usable interpreter and correct path config.

The Select Interpreter action in VS Code is basically telling the editor which Python on your machine this project should use.

Try this once directly: open VS Code, press Ctrl + Shift + P, type Python: Select Interpreter, then choose the learn environment you created. If you pick the wrong one, VS Code may run a different Python than the one you just installed.

After selecting correctly, the status bar usually shows the current Python environment/version (position may vary by theme). That’s the most direct success signal.

3.3 VS Code Installation, Chinese Language Pack, and Extensions

Start with the safest path. Don’t tweak too many options at first.

Go to the VS Code site and download the Windows installer.
You should see a clear Download for Windows button.
During installation, recommended options:
- Add to PATH
- Open with Code
- (optional) Register Code as an editor for supported file types
Launch VS Code after installation.
You should see the left activity bar (Explorer/Search/Source Control/Run/Extensions).
Open Extensions (the square icon), search and install the Simplified Chinese pack:
Chinese (Simplified) Language Pack for Visual Studio Code (official Microsoft pack).
Restart VS Code when prompted.
After restart, UI should switch to Chinese (if not, manually switch display language in Command Palette).
If you prefer Traditional Chinese, there’s also:
Chinese (Traditional) Language Pack for Visual Studio Code.
Do three things on first launch:
- Switch UI language to what you’re comfortable with.
- Install the minimal extension list above.
- Press Ctrl + ~ to open terminal and confirm commands can be entered normally.

Windows users can skip this short part:
VS Code also provides a macOS build at https://code.visualstudio.com/.
After install, open it directly; extension logic and interpreter selection are basically the same as on Windows.

What is a development environment?

Think of it as your programming workbench. The editor is for writing code, interpreter/compiler turns code into runnable behavior, and terminal is where you run commands and execute programs.

Package managers (like pip, conda) install and manage dependencies, while runtime defines what conditions your code runs under. You don’t need to master everything at once; it’s enough to know these parts work together.

3.4 Terminal and Win+R: Get Command Line Running First

What are CMD, PowerShell, and VS Code terminal exactly?

At first the black window may feel scary, but it’s just a place to type commands.

They’re all command-line entry points. CMD is simpler and easier to start with. PowerShell is more powerful. VS Code Terminal is basically one of these embedded in your editor so you switch fewer windows.

Pick one first. I suggest CMD.

Memorize a few core commands first: cd to change directory, dir to list files, mkdir to create directory, rmdir to remove empty directory, echo to output text, cls to clear screen.

Try this 3-minute exercise (copy-paste ready):

mkdir "%USERPROFILE%\Desktop\learning"  # 创建 learning 文件夹
cd /d "%USERPROFILE%\Desktop\learning"  # 进入 learning 文件夹（/d 支持切换盘符）
echo Hello Programming > hello.txt      # 创建并写入 hello.txt
dir                                     # 查看当前目录内容
type hello.txt                          # 查看文件内容
mkdir temp                              # 创建 temp 子文件夹
rmdir temp                              # 删除空的 temp 子文件夹
cls                                     # 清空终端屏幕

You will most likely see: after dir, hello.txt appears in the list; after type hello.txt, output is Hello Programming.

Two common pitfalls: forgetting cd /d so drive letter doesn’t switch; or creating files before entering learning, so files appear elsewhere.

If you understand what each command does, you’ve cleared the first terminal hurdle.

How to open system command line (Win + R)

If you’re not inside VS Code, open system command line directly: press Win + R, type cmd, press Enter.

After opening, you’ll usually see a prompt like C:\Users\your-username>. That’s your current directory.

If you accidentally open PowerShell, no need to panic. Most basic commands still work. Getting the workflow running matters most.

The terminal at the bottom of VS Code is essentially the same command-line environment embedded in the editor. Many commands follow the exact same logic.

Mac users can skip this Windows part:
On Mac, open Terminal (search Terminal with Spotlight).
Most commands are similar; Windows commonly uses cmd, Mac commonly uses bash/zsh.

3.5 Python Runtime, Miniconda, and Installation Route

I recommend Miniconda. Maybe Anaconda can be better in some cases, but I still hope you get familiar with terminal operations.

I still recommend Miniconda because it’s lightweight, controllable, and great for environment isolation.

Miniconda official download page: https://docs.conda.io/en/latest/miniconda.html.

Remember three words first: Python version (e.g. 3.10, 3.11), packages (third-party libraries like requests), and virtual environment (each project uses its own dependencies without conflicts).

Where is Python actually installed?

There are two common ways to install Python. One is direct install from the official Python site: https://www.python.org/. The other is installing Miniconda, which also includes its own Python.

Both ways work. Pick one. For beginners, I recommend starting with Miniconda to save trouble when you isolate environments later.

One more time for the most common misunderstanding: installing Python extension in VS Code does not mean Python is installed on your computer.

How to confirm Python is really installed

After installation, run this minimum check first:

python --version      # 查看 Python 版本
where python          # 查看 python 执行路径

Normally you’ll see something like Python 3.11.x, plus a python.exe path pointing to your Miniconda directory.

If python --version doesn’t respond or says command not found, PATH is usually not effective yet, or terminal session wasn’t refreshed. If where python points to a non-Miniconda path, you likely have multiple Python installs or PATH order is pointing to a different one first.

After changing PATH, remember to close all terminal windows and reopen.

If you can see both version and clear path, your runtime is basically ready. If not, don’t panic. Most of the time it’s just environment variables or terminal session not refreshed.

Use Tsinghua Mirror for Acceleration (Strongly recommended for users in mainland China)

Tsinghua open-source mirror: https://mirrors.tuna.tsinghua.edu.cn/. You can think of the “Tsinghua source” as a synchronized domestic mirror of official repositories. It’s not a modified fork; content still comes from upstream, just via a more stable local route.

If you’ve tried installing pandas or numpy in China, you’ve probably seen commands freeze for a long time. Often that’s not your code, just unstable default source connectivity. Switching to mirror usually makes downloads much smoother.

If you want to confirm paths yourself: open the mirror homepage, search anaconda, and you’ll find common channels. pkgs/main is core packages, pkgs/free is older compatibility packages, cloud/conda-forge is community-maintained packages with faster updates.

A channel is basically the repository list conda checks in order when resolving packages. Run the following in Miniconda Prompt, not plain CMD:

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/         # 添加主仓库镜像（常用基础包）
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/         # 添加历史仓库镜像（兼容旧依赖）
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/ # 添加 conda-forge 镜像（社区包更全）
conda config --set show_channel_urls yes                                                      # 显示包来源通道，排错时更容易定位

pip uses official PyPI by default, which can also be slow on some domestic networks. Setting index-url becomes persistent:

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple  # 设置 pip 默认镜像（持久生效）
pip config list                                                            # 查看配置是否生效

If you want to revert to default source later, run:

pip config unset global.index-url  # 取消自定义镜像，恢复默认 PyPI

3.6 Miniconda Installation and Verification Loop

I’ll split this into “domestic download” and “international download.” Follow it and you’ll close the loop.

Domestic users (Tsinghua mirror) download path

Open https://mirrors.tuna.tsinghua.edu.cn/.
On the homepage, look at the “download links” module on the right.
Click the blue button “Get download links”.
In the popup, switch to “Applications (or Application Software)” tab, select Conda on the left, then choose Miniconda3-latest (Windows/x86_64, exe) on the right.
x86_64 means 64-bit Windows, which is most computers; don’t select Linux .sh or macOS .pkg.
Downloaded filename usually looks like Miniconda3-latest-Windows-x86_64.exe; this format is normally correct.
Save the .exe installer to an English-path directory (like Downloads).

International users (official site) download path

Open https://docs.conda.io/en/latest/miniconda.html.
Find Windows 64-bit Installer.
Download the corresponding .exe installer.

Windows users can skip this short part:
Mac users can download macOS builds on the same page (choose Apple Silicon / Intel based on your device).
After installation, run conda --version in Terminal for a minimum verification.

After download, installation steps are:

Double-click installer.
For user scope, Just Me is recommended (less permission issues on personal machines).
Installation path recommendation: C:\Miniconda3; avoid Chinese path and spaces.
Add Miniconda to PATH: if this is your first install, checking it is recommended so python and conda work directly in CMD. If you later manage multiple Python versions, you can adopt stricter isolation workflows.
Register Miniconda as default Python is recommended, so common tools prioritize this Python. If your existing projects depend on another Python, decide based on your situation.
After installation, search Start Menu and open Miniconda Prompt.

If you don’t want to modify system PATH, you can leave it unchecked; but for beginners, checking it usually avoids more pitfalls. I’ll also show verification and manual handling below. Verify immediately after install

After installation, run these three commands in Miniconda Prompt:

conda --version              # 确认 conda 可用
python --version             # 确认 Python 可用（来自 Miniconda）
where python                 # 确认 python 路径指向 Miniconda 目录

conda --version should output something like conda 24.x.x
python --version should output something like Python 3.11.x
first path in where python usually should point to C:\Miniconda3\python.exe (or your own Miniconda directory)
where python may print multiple lines; the first line is the currently prioritized Python.

3.7 PATH Environment Variable: Manual Handling When You Don’t Check It

This sounds very “system settings” at first, but once you do it once, it becomes easy.

Right-click “This PC” on desktop or in Explorer.
Click “Properties”.
Click “Advanced system settings”.
In the popup, click “Environment Variables”.
In “System variables”, find Path.
Click “Edit”.
Click “New”.
Add your Miniconda directory, e.g. C:\Miniconda3.
Click “New” again and add C:\Miniconda3\Scripts.
Click “OK” all the way to save.
Close all opened terminals, then reopen.

You can think of PATH as the system’s “search directory list” for executables. When you type python in cmd, Windows checks this list top-to-bottom to find python.exe. If the directory isn’t listed, command line will say it can’t find Python.

Why reopen terminal? Because terminal reads an environment snapshot when it launches. If you change PATH later, old windows won’t auto-refresh; only new windows read the new values.

How to verify PATH is effective

After configuration, check immediately:

where python   # 查看 python 实际命中路径
echo %PATH%    # 打印当前 PATH 列表，确认是否包含 Miniconda 目录

If where python shows your newly configured path, it’s basically effective.

3.8 Create the `learn` Environment and Common Pitfalls

Run these in Miniconda Prompt:

conda create -n learn python=3.11  # 创建名为 learn 的 Python 3.11 环境
conda activate learn               # 激活 learn 环境
python --version                   # 检查当前 Python 版本
pip install requests               # 在当前环境安装 requests 包
conda deactivate                   # 退出当前环境

After conda activate learn, you’ll usually see (learn) on the left side of prompt. That’s the most direct activation signal.

When you run conda create -n learn python=3.11 for the first time, you’ll usually see:

Proceed ([y]/n)?

Type y and press Enter to continue.

If pip install requests times out or is very slow, go back to the Tsinghua mirror section above and check if mirror configuration is effective.

Another common pitfall: installing packages without activating target environment first. Then packages may go into base or system environment, and when you switch environment later you’ll get ModuleNotFoundError.

If this command set runs through, you’ve finished your first usable dev environment.

If you run into these cases:

python is not recognized as an internal or external command
Usually PATH is not configured correctly, or you didn’t reopen terminal after changing PATH. Fastest check: where python, then reopen terminal.
where python points somewhere else
You probably have multiple Python installs and current one is not the one you expect. Fastest fix: adjust PATH order, or explicitly use C:\Miniconda3\python.exe.
conda is not a command
You’re most likely not in Miniconda Prompt. Fastest fix: open Miniconda Prompt and run again.
ModuleNotFoundError
Confirm VS Code interpreter matches your active environment, then run pip install inside that same environment.

Pitfalls you’ll likely hit

Most common ones: python not recognized, multiple Python installs with unclear active one, or pip installing into system env instead of project env.

Many beginners go through this stage. You might run conda activate learn and feel like “nothing happened”. Usually command isn’t broken; either conda wasn’t loaded in this terminal, or you’re not using Miniconda Prompt.

I hit this too. Looking back, most issues came from path and environment not aligned. Use these two commands to make current state explicit:

conda info --envs  # 查看所有 conda 环境，以及当前激活环境
where python       # 查看当前 python 命令实际指向的可执行路径

conda info --envs confirms which environment is active; where python confirms which executable is actually called.

If output still looks confusing, that’s normal. Just confirm two things first:
(1) are you in learn environment, and (2) does first line of where python match the Python you intended.

4. Version Control

4.1 Why You Need Version Control

You’ve probably seen this: desktop full of final.py, final_final.py, final_final_v3.py, and a week later you can’t tell which one actually runs. That’s where version control matters: it records each change as a timeline, so you can review, rollback, and collaborate.

What is Git (one sentence)

Git is a local version control toolset that records code history and changes.

4.2 Git Installation and Basic Setup (Windows Mainline + Mac Side Note)

Start at Git official site: https://git-scm.com/. Windows users click Download for Windows (or equivalent), then run installer (filename usually like Git-2.xx.x-64-bit.exe).

Installer has many pages. Here’s the beginner-focused pass through key options:

License: click Next.
This page is just licensing text.
Select Destination Location: default is fine.
If changing path, prefer English path like D:\Git or C:\Program Files\Git.
Select Components: mostly default, focus on key options.
Git Bash Here recommended; Git GUI Here optional; Git LFS recommended; Associate .git* configuration files with the default text editor recommended; Associate .sh files to be run with Bash optional; Add a Git Bash Profile to Windows Terminal optional.
Start Menu Folder: default Next.
No need to tweak this page as a beginner.
Choosing the default editor used by Git:
If VS Code is installed, choose Use Visual Studio Code as Git's default editor; otherwise default is fine and can be changed later.
Adjusting the name of the initial branch in new repositories:
Recommended: Override the default branch name for new repositories and set to main.
Adjusting your PATH environment:
Beginner recommendation: Git from the command line and also from 3rd-party software, so git works in CMD/PowerShell/VS Code terminal.
Choosing the SSH executable and Choosing HTTPS transport backend:
Keep defaults (usually Use bundled OpenSSH / Use the OpenSSL library).
Configuring the line ending conversions:
Recommended: Checkout Windows-style, commit Unix-style line endings, to avoid full-file line ending diffs cross-platform.
Configuring the terminal emulator to use with Git Bash:
Keep default Use MinTTY; doesn’t conflict with daily use in VS Code terminal.
Choosing the default behavior of 'git pull', credential helper, extra/experimental options:
Keep defaults for now (Git Credential Manager should stay enabled).

After install, close all terminal windows and reopen. Then in CMD (Win + R, type cmd) run:

git --version    # 正常会看到：git version 2.xx.x

If it says git is not a command: reopen terminal once first; if still broken, reinstall and make sure PATH page selected “from the command line and also from 3rd-party software.”

Mac side note (Windows users can skip): run git --version in Terminal. It usually prompts to install command line tools. Follow wizard, then reopen Terminal and verify again.

First Git basic config (user.name / user.email)

This sets commit identity, not account password. Configure once and commit records become stable.

git config --global user.name "你的名字"          # 设置提交显示名
git config --global user.email "you@example.com" # 设置提交邮箱
git config --global --list                        # 验证配置

You should see user.name= and user.email= lines, meaning configuration is active.

4.3 GitHub Registration and Account Preparation

Git is local version control; GitHub is remote hosting and collaboration. One records versions locally, the other puts versions online and supports collaboration.

GitHub official site: https://github.com/.

For beginners, GitHub’s biggest value is making learning visible. What you built and how you improved are recorded. Others can see it, and you can review it yourself. It’s also great for learning repository structure, README style, and issue-writing patterns from others.

4.4 GitHub Web Quickstart: Interface, New Repo, First Commit

GitHub UI is English by default, which is normal. Don’t panic. As a beginner, recognize core buttons first and everything gets easier.
After logging into https://github.com/, you’ll usually land on Dashboard / Home.

You’ll usually see three things first: top search box, top-right avatar and + menu, and left-side repo area. UI may change slightly over time, but core entries are stable: avatar, +, Repositories, Settings.

These areas are enough to start:

Left repo area (Top repositories / Repositories): quick access to your repos.
Center feed: just know it exists for now.
Top-right + menu: most used item is New repository.
Green New button on left Dashboard: also creates a repo.

In avatar menu, common entries are:

Your profile / Profile: your personal page.
Your repositories / Repositories: your repo list.
Settings: account settings (email/password/security, etc.).
Sign out: sign out.

For your first time, knowing these entries is enough.

GitHub registration (step by step)

GitHub is mostly English UI. I don’t recommend relying entirely on translators from day one, but if you’re truly stuck, use translation temporarily and get through the flow first. Over time, build the habit of reading English buttons and errors directly.

Registration flow:

Open https://github.com/, click Sign up in top-right.
Fill Email address, Password, Username in order.
Complete Verify your account and email verification code.
After completion, you’ll enter homepage and usually see your avatar or + menu on top-right.

Common blockers:

Username already taken: choose another one.
Verification email not received: check spam, wait a few minutes, or switch mailbox.
Slow page loading: refresh or retry later; if it happens often, see optional section below.

Mailbox suggestions for GitHub registration

Domestic users can use QQ Mail or 163 Mail.
If you prefer international services, Gmail/Outlook are also fine.
There’s no hierarchy between mailbox providers. The important part is long-term stability, receiving verification codes, and your own convenience.
Same for English UI: don’t panic. Learn common buttons first; translate temporarily only when truly stuck.

Create a new repo on web (step by step)

Step 0: confirm login success.
You should see your avatar at top-right.

Step 1: enter creation page.
Entry A: top-right + -> New repository; Entry B: green New on left Dashboard.
You should arrive at Create a new repository page.

Step 2: fill Repository name.
Use English plus hyphen, e.g. project-hello.
When valid, you’ll usually get a green pass hint. If error appears, shorten name and keep to letters/numbers/hyphens.

Step 3: choose Public / Private.
Public is better for learning showcase; Private works as private draft notebook.
You should see your selected option highlighted.

Step 4: Add a README file is recommended.
Practical reason: non-empty repo, with an immediate readable entry point.
After checking it, the option should show enabled.

Step 5: .gitignore and License.
.gitignore can be skipped at first; if this is clearly a Python project, choose Python template.
If unsure about Choose a license, skip for now and add later.

Step 6: click Create repository.
After creation you’ll enter repo page on Code tab by default; if README was selected, you’ll see README.md in file list.

Common pitfalls:

Duplicate/invalid repo name: switch to a different one (letters/numbers/hyphens are safest).
Email not verified: some features may be restricted; verify email first.
Slow page loading: if creation/loading pages get stuck often, check optional handling section later.

First web commit (without installing any tools)

If you don’t want to install tools yet, web flow can still complete your first commit and build confidence that “I can submit changes.”

Route 1: Add file -> Create new file

Open repo Code page, click Add file -> Create new file.
Use English filename like notes.md or hello.txt.
Write some content in editor.
Scroll down to Commit changes, fill Commit message (for example add notes).
Click Commit changes.

You should see: new file appears in list, and Commits count increases by one.

Route 2: Add file -> Upload files

On Code page click Add file -> Upload files.
Drag local main.py in (or click button to choose file).
Wait upload to finish, then scroll to Commit changes.
Fill Commit message (e.g. upload main.py) and click Commit changes.

You should see: main.py appears in file list, and commit history has a new entry.

Web flow is great for small edits and temporary file updates. For long-term development, local workflow + Desktop is still more stable and efficient.

How to read a repo page (most-used parts on Code tab)

First time entering repo page, don’t read everything. Just walk through these areas:

Top tabs: Code / Issues / Pull requests / Actions / Settings.
Beginners can focus on Code first; Issues is for questions/bug reports; Actions can wait.
Branch dropdown (usually main): branch switch entry.
Green Code button: common options include HTTPS / SSH / Download ZIP.
Go to file: quick jump when repo has many files.
Add file: create/upload entry.
File list (src/, README.md, etc.): main project content.
README renders in lower page area: first project description entry.
Commits: change history timeline and per-commit details.

4.5 Git Workflow and Minimal Vocabulary

Start with five words: commit, push, pull, branch, merge. Daily flow is usually: change locally -> commit -> push; when syncing use pull; use branch for parallel work; merge with merge at the end. If conflicts happen, don’t panic, inspect both sides and decide what to keep.

Git in VS Code (short version)

The Source Control panel in VS Code can show diffs, stage files, write commit messages, and commit. Very handy for small daily edits.

But for beginners, using GitHub Desktop for push/publish is often more stable and more visual. Run through commit/push/pull with GUI first; command line can come later.

4.6 Optional Handling When Access Is Slow in Mainland China

Under domestic network conditions, GitHub may sometimes be slow in loading, login, or release downloads. Start with no-tool options first: try another time period, and prioritize sync via GitHub Desktop.

If you frequently get stuck on registration verification pages, login pages, or Desktop authorization callback, then consider this optional route.

If you need an optional network optimization tool, you can check Watt Toolkit (Steam++): https://steampp.net/. This is only a backup option, with no effect guarantees. Tools are just tools; don’t let them distract you from learning goals.

GitHub Desktop download: https://desktop.github.com/.

Do first-time sign-in/authorization once, then everything after becomes smoother:

Open GitHub Desktop.
On Windows usually go File -> Options -> Accounts; on macOS usually GitHub Desktop -> Settings -> Accounts.
Click Sign in, then follow browser authorization flow (you’ll usually see Authorize GitHub Desktop or similar).
After authorization, return to Desktop and confirm account is visible (avatar or username).
If authorization page loads slowly, retry at another time first; if it still frequently blocks, see optional section above.

Expected result: File menu is available, and after one commit, Publish repository will appear.

Make sure you’re already signed into GitHub in Desktop (done above).

Create a project folder project-hello on desktop.
Open it in VS Code, create main.py, and write: print("Hello from my first repo").
In GitHub Desktop:
- If local folder is not a repository, use File -> New repository....
- If it already is, use File -> Add local repository....
Fill Summary in lower-left, click Commit to main.
Click Publish repository.
Go back to GitHub web and confirm repo is created and main.py is visible.

State checks after each step:

After repo init/add, changed files appear on left list.
After commit, changes list becomes empty.
After publish, web repo is accessible.

If you get stuck:

Commit button is gray: usually file not saved or no changes made.
Publish doesn’t appear: check if you’re logged in.
Web page won’t open or loads very slowly: finish flow in Desktop first; consider optional tool above only if necessary.

Minimal Git vocabulary

repo means repository, commit is a snapshot, branch is a parallel line, merge combines branches, push/pull sync with remote, and clone copies remote repo to local.

5. In the AI Era, You Might Not Need to Write Every Line, But You Still Need Engineering Thinking

AI has made coding faster. That’s true. What hasn’t changed is this: to land projects, someone still has to clarify problems and make results reliable.

What I care about now isn’t how much syntax you memorized. It’s whether you can turn “looks like it works” into “stable and reproducible.” That’s where engineering ability lives.

Real scenarios are often plain. You copy a code snippet and immediately get ModuleNotFoundError. First check interpreter, then where python, then install dependencies into the current environment. Run again, now you get FileNotFoundError, then go back and check paths. Problems are peeled layer by layer, not solved by one magical answer.

The one sentence I want to keep is: “Code you don’t understand is still debt, even if AI wrote it beautifully.”

AI can do a lot: templates, ideas, error explanations, optimization suggestions. What it cannot do is understand your requirements for you, take responsibility for mistakes, or make long-term architecture tradeoffs for you.

No need to mythologize tool choices either. For beginners, Doubao and DeepSeek are fully enough to start. If you need stronger quality/context handling, then try ChatGPT, Gemini, or Claude.

Using Codex-like plugins in VS Code is also practical. Completion and explanations can speed you up. It can be a copilot, but you’re still holding the steering wheel.

I’ll end this part with one line: what you really need to train is turning chaos into clarity. Tools will change, methods will change, but the steering wheel stays in your hands.

I hope you can build one ability worth having in this era: finding problems and thinking through solutions. When you hit a problem, your first reaction shouldn’t be giving up, but asking “how can I solve this?” Once your brain has at least a rough map, go try. If this software isn’t available, where else can I get it? Has someone met the same issue before? Did they leave a solution? Can I learn from it?

People who do big things shouldn’t carry psychological burden about tools. Tools are means, not identity. If a tool helps you reach your goal, you don’t need to obsess over whether the method looks elegant enough. I really like this sentence: “Real masters usually keep an apprentice heart.” When solving engineering problems, use community resources and search engines well. The world is big enough that many problems you face have probably already been recorded somewhere.

6. Debugging and Engineering Habits (Optional Advanced)

6.1 Error Reading and Localization: How to Read Traceback and Narrow the Problem

It’s normal for beginners to fear errors. I used to get nervous seeing red text too. Later I realized errors are more like navigation: they tell you roughly where the problem is.

Keep these four questions in mind:

Which Python/program am I actually running? Check where python, then verify VS Code interpreter is the same environment.
Which line did the error happen on? The last part of traceback usually gives filename and line number.
What external dependency does this line rely on? Usually packages, file paths, permissions, or network.
How do I verify after fixing? Build a minimal repro and rerun after changing one thing at a time.

ModuleNotFoundError: No module named 'xxx'
Typical causes are missing package or package installed in wrong environment.
Do this: confirm interpreter, install package in current environment, rerun same code.
After fix you should see: this error disappears and execution continues.

FileNotFoundError: ...
Most commonly wrong path or wrong startup directory.
Do this: confirm current working directory, run with absolute path first, then switch back to relative path.
After fix you should see: file is read successfully and subsequent logic starts running.

SyntaxError
Most common causes are missing colon, unclosed bracket, or bad indentation.
Do this: jump to error line and inspect previous line, fix symbols and indentation, rerun minimal code.
After fix you should see: interpreter no longer exits immediately.

6.2 Breakpoint Debugging: Use VS Code to See Variables and Flow

Open the .py file you want to run.
Click left of line number to set a red breakpoint.
Click Run and Debug in sidebar, or press F5.
First run asks for environment; choose Python. If it asks to create launch.json, confirm.
When program pauses at breakpoint, inspect values in Variables panel.
F10 step over, F11 step into, Shift+F11 step out.

You should see: program paused at breakpoint, variables panel updating, and line-by-line execution control.

total = 0
for i in range(1, 6):
    total += i
    if total >= 10:
        print("hit", total)
        break
print("done", total)

Set breakpoint at total += i, and you’ll see how total changes each iteration. Debugging isn’t for show, it’s for saving time.

6.3 Engineering Habits: Directory Structure, Markdown, File Types, Commits

project-hello/
  src/
  data/
  output/
  README.md
  .gitignore

Put code in src/, input in data/, output in output/, usage notes in README.md, and non-tracked files in .gitignore. Once structure is clear, debugging gets much easier.

Try to use English paths and filenames, not for style points, but to reduce weird cross-tool compatibility issues.

A minimal README can start like this:

# project-hello
项目作用：xxx
运行方式：python src/main.py
依赖：xxx
输入在 data/，输出在 output/

You can think of Markdown as “plain text + lightweight markup.” It’s not a binary format like Word, so it’s great for Git version control and easy cross-platform opening.

It appears everywhere in engineering: README, project docs, issue records, blogs, study notes. Once you learn the minimal syntax, you can reuse it across many places.

Tool-wise, VS Code can edit it directly. A Markdown extension like Markdown All in One is recommended. Preview is only a display mode; it doesn’t change your file itself.
If you prefer WYSIWYG, Typora is also great. I use it for long writing; the flow feels smoother.

For minimal syntax, these are enough to remember:

# 一级标题
## 二级标题
- 列表项
```python
print("hello")


For links, this article prefers angle-bracket style `<https://...>`: consistent, direct, and less formatting trouble after copy. (`[text](url)` also works, choose what you prefer.)

Mini README template you can copy directly:

```markdown
# project-hello
这个项目是做什么的
## 运行方式
python src/main.py
## 输入输出
输入在 data/，输出在 output/

Three common pitfalls: inconsistent list indentation, unclosed triple backticks, and Chinese punctuation in code blocks. Chinese punctuation is usually fine in Markdown prose, but in code it often breaks execution.

High-frequency file types are enough at first: .py/.md/.txt are code/text and can be opened directly in editor; .json/.csv/.xlsx are common data formats, first two are editor-readable and table files can be opened in Excel; .yaml/.yml/.toml are common config formats, pay attention to indentation and keys; .zip/.7z should be extracted first; .exe/.msi are installers, not data files.

File extension doesn’t define everything, but it’s still a useful first signal for choosing the right tool.

Habit 1: small commits, one clear change per commit.
Habit 2: commit messages in plain language, use verb + object like add notes, fix path.

You’ll probably have a moment where something gets broken badly. If your commit history is clear, you won’t panic and rollback is fast. This habit looks small, but pays off when things go wrong.

7. Hardware Basics: Understand What Your Computer Is Doing

7.1 The Four Hardware Pieces: CPU, GPU, RAM, Storage

First separate these four terms, and configuration sheets become much easier to read. CPU is like the command center, good at general-purpose computation and complex branching, so single-thread performance is often important. GPU is more like many workers doing tasks together, great at parallel workloads like graphics rendering and matrix-heavy deep learning.

RAM is your “workbench,” where runtime data is kept temporarily. The bigger the bench, the more things you can spread out at once. In phone communities, ROM is often casually used to mean “storage,” but in PC context, what people call “ROM/storage” is usually persistent storage like SSD/HDD, not strict read-only ROM.

One more practical layer: RAM is volatile temporary space. While programs run, variables and caches stay on this workbench. Once program exits, computer restarts, or power is cut, this data is cleared. Values you see during breakpoint debugging are also runtime state in RAM, and they disappear when process stops. That’s why reopening a program often loses half-computed intermediate results unless they were written to disk.

Most common misconception in one sentence: memory (RAM) is not the same as storage (SSD/HDD). One is temporary runtime space, the other is long-term file storage.

Many laptops show both iGPU and dGPU, and that’s normal. Integrated GPU (iGPU) is inside CPU: power-saving, cooler, and enough for coding/docs/daily dev. Dedicated GPU (dGPU) is separate silicon: stronger for graphics and parallel compute, suitable for gaming, 3D rendering, video export, and model training.

Automatic switching is the system balancing power and performance: light tasks on iGPU, heavy tasks on dGPU. Practical note for beginners: learning programming itself doesn’t require a dGPU. But if you’re heading into deep learning, NVIDIA CUDA ecosystem is more common. You can still learn without dGPU; training is just slower.

7.2 Storage and Interfaces: HDD/SSD, SATA/M.2/NVMe

One sentence to remember first: both HDD and SSD are for long-term storage, not RAM. HDD is like an old warehouse: large capacity and cheaper, but slower, noisier, and more sensitive to shock. SSD is a modern warehouse: faster, quieter, and shock-resistant. Booting, package install, and opening projects all feel snappier.

Beginners most commonly mix up three things: form factor, interface, and protocol. 2.5-inch SATA is typically cable-connected; M.2 is the card-like form factor; NVMe is a protocol usually running on PCIe. If two drives look like M.2 but speed differs a lot, protocol differences are often the reason.

Before buying/installing, check specs in three steps to avoid pitfalls:

Check motherboard/laptop spec page first: confirm whether it supports SATA or M.2 before purchasing.
Check details: M.2 length (e.g. 2280) and slot protocol (SATA/NVMe) must match.
Check resource sharing: some M.2 slots may disable SATA channels; on laptops confirm expansion support first.

One language detail: when people say “my phone’s 256G memory is full,” they usually mean storage space is full. Just understand the meaning; no need to argue terminology.

7.3 RAM Sticks and Frequency: DDR4/DDR5 and Speed Indicators

In real scenarios like “browser + VS Code + Python + spreadsheets,” 8GB can run but fills up quickly with many tabs. 16GB is the current sweet spot for learning and moderate development. 32GB gives more headroom for VMs, data processing, and video editing.

For SSD, at least 512GB is usually more comfortable. Reason is practical: development environments, package caches, project files, and datasets keep growing. 256GB gets tight quickly. Don’t stare only at CPU; a strong CPU with tiny RAM still feels constrained.

DDR4 and DDR5 are memory generations. They are not freely mixable; compatibility depends on motherboard and CPU platform. Check compatibility first, then parameters. “Newer generation” doesn’t mean every machine can upgrade directly.

For frequency labels, vendors may use MHz, MT/s, or casually Hz. Treat it as speed tier. Higher frequency can help, but perceived performance won’t always double because bottlenecks may be CPU, disk, or program design itself.

A practical order for beginners:

Compatibility first: does motherboard/CPU support DDR4 or DDR5?
Capacity second: secure 16GB baseline, then 32GB if needed.
Frequency last: increase one tier if budget allows; dual-channel (two matching sticks) is usually more stable.

In real development, browser + VS Code + Python + spreadsheets usually hit capacity limits before extreme frequency limits, so capacity often impacts experience more.

7.4 Quick Model Reading: Intel / AMD / NVIDIA

One overall rule first: naming conventions change with each year, suffixes evolve too. If you see a new suffix, check official docs instead of guessing.

For Intel CPU, read three parts: series, generation, suffix. i3/i5/i7/i9 are broad positioning, but the same i7 across generations can differ a lot. In examples like i5-12400, i7-13700K, i7-13620H, i5-1340P, check generation first, then suffix: K often means unlocked overclocking, F often means no iGPU, laptop H/HX usually performance-focused, U low-power, P in-between.

AMD CPU is similar: start with Ryzen 3/5/7/9 positioning, then generation numbers. For models like Ryzen 5 5600, Ryzen 7 7700X, Ryzen 7 7840HS, Ryzen 5 7530U, numbers broadly represent generation and class; laptop suffixes often include H/HS/U. Also know APU (stronger integrated graphics) exists; it helps with light graphics and light editing tasks.

For NVIDIA GPU, the easiest mistake is this: bigger number isn’t always stronger unless you compare generation first. GTX is generally older generation, RTX usually includes newer feature sets. Example RTX 3060 vs RTX 4060: identify generation first, then compare 60/70/80/90 tiers within the same generation. Ti/SUPER are usually enhanced variants in that generation. Also remember Laptop GPU with same name is not equal to desktop performance. For AI, VRAM matters a lot: 8GB is entry level, 12GB is much more comfortable, and 16GB+ gives better room for larger models/images.

7.5 Self-check and Remote Use: Task Manager, Device Manager, RDP, Server

Check memory and storage first: 16GB RAM + 512GB SSD is a stable baseline.
Then check CPU generation and class: don’t judge by i7/i9 label alone.
Only if your tasks are AI/gaming/rendering, prioritize dGPU; NVIDIA ecosystem is often more convenient.
If portability and battery matter more, iGPU laptops can absolutely handle programming study.
Finally check display, ports, and weight based on your usage scenario.

Your current computer is very likely enough to start learning. No need to wait for a “perfect machine” to begin.

Now that you’ve learned CPU/GPU/memory/storage concepts, next step is mapping them on your own machine. It’s not complicated. Three entry paths are enough.

A) Task Manager -> Performance (most common)

Method A: right-click Start menu, open Task Manager.
Method B: Win + R, type taskmgr, press Enter.
If you only see simplified view, click “More details” first.
Go to Performance, then click CPU / Memory / Disk / GPU one by one.
You’ll see: CPU model and base speed, total memory capacity, disk model and active time, GPU name and VRAM usage.

B) Device Manager (hardware list and driver state)

Method A: Win + X menu -> Device Manager.
Method B: Win + R, type devmgmt.msc, press Enter.
Expand Display adapters / Processors / Disk drives / Network adapters.
You’ll see device name lists; yellow exclamation usually means abnormal status.

C) Third-party tool: TUZB Toolbox (optional)

If you want one-screen overview, use it as supplementary tool. Download: https://www.tbtool.cn/.

Method A: open browser and visit the official URL above.
Method B: Win + R, directly enter https://www.tbtool.cn/, press Enter.
After opening, check pages like hardware overview/sensors to compare CPU, memory, disk, and GPU.
If values differ slightly from Task Manager, trust system entries first and use third-party data as cross-check.

Display details vary by brand/device, but entry path is stable: check performance page first, then hardware list, then optional third-party cross-check.

First skill: open it. Three methods, pick one:

Ctrl + Shift + Esc.
Right-click taskbar -> Task Manager.
Win + R, type taskmgr, Enter.

Second skill: know which tabs to read:

Processes: sort by CPU/memory to find what’s consuming resources.
Performance: watch real-time CPU/memory/disk/GPU usage.
Startup: startup apps (name may vary slightly by Windows version).

Third skill: end frozen apps correctly:

Confirm it’s an app you recognize and it’s frozen (e.g. browser/editor).
Select the process.
Click End task.
You should see app window disappear and CPU/memory usage drop.

One safety line: don’t end unknown system processes casually, like System, Service Host, Windows Explorer. If unsure, search process name first or take a screenshot for record. A process is basically an “instance of a running program.” If you’re not sure whether it’s a system process, don’t end it first; copy process name and search it, you can usually judge in 30 seconds.

A common scene: PC suddenly becomes very laggy. Open Processes, sort by CPU, find one process staying above 90%. Save your current work first, then end that process. Usually this brings the machine back to usable.

Device Manager is not a “magic driver installer.” Its first value is helping you verify whether hardware state is normal.

Method A: Win + X -> Device Manager.
Method B: Win + R, type devmgmt.msc, press Enter.
Focus on four categories: Display adapters (GPU), Processors (CPU), Disk drives (storage), Network adapters (network card).
If you see a yellow exclamation mark: right-click device -> Properties -> Device status, read system-provided cause first.

Beginner-safe order for driver updates:

Get drivers from hardware vendor or laptop OEM official site first.
Avoid unknown third-party driver packages.
Windows Update may provide drivers too, but not always the latest.

If you see two GPUs (iGPU + dGPU), in most cases that’s normal and aligns with automatic switching logic discussed above.

One-sentence definition: remote desktop means “use another computer as if it were your own,” with display/keyboard/mouse behavior similar to local operation.
Typical use cases: connect to home/company PC for files, connect to lab machine for tasks, connect to cloud server for deployment and maintenance.

Most common Windows connection steps are straightforward:

Press Win + R.
Type mstsc, press Enter to open Remote Desktop Connection.
In Computer, enter target machine IP or hostname.
Click Show Options (optional) to fill username and avoid retyping.
Click Connect.
Enter password and confirm certificate prompt on first connection.

You should see: a new window pops up, showing the other machine’s desktop, where you can open apps/files like local.

Four common pitfalls:

Target machine is off or asleep: connection fails directly.
Remote Desktop not enabled on target: enable it in “Settings -> System -> Remote Desktop.”
Network unreachable causes timeout; in public network, port forwarding/tunneling may be needed.
Account permission insufficient can also deny access; not all Windows editions are suitable as remote host.

Security-wise, keep it simple: don’t store passwords everywhere, and use strong passwords whenever possible.

You can think of a server as a “24/7 working machine.” It prioritizes stability, continuous operation, and remote maintainability, not direct sitting-in-front interaction experience.

The easiest beginner misunderstanding: servers are not mysterious. At core they are still CPU + memory + storage computers. Difference is mainly usage and operation mode. Your laptop is a personal workstation; a server is a long-running production machine.

Many servers have no monitor/keyboard attached, not because they can’t, but because daily operations don’t need it. Admins typically use SSH or RDP for config, deployment, and logs.

Once you connect the full flow, it’s clear: write code locally -> push to GitHub -> deploy to server. You’re moving a program from your dev machine to another machine that runs continuously.

Desktop PC keywords are expandability, cooling, and cost efficiency. Great for fixed long-term development, multi-monitor setup, and gradual hardware upgrades.
Laptops emphasize portability, with a balance between performance and battery life. Suitable for study, classes, and mobile work.
Phones are mostly ARM-based and better for “using services” than as primary dev devices. They work well as auxiliary terminals via remote control/cloud services.
Workstations target professional loads like rendering, simulation, and AI, where stability and expansion matter more. Don’t be intimidated by the name; match it to your actual tasks.
Servers are about long uptime, remote administration, and stability. Many scenarios use Linux, often without GUI or with minimal graphical environment.

A practical decision framework for beginners:

Ask first: am I learning programming, or already doing heavy rendering/training tasks?
For study and daily projects, prioritize usability: 16GB RAM + enough SSD usually matters more than chasing top-tier model names.
If you need fixed desk and multi-monitor setup, lean desktop; if you move often, lean laptop.
Only consider workstation/server when your task clearly requires them.
In most cases, the computer you already have is enough to start building projects.

Conclusion

If you can follow this article once from start to finish — even just once — set up your environment, run python in terminal, write a loop in VS Code, create a repository on GitHub, and submit successfully, then you’ve already completed the core of “getting started.”

Many people think programming entry means “memorizing syntax,” but I prefer seeing it as a practical life skill: can you break down a problem, find references, verify attempts, stay calm with errors, and finally reproduce results? You’ll find that real gap usually comes not from raw cleverness, but from whether this workflow is stable.

One final line: tools are means. Using Python, VS Code, GitHub, or AI plugins is all fine. The key is not “what tool I used,” but “did I understand the problem clearly and build a working result.”

To reduce your psychological burden, I want to be direct: this blog site and this article were also heavily AI-assisted. ChatGPT helped me write a lot, and it worked very well. It saved me significant time that I could spend on other things, and it improved my efficiency in a very direct way.

How I Turned My Tablet into a Second Monitor with Sunshine

Mon, 16 Feb 2026 00:00:00 GMT

Preface

I have been using a laptop for both work and entertainment for years. Because I move between places a lot, I never bought a dedicated external monitor. Part of it was me being picky, and part of it was the classic “if I buy one, I probably need two” dilemma.

At some point, the single-screen setup just became annoying. Gaming felt cramped, coding felt cramped, everything felt cramped. I started regretting not buying a monitor earlier.

I only took this seriously after trying Apple Vision Pro and learning what Sunshine could do for low-latency streaming. I still did not want to overcomplicate things, but the idea stayed in my head.

My tablet is a Huawei MatePad 11, with a 2560x1600 panel, close enough to my laptop’s workflow needs. I tested 90Hz streaming at that resolution and saw around 6ms delay in the path I measured. In real use it felt smooth enough to be useful, not just “tech demo smooth.”

I do not use this setup every single day, but if you want a portable second screen without adding more cables to your desk, it is a very practical option.

What I Want from a Second-Screen Experience

I wanted a true extended screen, not a remote-control mirror. I did not want accidental touches on the tablet to mess with my main cursor. I wanted the tablet to sit on my left side and behave like a natural extension of my desktop space.

The ideal use case for me is simple: the main screen for active work, the side screen for docs, serial logs, dashboards, or reference windows. Since it is an actual extended display, dragging content across is fast and natural.

I also wanted it wireless. I like being able to pick up the tablet and move around when needed. A cable works, but for this use case it quickly becomes visual and practical clutter.

Solution Overview

One-line topology:

PC -> Sunshine (encoding) -> LAN -> Moonlight -> Tablet
            |
        Parsec-VDD (virtual display)

Role split:

Parsec-VDD: creates the second display target
Sunshine: captures and encodes that display
Moonlight: decodes and shows it on the tablet

Preparation

Hardware Requirements

A GPU that supports hardware encoding
A local network (5GHz recommended)

Software List

Sunshine
Moonlight
Parsec-VDD

Once your hardware is ready, the rest is mostly configuration and a bit of verification.

How to Install and Configure Sunshine

I use Windows for this setup, so these are Windows-first steps.

Install Sunshine from the official release.
Launch Sunshine. The first-time WebUI is usually at https://localhost:47990.
Create your admin account on first login.
Open Settings / Configuration:
- In General, confirm the service is running and enable start-with-system if you want auto-start.
- In Video / Encoder, choose your encoder backend.
- Keep default ports until the full chain is stable.
Open Applications, click Add / New / +, add Desktop, then save.

Useful links:

Build choice on Windows:

Installer: best default choice. Easier service setup and easier updates.
Portable: useful for no-install environments, but you manage more manually.

Service mode in plain terms: Sunshine keeps running in the background as a service, so Moonlight can connect without you re-opening the UI every time.

WebUI and ports:

Default WebUI is 47990 (HTTPS).
If you change ports later, update firewall rules accordingly.

Encoder choice:

NVENC (NVIDIA hardware video encoder)
AMF (AMD media framework encoder path)
QSV (Intel Quick Sync Video encoder path)

After selecting encoder settings, click Save / Apply. Do not leave the page without saving.

NVENC preset:

Start with low-latency presets.
Move toward higher quality only after stability is good.

Bitrate baseline I use:

1080p60: 20-35 Mbps
1440p60: 35-55 Mbps
1600p90: 45-75 Mbps
4K60: 60-100+ Mbps

Practical codec pick:

HEVC / H.265 for better compression efficiency at the same quality.
H.264 when compatibility or decode stability matters more.

Audio setup (important):

In Sunshine Audio, set output device explicitly (avoid auto if you want predictable routing).
If you want sound only on the PC, disable audio redirection.
On Moonlight, go to Settings -> Audio Playback and disable playback there.
In Windows, verify your default playback device is still the local speaker/headphone you want.
Save/Apply Sunshine audio settings after each change.

This avoids the common issue where both PC and tablet play sound at the same time.

How to Install and Configure Moonlight

Moonlight setup is lightweight. Pairing and network correctness are the main points.

Install Moonlight on the tablet.
Make sure tablet and PC are on the same LAN.
Open Moonlight and let it auto-discover the host.
If auto-discovery fails, add host manually with your PC IPv4 address.
Enter the pairing PIN in Sunshine WebUI.

Manual IP steps on Windows:

Press Win + R.
Type cmd, press Enter.
Run ipconfig.
Find the active adapter and read IPv4 Address.
Use that IPv4 address in Moonlight Add Host.

Moonlight links:

First-pass stream settings:

Start at 1080p, 60fps, moderate bitrate.
Scale up after it is stable.

Parameter behavior that matters:

Keep source/output/client resolution aligned when possible.
Keep refresh rates aligned (or integer-related) to avoid uneven cadence.
Watch frame pacing (frame time consistency), not just average FPS.
If bandwidth is tight, reduce resolution/FPS before crushing bitrate.
V-Sync on for smooth office-style use, off for lower interactive latency if needed.
HDR is optional; keep SDR first until the chain is stable.

How to Install and Configure Parsec-VDD

Parsec-VDD is the piece that makes Windows think a second display exists.

Install Parsec-VDD.
Reboot the PC (important: driver enumeration is cleaner after reboot).
Open Windows Display Settings and confirm a new display appears.
Switch display mode to Extend these displays.
Set resolution and refresh rate on the virtual display.

Useful link:

Parsec-VDD Repository

How the virtual display appears:

After driver install + reboot, Windows display stack enumerates it as an available display output.
If your VDD build has an enable toggle/tool, enable the virtual screen there first, then return to Windows Display Settings.

Now the important part: mapping Windows display to Sunshine display ID.

Windows numbers (1/2/3) are logical labels. Sunshine often lists outputs by its own enumeration order (for example Display 0/1/2 or \\.\\DISPLAY1/2). They are often related, but not guaranteed to match one-to-one.

Reliable mapping workflow:

In Windows, make the virtual display easy to recognize:
- set a unique resolution (for example 1280x720), or
- switch it to portrait, or
- drag it to the far left in display arrangement.
In Sunshine WebUI, go to Settings/Configuration -> Video/Display/Capture (wording may vary by version).
Find the target selector (Display / Monitor / Output) and pick one display ID.
Click Save / Apply.
Connect from Moonlight and verify what you see.
If it is the wrong screen, switch to the next display ID in Sunshine, save again, reconnect, and verify again.

This takes a minute once, then stays stable.

Known recovery trick when extend mode does not react:

In Windows Display Settings, switch to Show only on 2.
Click Apply.
Switch back to Extend these displays.

This often refreshes display state and brings the virtual output back into a usable state.

If still broken, check:

You rebooted after VDD install.
Virtual display is not disabled.
Advanced display settings show valid refresh modes.
Manually disable/re-enable the virtual screen once.

Performance Tuning Notes

The goal is stable low latency, not maximum numbers on paper.

Tuning order I use:

Network first
- PC on Ethernet if possible.
- Tablet on 5GHz/6GHz Wi-Fi.
- Avoid heavy transfers on the same LAN while streaming.
Stream parameters second
- Lock stable 60fps first, then push 90/120.
- Raise bitrate gradually.
Encoding path third
- Prefer hardware encoding.
- Avoid software encoding (CPU path) for this use case.
System power and load
- Keep laptop plugged in.
- Use high-performance power mode.
- Close heavy background workloads.

Bandwidth reality:

Codec bitrate is baseline demand, not total overhead-inclusive traffic.
Keep practical throughput headroom (around 25%-40%).

Latency usually accumulates from:

Encode queue
Wireless contention
Router queueing/forwarding
Decode + display sync

Wi-Fi 5 vs Wi-Fi 6 in this use case:

Wi-Fi 5 can be enough.
Wi-Fi 6 tends to reduce jitter under multi-device load.

Monitor GPU correctly:

Watch Video Encode engine utilization, not only 3D usage.
If encode is saturated, lower resolution/FPS/bitrate before anything else.

Technical Notes (Optional Read)

Why This Feels Lower-Latency

The path is designed for real-time frame delivery.

High-level flow:

App renders frame.
Compositor outputs to target display surface.
Sunshine captures that frame buffer.
Hardware encoder (NVENC/AMF/QSV) compresses the frame.
Stream crosses LAN.
Moonlight decodes and presents.

Latency behavior comes from each queue in that path.

Lower-latency encoder presets reduce internal buffering and lookahead.
Network jitter is handled by a jitter buffer on the client side.
Bigger jitter buffer improves stability but adds delay.
Smaller jitter buffer cuts delay but can increase visible hiccups.

Why traditional remote desktop paths often feel slower in this context:

They are generally optimized for desktop readability, reliability, and compatibility.
Their buffering/retransmission behavior is usually more conservative.
That helps office remoting quality, but it is not tuned for minimum interactive frame latency.

Wrap-up

For me, this setup is not a gimmick. It is a practical second screen that I can carry around.

The upside is clear: wireless workflow, low-latency feel, and enough control to tune for your own network and hardware.

It works especially well if you move between places and do not want to buy duplicate monitor setups.

The main thing to remember is that stability comes from process: get the virtual display right, map display ID correctly, then tune bitrate/FPS step by step.

Once configured properly, daily use is mostly just connect and go.

How I Keep My Anime Watching Stable

Sat, 14 Feb 2026 00:00:00 GMT

Introduction

How do you keep up with anime, or more importantly, how do you keep up consistently?

When a new show starts, sometimes it needs a paid membership on one app, sometimes it is not even licensed in your region yet, and sometimes even after licensing, you still wait extra weeks for delayed release windows. A classic case for me was Lycoris Recoil. Every week I was waiting for the newest episode like my life depended on it.

I even tried watching Japanese TV broadcasts directly with my very questionable Japanese skills. That ended exactly how you expect: confusion, panic, and me staring at the screen like a lost NPC.

So yes, I was in a hurry. Platforms like Bilibili could work, but often lagged behind official release timing by weeks. And if you know that show, you know why being late felt rough. I felt like a clown by the time I caught up.

Have you had this too: you search a title, click a random site, and the video quality is blurry, unstable, or heavily edited; subtitles are inconsistent; and if you like watching with danmaku, the experience is all over the place. The good news is these problems can be improved. This post is basically how I made my anime-watching flow less chaotic and more reliable.

warning

This post only shares personal workflow and tool usage ideas. It does not provide unauthorized content sources. Please follow local laws and platform terms in your region.

1. How I Get Content

Let me be clear first: this is not a piracy tutorial. This is a “how to reduce chaos” tutorial.

My order is simple: check legal options in my region first, then decide whether I need local playback for better quality/subtitle control.

Why do I still download for local playback?

Not everyone needs local playback. But if you care about quality consistency, subtitle control, release timing, and archive stability, local playback helps a lot.

I treat it like this:

Platform streaming: fast and convenient, great for casual watching.
Local playback: better control, better consistency, better for rewatching.

If you watch casually, streaming may be enough. If you are picky like me, local playback is often worth it.

What is a magnet link?

A magnet link (Magnet URI) is a technical identifier. It tells a client what content hash to look for; it does not automatically mean “this is where to legally get content.”

You will often see it with P2P workflows. P2P (Peer-to-Peer) means participants exchange data with each other instead of relying only on one central server. So speed can change based on peers online, their upload rates, and your network path.

Technology itself is neutral. Usage still needs to be legal.

So how do I get anime magnet links then?

I do not provide unauthorized source instructions here.

My practical approach: confirm licensing in your region first, then use legal channels. If you just want to start watching today, these are common legitimate platforms to check first:

Catalogs vary a lot by region, which is normal. I usually build a weekly watchlist first, then map each title to whichever legal platform actually has it.

What are fansub groups? What does dual Chinese internal subtitles mean?

You will see these terms sooner or later.

A fansub group usually handles translation, timing, editing, and packaging. “Internal subtitles” means subtitle tracks are embedded in the media container. “Dual Chinese” often means both Simplified and Traditional subtitle tracks are included.

If subtitles exist but look terrible, check three things first: subtitle renderer, missing fonts, and whether you selected the correct subtitle track.

How do I download from a magnet link?

I will only cover tool usage here, not source discovery.

The practical idea is simple: use one stable downloader and keep your path settings consistent. That way your player, danmaku workflow, and RSS setup all stay clean.

qbittorrent

qBittorrent is still my primary client. It feels like a proper tool: clean, transparent, and direct.

Official download links:

If the official site is inaccessible for you, GitHub releases work fine. On Windows, use this quick rule:

Open Releases and pick the latest stable version (not pre-release).
Expand Assets.
For most users, download the installer: usually qbittorrent_<version>_x64_setup.exe.
If you want portable mode, download the x64.zip build and run qbittorrent.exe.
Do not download Source code (zip/tar.gz) unless you actually plan to build from source.

If this is your first time, here is the beginner-friendly flow:

Install qBittorrent.
Go to Tools -> Options -> Downloads, set a default save path (for example AnimeWorkspace/_incoming).
Copy your magnet link.
qBittorrent usually pops up an “Add Torrent” window automatically.
If it does not pop up, click the chain/link icon and paste it manually.
In the dialog, check save path, file list, and whether to start immediately.
Click confirm and watch status.
When status changes from downloading to seeding, download is complete.

What I check before moving a file into my main library:

File size looks reasonable.
Video duration makes sense.
Subtitle track exists and is usable.

Pros in plain language:

Stable for long-running tasks.
Highly controllable paths and categories.
Great RSS automation support for weekly updates.

Cons in plain language:

UI is not “cute beginner mode”; it looks technical.
Speed fluctuates with peer/network conditions.
If you hate all settings screens, it may feel a bit nerdy.

About those country flags in peers list (this confuses many people):

The flag usually represents the IP geolocation of connected peers. In plain words, it shows where those network nodes are estimated to be.

It is not a legal guarantee, not a quality score, and not always perfectly accurate.

Quark Drive (non-sponsored)

I use Quark as an acceleration option in some cases, mostly for convenience.

In my home setup (gigabit line), with membership, I can often see around 50-60 MB/s on many tasks.

Compared with qBittorrent, the difference is often not “which app is objectively stronger” but “how the backend works.” Quark can feel more stable in speed because part of the process is platform-assisted. qBittorrent is direct P2P, so it can be very fast on good swarms and slower on weak ones.

Download link:

Quark official site

Xunlei (non-sponsored)

Xunlei is often called “leech thunder” in old P2P discussions. That label comes from long-running debates about fairness in sharing behavior.

The core argument is simple: if too many clients take bandwidth but contribute less back, swarm health goes down and everyone eventually suffers.

Download link:

Xunlei official site

2. Choose Your Player

Downloading is only step one. Playback quality is where your daily experience is won or lost.

potplayer

PotPlayer is my main local player when I care about details.

Official download:

PotPlayer official site

Beginner install path:

Download Windows installer from the official page.
Run installer and keep default options unless you have specific needs.
Open one known-good video first before touching advanced settings.
After confirming playback works, do basic tuning.

Basic setup I recommend first:

Associate common formats (mkv, mp4).
Enable auto-loading same-name subtitle files.
Ensure hardware decoding stays enabled.
Keep audio output defaults initially.

Why it is good:

Strong decoding compatibility.
Excellent subtitle styling control.
Fast switching between tracks/subtitles.
Stable local experience without platform UI drama.

Common beginner issues:

Stutter: check hardware decode and heavy filters.
Weird subtitle rendering: check renderer mode and fonts.
Audio oddities: switch output device or test another track.

My normal use is boring and reliable: open file, confirm subtitle/audio tracks, only tweak settings if needed.

dandanplay

dandanplay is very anime-friendly. It combines playback, danmaku, and show metadata in one place.

Official download:

If you download from GitHub on Windows:

Pick the latest release with windows- in the tag/title.
Open Assets.
Prefer installer .exe with Setup in filename.
On 64-bit Windows, prefer x64 builds when available.
If you want portable mode, choose .zip and run dandanplay.exe.
Do not download Source code (zip/tar.gz) for normal use.

Initial setup flow:

Install app and launch.
Add your anime folder to library.
Let it scan once.
Open one episode and verify match.
Adjust danmaku opacity/speed/font size to comfort.

Why it is good:

Anime-focused workflow out of the box.
Better title/episode matching than many generic players.
Danmaku integration is smooth.
Lower setup friction for regular users.

If danmaku looks chaotic at first, that is usually settings, not app failure. Lower speed a bit, reduce track count, and increase transparency.

Quark Drive

I use this as a light playback fallback on other devices.

Convenient for quick switching, less ideal for fine subtitle/decoder control.

3. How to Configure Danmaku in dandanplay

Danmaku quality is all about tuning. Good settings feel immersive; bad settings feel noisy.

What is danmaku?

Danmaku is timestamped viewer commentary synchronized to specific timeline moments.

The fun part is you can still “watch with others” asynchronously.

What is a danmaku source?

It is where danmaku data comes from. Different sources vary in volume, quality, moderation style, and timing precision.

Choosing a danmaku source

My practical order:

Check timeline alignment first on one test episode.
Check text quality (spam/repeat/noise).
Only then evaluate quantity.

I recommend keeping 1-2 stable sources instead of switching every week.

4. What is RSS Subscription?

RSS in plain English: automatic update notifications.

Think of it as a subscription inbox. When a source updates, you get a structured feed item without manually checking pages every day.

Technically it is a standardized feed format (often XML-based, such as RSS or Atom). It helps discover updates; it does not automatically download files by itself.

How to use qBittorrent for anime RSS subscriptions?

In qBittorrent:

RSS discovers new items.
Download rules decide what to grab.

Windows-friendly setup flow:

Open qBittorrent View and enable RSS Reader.
Add your legal feed URL in RSS panel.
Confirm feed updates are visible.
Open RSS Downloader (auto-download rules) and create one rule.

I recommend starting with these fields:

Must contain: title + season keyword.
Optional contains: 1080p, language tags, preferred release tags.
Must not contain: trailers/NCOP/other unwanted items.
Save path: your fixed download folder.
Smart episode filter: avoid duplicates.

Start conservative:

Run manually for 3-7 days.
Check mis-matches.
Tighten or relax keywords.
Only then enable full auto-download.

Quick troubleshooting list:

Feed does not update: verify URL/network/source activity.
Items appear but nothing downloads: rule mismatch.
Wrong versions downloaded: tighten must-contain filters.
Duplicate downloads: enable smart filters.
Wrong folder: set per-rule path explicitly.

Once this is tuned, weekly tracking becomes much easier. You move from “daily manual searching” to “quick weekly rule maintenance,” which is honestly a huge quality-of-life upgrade.

How to Build a Personal Blog Website

Thu, 12 Feb 2026 00:00:00 GMT

Preface

When I realized I was remembering less and less of my technical ideas, I started writing things down in my phone notes during sleepless nights. But phone notes are limited, and I could not access everything smoothly across devices.

In January this year, during another late night, I thought: if I get some time, I should build a personal blog. I want to write down meaningful things for myself, for students I have taught, and maybe for students I will teach in the future.

The problem was: I was very busy. I had just returned from a business trip in Jiangsu. One night, still unable to sleep, I remembered this plan again. It was already very late, so I did not want to disturb friends who had built blogs before. I guessed the whole thing might take around a week.

The next morning, I asked my high school friend Herbert Skyper. His answer: around one week too. He hand-built his version with Vue (no mature blog framework, mostly for frontend fun). When I visited him later, we talked more. Domain cost is usually not expensive per year, but server/public IP/stability are often the annoying parts.

One of the biggest headaches of running a website is exactly this: domain name, reliable always-on machine (or server), public network accessibility, and so on. There are ways to solve all of these, but if you can avoid extra operations in the early stage, that is usually better.

Skyper mentioned some classmates using Astro, which is a mature framework. Later my friend kymi replied too; he writes with Hexo and has a related tutorial: How to Deploy a Blog with Hexo. He also said deployment on GitHub is not too time-consuming, and it avoids server/domain costs at the start.

Requirements Analysis

What exactly do I need?

I need something like a “pro memo” that I can read anytime, and others can read too, without costing too much time or money.

Content comes first, but I also want a little personality in the design. Something simple, rational, and restrained, but still gentle, with small colorful details that can make people smile.

Technical Route

So why did I choose Astro?

I compared several blog frameworks first: their pros, cons, and which one fits me best. Since I have used ChatGPT for years, it has a decent idea of my technical level, and I organized its suggestions into the table below.

Blog Framework Comparison

Framework	Tech Stack	Build Speed	Writing Experience	Component/Interaction Power	Extensibility	GitHub Pages Fit	Best For	Common Pitfalls
Hexo	Node.js	Medium	Easy to start, many themes	Weaker (template-centric)	Medium	Mature and stable	Pure writing, Chinese ecosystem	Node dependencies may be annoying
Hugo	Go	Very fast	Clear structure	Moderate (content-driven)	Medium	Very stable	Speed-focused, low maintenance	Theme config can feel too engineering-ish
Astro	Modern frontend (React/Vue/Svelte)	Fast	Great Markdown/MDX experience	Strong (component mixing)	Strong	Need to handle `base` carefully	Frontend developers	High freedom means more decisions
Next.js / Nuxt	React / Vue full-stack	Medium	Good	Very strong	Very strong	Static export needs prefix care	People planning larger platforms	Slightly heavy for pure blogs
VitePress / Docusaurus	Vite / React	Fast	Excellent for documentation	Medium	Medium	Very stable	Technical docs-style content	Less “blog vibe”
Jekyll	Ruby	Medium	Traditional Markdown	Weaker	Medium	Native support	Minimal deployment overhead seekers	Less modern by today’s standards

Decision-Oriented Summary

Requirement Type	Recommended Option	Why
Pure writing, mature theme ecosystem	Hexo / Hugo	Classic and stable
Lots of technical posts, fastest builds	Hugo	Extremely fast build speed
Blog + project showcase + interactions	Astro	Markdown + components is very strong
Might evolve into personal platform	Next.js / Nuxt	Strong full-stack capability
More documentation-oriented	VitePress / Docusaurus	Great structure and TOC management

ChatGPT told me Astro’s flexibility can feel like a pitfall because you need to make more choices yourself. For me, that is actually an advantage: I can choose the components and style I like.

At first I considered Cloudflare. But once I decided to push the project to GitHub anyway, GitHub Pages became super convenient: configure once, then update via push.

Deployment Cost Snapshot

Item	Reality
Server cost	Usually 0 with GitHub Pages / Cloudflare Pages / Vercel
Domain cost	`username.github.io` is free; custom domains usually cost money
Maintenance overhead	Almost 0 for static sites

Astro supports modern frontend component ecosystems, so which components should you choose?

Your technical route shapes your blog’s personality and tone.

One key mindset correction first: this is Astro’s strength, not a limitation.

Astro is not “a Vue-based blog framework”. It is:

👉 Astro = static-site framework + optional Vue components when needed

ChatGPT recommended Tailwind CSS and suggested a style that is timeless, professional, and easy to live with in the long term. I agree.

At this stage, I still prefer introducing only a small number of components to avoid complexity.

Less is more.

Development Environment

I use VS Code as my text editor, and I installed the Astro extension.

note

Node.js - v18.20.8, v20.3.0, v22.0.0, or higher (v19 and v21 are not supported).

Astro is built with Vite. Vite targets modern JavaScript browsers by default. See the browser support list in Vite docs: Browser Compatibility.

Terminal - Astro is operated via CLI.

Let AI Code Build the First Skeleton for You

Once your requirements and technical direction are clear, you can treat AI as a “scaffolding assistant” and let it create a runnable version first.

My habit is simple: let AI produce a quick first draft, then do a second refinement pass manually. This is much more efficient and helps you avoid getting stuck at step one.

Prompt Set I Actually Use (Copy-Paste Ready)

You can paste this to AI tools like ChatGPT, Codex, or Cursor:

You are a senior frontend engineer. Help me build an Astro personal blog project from 0 to 1.

Goals:
1) Tech stack: Astro + Tailwind CSS
2) Content: Markdown-based writing
3) Deployment: GitHub Pages
4) Requirements: beginner-friendly maintenance, clear project structure, clean and restrained style

Output format:
1) First, provide the project directory tree
2) Then provide commands to run (in order)
3) Then provide full content for key files (astro.config.mjs, package.json, basic pages, blog content dirs)
4) Explain "why" for every step
5) Finally provide a troubleshooting checklist (common errors + fixes)

Constraints:
- Do not skip steps
- Do not omit key configurations
- All commands must be directly runnable
- Prioritize stable solutions over fancy tricks

Second-Round Prompt (Ask AI to Improve, Not Rewrite)

After the first version runs, give AI this:

This is my current project state. Please make incremental changes on top of the existing structure. Do not rewrite from scratch.

Goals:
1) Keep existing routes unchanged
2) Improve homepage layout and blog list style
3) Add tags page
4) Ensure npm run build passes

Output requirements:
1) Only list files that need modification
2) For each file, provide minimal diff
3) Include verification commands after changes

This “incremental modification” style prompt is important. Otherwise AI may accidentally replace things you already wrote.

For example, this is the kind of effect I got when I locked requirements and asked Codex to scaffold it. It is great for getting started. If you feel stuck during debugging, ask AI to help write a precise prompt first. It is often more effective than saying “move this thing a bit left/right.” AI code assistants are smart, but they cannot see your screen.

Installation

Install Node.js (Windows)

Node.js download page: https://nodejs.org/en/download

The simplest way is opening that page and clicking Windows Installer (.msi).

Steps

Double-click the installer.
Click Next.
Accept the license and click Next.
Default path is usually C:\Program Files\nodejs\ (you can change it).
Click Install.
Click Finish when done.

tip

After installation, test Node/NPM in cmd or PowerShell. The fastest way to open cmd: Win + R, type cmd, press Enter.

node -v
npm -v

# example
C:\Users\Dan>node -v
v24.13.0

If Network Is Slow (download/install timeout)

This is a very common beginner issue and not your fault. Often the connection to the official npm registry is simply slow.

You can switch npm registry to a domestic mirror first:

# check current registry
npm config get registry

# switch to npmmirror
npm config set registry https://registry.npmmirror.com

# verify again
npm config get registry

Then run:

npm install

If you want to switch back to the official registry later:

npm config set registry https://registry.npmjs.org

Install VS Code

Download from the official site (Stable recommended):

https://code.visualstudio.com/

Quick Windows setup:

Click Download for Windows.
Run the installer and mostly Next all the way.
Recommended checkboxes: Add "Open with Code", Add to PATH, Register Code as an editor.
Open VS Code, then File -> Open Folder and choose your blog project folder.
Open terminal (Ctrl + ~) and run:

npm -v
node -v

If versions show up correctly, your environment is ready.

Extensions I personally use (minimal but effective):

Astro (official syntax support)
Tailwind CSS IntelliSense (class name suggestions)
Markdown All in One (better Markdown writing flow)

If you are interested in learning programming from scratch, I will publish a future post called “How to Start Programming” with more detailed guidance.

Install Astro

I recommend using the CLI wizard.

Open terminal in your target folder (for me: F:\project\Blog) and run:

# create a new Astro project
npm create astro@latest

Choose your project name and select Use blog template.

After project creation, when terminal is ready again (cursor blinking), continue.

C:\Users\Dan>

Enter your project folder and install dependencies:

F:\project\Blog>cd astro-blog
F:\project\Blog\astro-blog>npm install

At this point, the local site should already run:

npm run dev

Open http://localhost:4321/ in browser. If it looks normal, move on.

Deploy to GitHub Pages

Prepare Accounts and Tools First (Beginner-Friendly Order)

1. Create a GitHub Account

Open https://github.com/.
Click Sign up.
Enter email, password, and username (username appears in your blog URL).
Finish verification and email confirmation.
Remember your username, you will use it in repo URL and Astro site config.

tip

If you plan long-term maintenance, enable 2FA in Settings for better account safety.

2. Install Git (Windows)

Download from https://git-scm.com/downloads.
Run installer; default options are usually fine.
Verify in terminal:

git --version

Then configure identity (one-time):

git config --global user.name "Your Name"
git config --global user.email "your-email@example.com"

3. Install GitHub Desktop (Optional, very beginner-friendly)

If you do not want to memorize many commands at first, GitHub Desktop is a great bridge.

Download: https://desktop.github.com/
Sign in with your GitHub account.
File -> Add local repository..., choose your project folder.
After edits, review changes, write a Summary, click Commit to main.
Click Push origin to upload.

I still use CLI in daily work, but for beginners I often recommend Desktop first. No mental burden needed. Efficiency matters: commit, push, and move forward.

Initialize Repository and First Push (CLI / Desktop)

If this is your first time, follow this flow (skip if repo already exists).

Create an empty repository on GitHub first, then replace the URL below.

Option A: CLI

git init
git add .
git commit -m "init astro blog"
git branch -M main
git remote add origin https://github.com/<your-github-username>/<your-repo-name>.git
git push -u origin main

Option B: GitHub Desktop (GUI)

In GitHub Desktop, Add local repository.
For first commit, use a message like init astro blog.
Click Publish repository.
Next updates are simply Commit + Push origin.

My recommendation: keep repository name simple and lowercase, which helps avoid mistakes when configuring base later.

Use My Blog Project as a Reference: Clone First, Then Customize

If you want to learn from my current project structure directly, quickest way:

git clone https://github.com/Dancncn/DansBlog.git
cd DansBlog
npm install
npm run dev

After local startup, open http://localhost:4321/.

Project link:

https://github.com/Dancncn/DansBlog

If this tutorial or project helps you, I would really appreciate a Star on the repo.

Then convert it to your own repo:

Create a new empty repository in your own GitHub account (for example my-blog).
Update these fields in astro.config.mjs: site: 'https://<your-username>.github.io' base: '/<your-repo-name>/'
Replace remote URL:

git remote set-url origin https://github.com/<your-username>/<your-repo-name>.git
git push -u origin main

Go to Settings -> Pages and set Source to GitHub Actions.
Wait until Actions finishes, then visit: https://<your-username>.github.io/<your-repo-name>/

Configure `site` and `base` in Astro (Critical)

If you deploy as a project repo (for example https://<username>.github.io/<repo>/), you must configure base, otherwise static assets often return 404.

astro.config.mjs example:

const REPO_BASE = '/<your-repo-name>/';

export default defineConfig({
  site: 'https://<your-github-username>.github.io',
  base: REPO_BASE,
  trailingSlash: 'always',
  output: 'static',
});

If you use a user-site repo (<username>.github.io), base is usually /.

Auto Deploy with GitHub Actions

I personally prefer automation: one push, one deployment.

Create file: .github/workflows/deploy.yml

name: Deploy to GitHub Pages

on:
  push:
    branches: [main]
  workflow_dispatch:

permissions:
  contents: read
  pages: write
  id-token: write

concurrency:
  group: pages
  cancel-in-progress: false

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: npm
      - uses: actions/configure-pages@v5
      - run: npm ci
      - run: npm run build
      - uses: actions/upload-pages-artifact@v3
        with:
          path: ./dist

  deploy:
    needs: build
    runs-on: ubuntu-latest
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    steps:
      - id: deployment
        uses: actions/deploy-pages@v4

If you started from Astro’s blog template, this file may already exist. Check first before editing.

Enable GitHub Pages

Open your repo, click Settings.
Find Pages in left sidebar.
Set Source to GitHub Actions.
Go back to Actions and wait for workflow success.

After that, your site is usually available at:

https://<your-github-username>.github.io/<your-repo-name>/

Pitfalls I Personally Hit

Site opens but CSS is missing: base is wrong.
Images 404: wrong Markdown image path, prefer relative paths.
Action failed: most often dependency install or Node version issue.
Fresh deployment still 404: wait 1-2 minutes; Pages can lag.
Pushed code but site did not update: likely pushed to wrong branch (not main).
Works locally, white screen online: site + base combination is wrong.
Project path with Chinese chars/spaces: can trigger weird script issues on Windows.
npm install is very slow/stuck: check network first, then switch registry.
Changed config but no effect: some files (like astro.config.mjs) require dev server restart.
Random file-name case changes: Windows is case-insensitive, Linux (Pages) is not, causing online 404.
Editing config directly on GitHub web too often: easy to conflict with local changes.

Deploying to Cloudflare Pages (Recommended: Stronger CDN & Less Maintenance)

If GitHub Pages is already working for you, this is a practical upgrade path worth trying. In real-world use, Cloudflare Pages usually gives you a smoother deployment loop and stronger global delivery out of the box.

Why Consider Cloudflare Pages?

Global CDN: static assets are distributed closer to visitors worldwide.
Automatic HTTPS: certificate and TLS are managed for you.
Automatic deployment from Git: push to branch, trigger build, ship.
Performance and basic security benefits: caching, compression, and edge protection are easier to get right.
Future scalability: you can extend with Pages Functions / Workers and pair with D1 / KV / R2 when needed.

For access quality, keep expectations realistic: international performance is usually excellent; mainland China is often more usable than GitHub Pages, but this is still not the same as a mainland CDN setup with ICP filing.

Step-by-Step Deployment Guide

Create a Cloudflare account and enter the dashboard.
In the left menu, open Workers & Pages.
Choose Pages. In the newer UI, this entry may appear under Looking to deploy Pages? Get started.
Click Import an existing Git repository.
Connect your GitHub account and select your blog repository.
Configure build settings:
- Framework preset: Astro
- Build command: npm run build
- Build output directory: dist
- Production branch: main
Start deployment. After success, open the generated *.pages.dev URL.

My recommendation: validate everything on the default pages.dev domain first, then bind custom domain later.

The Most Common Pitfall: Base Path Issues

This is the one that gets almost everyone once.

GitHub Pages project sites usually live under a subpath like /DansBlog/.
Cloudflare Pages usually serves your site from root path /.
If base still points to /DansBlog/, your page loads as blue links / raw HTML with missing CSS/JS.

Use an environment-based base switch in astro.config.mjs:

import { defineConfig } from 'astro/config';

const isCfPages = process.env.CF_PAGES === '1';
const isGithubProd = !isCfPages && process.env.NODE_ENV === 'production';

const base = isCfPages ? '/' : isGithubProd ? '/DansBlog/' : '/';

export default defineConfig({
  site: 'https://your-domain-or-pages-domain',
  base,
  trailingSlash: 'always',
  output: 'static',
});

Behavior of this setup:

Cloudflare build: base = "/"
GitHub Pages production build: base = "/DansBlog/"
Local dev: base = "/"

Also avoid hardcoded "/DansBlog" in links/components. Prefer import.meta.env.BASE_URL or relative paths.

How to Validate the Deployment

Local simulation first (Windows CMD):

set CF_PAGES=1
npm run build
npx astro preview

Optional PowerShell equivalent:

$env:CF_PAGES='1'
npm run build
npx astro preview

Online validation checklist:

Open your pages.dev URL.
Open DevTools -> Network, confirm 404 count is 0.
View page source and search for "/DansBlog"; it should not appear in Cloudflare deployment output.
Test key routes: home page, article page, tag page, pagination.

pages.dev Domain & Custom Domain

pages.dev is the default free subdomain.
Renaming the project usually changes the subdomain prefix.
If you want your own domain, you usually need to purchase one first.
Cloudflare Pages supports custom domain binding directly in project settings.
Regarding domain acquisition and setup, please consult the guide on How to Register a Cloudflare Domain, which includes a video tutorial.

Accessibility for International & Mainland China Users

Practical expectations:

International visitors: usually very strong performance.
Mainland China users: often more usable than GitHub Pages.
Without ICP备案 and mainland CDN architecture, do not expect domestic-CDN-level stability everywhere.

Low-cost improvements that help a lot:

Self-host fonts instead of relying on Google Fonts.
Minimize third-party external scripts.
Leverage static asset caching (hashed file names + long cache headers).

Wrap-up

By now you already have a very practical workflow: local writing -> git push -> GitHub auto build + deploy.

From here, keep writing and gradually polish your style. Technology is the skeleton; content is the soul. First make it run, then make it beautiful.

I hope you can use AI code tools without psychological pressure. They can significantly improve productivity. For example, this site reached a usable Home/Blog/About structure in about 4 hours on day one, then I spent day two and day three refining details and mobile adaptation.

But do not forget your original goal for building a blog: reliable publishing and reading comes first. Fancy features are optional personal fun. Add them if you want, skip them if you do not.

GoFile Download Tool -- Complete Usage Guide

Wed, 11 Feb 2026 00:00:00 GMT

1. Getting the Project

The project is hosted on GitHub:

https://github.com/rkwyu/gofile-dl

You have two ways to obtain it.

Method 1 — Download ZIP (Recommended)

Open the repository page
Click Code
Select Download ZIP
Extract it to any folder

Method 2 — Clone via Git

If Git is installed:

git clone https://github.com/rkwyu/gofile-dl

2. Install Dependencies

Open the project folder.

Click the address bar, type:

cmd

Press Enter.

Then install dependencies:

python -m pip install -r requirements.txt

Wait until installation finishes.

If Python is not recognized:

python --version

Reinstall Python and enable:

Add Python to PATH

3. Run the Downloader

Execute:

python run.py -i "output_filename.zip" https://gofile.io/d/your_link_id

Example:

python run.py -i "example.zip" https://gofile.io/d/abcd1234

Downloaded files will appear in:

outputs/

4. Common Issues

Python Not Found

Reinstall Python and configure PATH properly.

pip Installation Errors

python -m pip install --upgrade pip

Workflow Summary

Get repository
Install dependencies
Run download command

That’s all.

Notes

This tool is intended for downloading publicly accessible files.
Ensure you comply with applicable laws and platform terms of service.