Posts on Toothbrush's Blog

NT Creative Gallery: One Picture to Explain Core Assets – A Great Assistant for Home Users

Sat, 12 Jul 2025 17:42:38 +0800

⚠️ Disclaimer
All images displayed on this page were generated by the Google Gemini AI model, automatically synthesized based on user-provided prompts. They are not photographs nor representations of real events. The content is provided for visual creative reference only and does not represent real people, locations, products, or events, nor does it constitute any form of advice or commitment.

According to the Gemini Terms of Use and its Content Policy, the copyright of generated images belongs to Google or is produced under its authorization. Users are responsible for ensuring compliance with applicable laws and regulations, and the content must not be used for any commercial purpose that violates copyright, trademark, or publicity rights.

If you have questions or request content removal, please contact us using the method at the bottom of this page.

Get in touch (Google Mail): wth88888888

My Smart Assistant 3.0: Building a Fully Automated "Time Screening Room"

Sat, 12 Jul 2025 17:10:27 +0800

Welcome back to my “lazy” photography system series. In the previous chapters, we witnessed how an ordinary webcam was endowed with the ability to “think,” and how I built an elegant and convenient “control room” for it. However, the story doesn’t end there. Our clever photographer has been smartly “slacking off” every day, accurately capturing a vast number of valuable moments. These photos, like scattered pearls, contain the secrets of time, quietly resting deep within the server’s hard drive.

It’s time to string these pearls together, letting them shine brilliantly through the flow of light and shadow. Today, I will show you the final chapter of this project, which I personally find the most exciting — building a fully automated “Time Screening Room.” At the core of this screening room is a powerful and reliable shell script. It is the “behind-the-scenes director” of my entire system, entrusted with a sacred mission: before each quiet dawn arrives, automatically merging tens of thousands of photos from the previous day into wonderful time-lapse videos.

Project code: https://github.com/AndroidOL/camera-capture/tree/main/merge

From “Material Pileup” to “Visual Poems”: The Final “Billion” Step

Imagine what life would be like without this automated “director.” It would mean that every day, I’d have to act like a “miner” in the digital age — manually logging into a remote server to dig through tens of thousands of photos from the previous day, which might amount to dozens of gigabytes; then carefully downloading these “raw ores” to my local computer; next, launching complex video editing software, painstakingly dragging each photo onto the timeline, setting frame rates, encoders, bitrates… and finally clicking “render” after a long wait.

This entire process is not only a battle of patience and endurance with no creativity but also prone to errors. If one day I forget or get too busy at work and miss it, the “visual diary” for that day will have an irreplaceable gap. That’s not what I want.

What I need is a fully unattended, extremely stable and reliable, and smart enough automated process. It should be a tireless artist that quietly starts at a fixed time every day, for example, in the dead of night, and like a skilled film editor, carefully arranges the scattered materials of the previous day into a complete film, then elegantly places it on the digital shelf of the “family film library,” waiting for my review.

Thus, this labor of love — the automation script daily_photo_to_video.sh — was born. It’s far from a simple ffmpeg command wrapper; it is an industrial-grade robust “smart production line.”

The Director’s Extraordinary Skills: Revealing the Core Design of the Automation Script

The design philosophy of this script is “pursue ultimate stability and efficiency.” I armed it to the teeth so that it can calmly handle all foreseeable and even unforeseeable complex situations.

1. Ultimate Efficiency: Squeezing Every Drop of Hardware Potential

Highway — Ramdisk (In-Memory Disk)
Reading tens of thousands of scattered small images on a traditional hard drive while writing a huge video file immediately exposes disk I/O bottlenecks, making the whole process painfully slow. My solution is radical: directly carve out a high-speed virtual disk (Ramdisk) in the server’s precious memory.

When the script starts, it first synchronizes all photos to be processed from the photo server to this memory disk via high-speed network. Then, all intensive read-write operations of video synthesis (encoding) are performed entirely on this virtual disk. Memory read/write speeds are tens or even hundreds of times faster than ordinary hard drives, which is like building a “star highway” that ignores physical laws and travels at light speed for data migration, greatly shortening processing time.

Professional Engine — Hardware Encoding (HEVC_RKMPP)
Video encoding is a typical CPU-intensive task. Relying solely on the CPU to “hard compute” is like asking a versatile but tired butler to do a highly specialized woodworking job — inefficient and causing the server’s “heartbeat” (CPU usage) to spike and the fans to roar. Fortunately, the server I use (based on Rockchip chips) has a dedicated video processing unit (VPU).

My script precisely calls ffmpeg and specifies the use of the hevc_rkmpp hardware encoder. This is equivalent to handing the professional work to a specially hired, highly skilled “film editor,” letting the VPU handle the heaviest encoding tasks, fully freeing the CPU. Meanwhile, I choose the efficient HEVC (H.265) encoding format, which maintains very high picture quality while compressing the video size to about half of traditional H.264, saving massive precious space in my “family film library.”

2. Foundation of Stability: Industrial-Grade Fault Tolerance and Self-Healing

A spaceship sailing alone in the wilderness values not only speed but also its ability to survive cosmic storms. Likewise, a script that needs to run unattended for years requires strong resilience. I built four layers of “security protocols” to handle various possible accidents.

Scenario	Script’s Smart Response Strategy
Unexpected script interruption	Uses `trap` cleanup mechanism to automatically clear temp files and unmount Ramdisk on interruption
Concurrent run conflicts	Uses `flock` file lock to avoid conflicts from multiple instances running concurrently
Insufficient storage space	Pre-checks available space in target path to avoid write failures midway
Target disk disconnection	Automatically switches to backup storage path, ensures task completion, and pauses old task catch-up

3. Smart Scheduling: Never Miss a Day’s Highlights

I want every day’s video in my “screening room” to be complete, like a coherent chronicle. Therefore, the smartest and proudest part of the script is its almost obsessive “completion” logic.

When running, the script:

Reviews logs from the past 7 days, checking for missing or failed videos;
If omissions are found, it prioritizes filling gaps starting from the earliest day;
Verifies that remote materials still exist to avoid pointless runs;
Only after confirming completeness does it process “yesterday’s” new materials.

This way, the system gains memory and responsibility, always maintaining a complete “visual diary.”

The Birth of a “Family Epic”

Now, this has become a ritual-filled daily routine. Every morning, when I brew coffee and open the “family film library,” a brand-new time-lapse video named after yesterday’s date quietly rests there.

It might capture the entire thunderstorm outside the window, or my figure working late into the night, or simply portray the traces of sunlight flowing through the home.

This automated script is like a silent but powerful heart, injecting endless vitality into my entire smart photography project. It transforms day-after-day trivial visual data into distilled visual poems full of time’s essence, turning cold data into warm memories, allowing me to truly “see” and “cherish” those silently passing moments.

The Joy of Creation

The joy of creation lies here — using code and logic to build a system that automatically creates, organizes, and presents beauty for us.

Next steps might be training an AI to automatically add the most fitting background music to these videos, or editing “weekly highlights.”

The journey to a “better life” through creation is endless, and that is its true charm.

My Smart Assistant 2.0: Giving the “Lazy” Photography System a Panoramic Window

Sat, 12 Jul 2025 16:19:04 +0800

It’s been a while since I last shared my “lazy” photography system—the one that decides when to snap a photo and when to chill. This little helper has been quietly working for me all this time. But as time went on, a new pain point emerged: while its inner workings were smart, the way I interacted with it remained… primitive.

Project code: https://github.com/AndroidOL/camera-capture/tree/main/web-ui

From “Command Line Archaeology” to “Tap of a Finger”: A Revolution in Experience

In the past, every interaction with the system felt like digital archaeology inside a server:

Want to see yesterday’s shots? Fire up your SSH client, connect to the server, and navigate through a maze of directories with cd and ls.
Want to tweak sensitivity settings? Use Vim or Nano to edit config files, save, and systemctl restart—then cross your fingers you didn’t miss a comma.

This was cumbersome and emotionally distant. My smart assistant—its joys, its output—was locked behind the black box of a terminal.

So I opened a window for it: a wide panoramic floor-to-ceiling window in the form of a web control console, designed for intuitive, elegant interaction—even from the comfort of a couch.

Now, everything has changed:

Open a browser and enter the local address;
A beautiful and powerful interface appears;
The once-silent background photographer now has a vivid “face” and nimble “hands.”

Its components:

Eyes: A real-time monitor with zero delay.
Hands: Clickable button menus for full control.
Brain: Complex logic wrapped in an intuitive design.

Four Superpowers of the Web Console

1. Time Drawer: A Tiered Photo Archive

Inspired by real-life “drawers,” navigating photos now feels like opening a set of Russian nesting dolls:

Year/Month view: See all months with recordings.
Daily preview: Thumbnail grid for each date.
Hourly drawers: Tap to reveal 24-hour distributions.
Minute-level access: Dig down to individual images.

Browsing becomes light, fun, and ceremonial.

2. Real-Time Window: A Watchful, Never-Blinking Guardian

Tap “Live Monitor,” and the system enters watch mode:

Heartbeat refresh: The frontend fetches a new frame every 2.5 seconds.
Auto-reconnect: Camera outages are self-healed.
Night mode: Auto-dimming for dark environments—no eye strain.

3. Time Tunnel: Your Personal Documentary Generator

The “Slideshow” mode is my favorite feature:

Select any date range (e.g., “2025 Cherry Blossom Season”);
The system stitches together all relevant photos into a dynamic time-lapse.

Highlights:

Slide mode: Chronologically ordered playback.
Smooth transitions: Fade-in/out between shots.
Timestamp overlay: Auto-displayed capture time at the bottom.

🎞️ I used this to relive the cherry blossom bloom—from bud to fall—utterly moving and magical.

4. Thoughtful Themes: A Smart and Caring Interface

As a night owl, I added a theme toggle:

Day mode: Blue-white for clarity.
Night mode: Deep black and crimson for eye comfort.
Auto-memory: Remembers your last-used theme.

Like a friend who just gets you.

Dev Diary: Humanizing the System, One Mishap at a Time

The Midnight Panic

One night while debugging live view, the screen started flashing like crazy!
Turned out I mistakenly set 250ms instead of 2500ms—the camera nearly became a strobe light.

The Naming Crisis

Initially, I named my API get_image_list.
A few weeks later, even I had no clue what it did.

A New Lens on Life: When Tech Becomes Daily Ritual

The web console made this system part of my life:

☕ Morning coffee ritual: Wake up with the latest time-lapse visuals.
🌱 Plant growth journal: Weekly recaps via the “Time Tunnel.”
🖼️ Family time machine: Cast time-lapse memories during gatherings.

An Invitation to Makers

Building this isn’t hard:

# ----- Essentials -----

# Hardware: Raspberry Pi / any Linux device + webcam
# Image processing: Python + OpenCV
# Frontend: HTML + JavaScript + CSS
# Backend: PHP

Each module is like a LEGO block—ready to be customized, expanded, or swapped.

The warmth of technology lies in how we use it to illuminate and document life. I hope you too can open your own “window of time” and watch your story unfold.

My Smart Assistant: A Time-Lapse System That Knows When to Be Lazy

Sat, 12 Jul 2025 15:38:51 +0800

There’s a quiet poetry flowing through everyday life, often unnoticed. I became fascinated with time-lapse photography because it compresses long stretches of time into captivating moments, letting us witness slow transformations with the naked eye—it’s like magic unfolding through time.

So I dusted off an old USB webcam that had been asleep in a drawer for years, sparked by a gentle thought: I want to record life’s subtle breath—the kind we often overlook in our hurried pace. Like the succulent on the balcony slowly stretching toward sunlight; the drifting clouds outside, sculpted into shapes by an invisible hand; or how the evening sun casts long, warm shadows across the living room floor inch by inch…

Project Code: https://github.com/AndroidOL/camera-capture

From “Diligent Fool” to “Smart Slacker”: A Shift in Philosophy

At first, my approach was simple and direct, like many others: write a script to turn the webcam into a tireless “model worker,” snapping a photo every minute on the dot. The moment I finished and successfully ran the code, I felt a wave of achievement. But that joy quickly turned into mixed disappointment the next morning.

There they were—1,440 neatly organized photos, a testament to my program’s “diligence.” Yet scrolling through them felt lifeless and frozen. Especially during the long hours of the night—say, between 3:00 and 3:01 AM—everything looked identical: the dust on the coffee table hadn’t budged, and even the air seemed still. I realized I hadn’t built a tool for recording “change,” but a factory for producing repetition.

Once I calmly calculated this “digital legacy,” the scale of the problem became clear:

Alarming Storage Consumption

Daily output: 43,200 photos
Monthly output: ~1,296,000 photos
Annual output: Over 473 million photos

Assuming 0.2MB per 1920×1080 photo, that’s nearly 8GB per day—reasonable for a desktop setup, but excessive for embedded devices like the ESP32 or RK boards.

Destructive Post-Production Workload

Footage screening: To produce a few minutes of highlights, you’d have to sift through hundreds of thousands of nearly identical “waste shots.”
Time cost: This isn’t artistic creation—it’s soul-draining manual labor.

To better illustrate the contrast, I created this table:

Feature	“Diligent Fool” Mode	“Smart Slacker” Mode
Operating Principle	Uniform, scheduled capturing	Intelligent, on-demand capture
Photos per hour	Constant 1,800	Dozens to hundreds (based on changes)
Storage efficiency	Very low, linear explosion	Very high, only saves useful data
Post-workload	Huge, painful screening	Minimal, most shots are valuable
Final output quality	Filled with static “waste time”	Tight pacing, focused on change

Clearly, the latter is what I needed—a wise system that knows when to act and when to chill.

Giving the Camera a Brain: Laziness as Productivity

So I set out to upgrade my system with real intelligence. This time, I didn’t teach it to work harder—I taught it a more elegant skill: how to slack off smartly.

Its core principle is like a seasoned intelligence officer who only reports when something actually matters—no boring “all clear” updates, just action when there’s movement.

To empower this discernment, I designed a three-step “smart pipeline”:

Visual Purification: Seeing the Essence, Not the Surface

Morning cool light and evening warm light may color the scene differently, even if nothing has moved. So before comparison, the system converts both current and archived frames to grayscale “sketch mode.”

Quantifying Change: Giving Weight to Differences

The system overlays two grayscale images pixel by pixel, generating a “change map.” It calculates the percentage of light areas to assess the degree of difference.

The Art of Decision-Making: A Smart Laziness Threshold

I set a threshold—say 0.5%. If the detected change is below this, the frame is skipped. Only significant changes are recorded, saving resources and capturing only the meaningful.

A Thoughtful Housekeeper: A System That Runs Itself

To ensure 24/7 stability, I implemented multiple layers of resilience:

A Custom “Biological Clock”

Sampling frequencies tuned to household rhythms:

Morning glow (6–8 AM): every 5 seconds
Daytime activity (8 AM–6 PM): every 2 seconds
Evening mood (6–10 PM): every 5 seconds
Midnight patrol (10 PM–6 AM): every 10 seconds

Strategic Storage Management

When storage usage hits 85%, the system auto-deletes the oldest photos to maintain space.

Survival Instincts

In case of power loss or camera disconnects, the system includes auto-reconnect and retry logic to self-heal and stay online.

Unexpected Rewards: Becoming a Quiet Observer of Life

The results far exceeded my expectations. It allowed me to observe:

A Miniature Home Sundial

By tracking sunlight shifts on the floor, it became a massive clock of shadow and light.

The Silent Dance of Plants

In time-lapse, my succulent turned toward the sun like it was engaging in a dialogue with life.

The Moving Landscape Outside

It captured drifting clouds, droplets melting from the roof after snow, everything like a living poem.

The Joy of Creation Lies in the Process

From the initial spark to a mature system, this 0-to-1 journey gave me indescribable satisfaction.

The beauty of technology isn’t in complexity, but in how we use it to understand and embrace life.

If you also feel passion for creation, start with a tiny idea. The real barrier is never the tools—it’s whether you’re willing to tinker, to explore.

Begin your journey now. Go capture your own, one-of-a-kind story in time.

Next-Terminal: A Secure Access Solution for Home Networks

Fri, 11 Jul 2025 19:43:25 +0800

A New Secure Access Approach for Home Networks: Next-Terminal in Practice

With the rapid spread of information technology, more and more home users are building their own servers, mini NAS systems, and home automation centers. At the same time, how to securely, efficiently, and cost-effectively access these devices from the public internet has become an urgent issue to solve.

The open-source project Next-Terminal (abbreviated as NT) offers an elegant solution for home users. It’s not only open-source and free, but also extremely lightweight (only around 200MB) and highly performant. It can be easily deployed on public nodes such as Alibaba Cloud, Tencent Cloud, or other lightweight cloud instances, serving as the single entry point for all traffic. NT securely forwards requests to various services in the home network, achieving unified management of secure proxy and access control.

1. Security Risks of Exposing Home Networks to the Internet

1.1 Common Ways of Home Network Exposure

Suppose you’ve set up a website or NAS device at home and want to access it remotely. Common approaches include:

Port forwarding on the home router (using a public IP);
Domain name resolution to a dynamic home IP (Dynamic DNS);
Direct connection using IPv6 address.

1.2 Potential Security Risks from Public Exposure

Regardless of whether you use DDNS or IPv6, exposing your device to the public internet means:

A significantly increased chance of being scanned by attackers;
Anyone who knows your IP can try to connect;
If there are any vulnerabilities (e.g., outdated NAS, PHP flaws), attackers might compromise your internal network.

In IPv4, NAT allows many internal devices to access the internet using one public IP. However, with IPv6, each device can have its own public IP, which facilitates direct communication but introduces new threats:

Predictable addresses — attackers can guess address ranges based on a known /60 prefix;
Every device at home (router, NAS, cameras, smart TVs) has its own IPv6 address;
Knowing one server address could allow inference of the entire network prefix;
Despite the vast IPv6 space, targeted scans and brute force attacks are still feasible;
Many home devices lack strict IPv6 firewall configurations, meaning open ports might be directly accessible.

Security Alert: The global reachability of IPv6 makes home devices more vulnerable to targeting and attacks.

2. How Does Next-Terminal Help Solve These Problems?

Next-Terminal uses a “unified entry proxy + fine-grained access control” approach with key features such as:

No exposure of internal ports to the public internet;
Ports open only to trusted entry points;
Supports fine-grained access control and login authentication;
Auditable, manageable, and authorizable access to your services.

graph LR
    A[User] --> B[NT Public Node]
    B --> C[Home Gateway]
    C --> D[Internal Services]

Scenario: Securely Exposing a Home Website to the Internet

Suppose you have a website at http://192.168.1.100:8080 on your home network and want to access it from outside — but don’t want anyone to be able to connect directly.

Traditional method: Port forwarding — risky
Improved method: Use NT for reverse proxy + authentication

Steps (With Public IP):

Deploy Next-Terminal on a public server (e.g., Alibaba Cloud);
Configure your home firewall to only allow the public server’s IP to access relevant ports;
Add internal assets (like your home website) and configure port mapping;
Enable authentication and authorization (multi-factor authentication, passkeys, etc.);
External users access via NT’s web interface — requests are proxied to your internal service after verification.

Steps (Without Public IP):

Deploy Next-Terminal on a public server;
Deploy NT secure gateway in your home (e.g., container or mini host);
Register the NT gateway with the NT platform;
Add internal assets to be accessed;
Enable authentication and authorization;
External users access through NT — the public server proxies requests to the NT gateway, which forwards to internal services.

3. Firewall Strategy: Trust Only the Public Server, Reject Everything Else

To further enhance security, configure firewall rules on your home router or soft router:

Only allow the NT public server’s IP (e.g., Alibaba Cloud) to access specific ports (like NAS port 8080);
Block all other IPs from accessing these ports.

This ensures “only trusted servers can access your home network”, preventing connections even if your public IP is known.

# Example firewall rule (assuming home gateway uses iptables)
# Allow access from Alibaba Cloud IP to port 8080
iptables -A INPUT -p tcp -s <NT_Public_IP> --dport 8080 -j ACCEPT
# Drop access from all other IPs to port 8080
iptables -A INPUT -p tcp --dport 8080 -j DROP

4. Comparison with Traditional VPN and FRP Solutions

Feature	VPN	FRP	NextTerminal ✅
Security	High (requires hardware)	Medium (requires setup)	High (granular control)
Usability	Requires client	Complex config	Web-based access
Deployment Difficulty	Easy (hardware)	Moderate	Easy (container deployment)
User Access Control	✅ Supported	❌ Not supported	✅ Supported
Logging & Audit	Hard to query	❌ Not supported	✅ Supported
Internal Service Proxy	✅ Auto config	Manual port mapping	✅ Auto proxy

5. Extended Use Cases: More Than Just Website Access

NextTerminal can proxy not only websites, but also:

Remote SSH access to home Linux machines;
RDP access to Windows desktops;
NAS directory browsing (e.g., via WebDAV);
Access to camera admin panels;
Connect to HomeAssistant, Aria2, Transmission, and other home services.

All with a unified entry point and unified identity authentication.

A Note to Developers: Don’t Let Open Source Go Unnoticed

Next-Terminal is a free, open-source secure ops platform developed by a Chinese developer and maintained actively on GitHub. Whether you’re a developer, ops engineer, or home user, it’s strongly recommended to:

Try deploying and using the platform yourself;
Give the project a ⭐️ Star;
Share it in your blog or community;
Suggest features or contribute docs to help improve it!

📘 References and Recommended Links

Project: https://github.com/dushixiang/next-terminal
Docs: https://next-terminal.dushixiang.com
IPv6 Security (Google Research Paper): https://research.google/pubs/pub46246/
Home Security Setup Guide (Zhihu): https://zhuanlan.zhihu.com/p/620203743

Conclusion

Next-Terminal is not just a great enterprise remote ops platform — it’s also perfect for home users. By building a unified and secure access point, you no longer have to worry about public internet attacks, deal with complex VPN setups, or risk exposing your internal network.

The security of home IT infrastructure is something every tech enthusiast should care about. Start today by deploying Next-Terminal and level up your network security.

Getting Started with Hugo Website Setup

Fri, 11 Jul 2025 15:25:51 +0800

This article provides a detailed guide on how to build a Hugo static website from scratch on macOS without relying on Homebrew. It includes key operations such as adding a Git-based theme, modifying configurations, and creating content, helping you quickly set up your own high-performance blog.

1. Preparation: Install Hugo and Git

1.1 Manually Download and Install Hugo

Open the Hugo official Releases page.
Download the Extended version for macOS, such as:
hugo_extended_0.148.0_darwin-universal.tar.gz

Run the following commands in the terminal:

cd ~/Downloads
tar -zxvf hugo_extended_0.148.0_darwin-universal.tar.gz
sudo mv hugo /usr/local/bin/
chmod +x /usr/local/bin/hugo


4. Verify the installation:
    ```bash
    hugo version
    ```

Make sure the output includes the word `extended`.

---

### 1.2 Install and Verify Git

macOS comes with Git preinstalled. If not, follow the prompt to install Xcode Command Line Tools:

```bash
git --version

Ensure the Git version is displayed correctly.

2. Create a Hugo Project

2.1 Create a New Site

`1`	`hugo new site www-blog`

www-blog is the name of the new folder. You can name it anything — it does not affect your blog’s title or content, only the root directory name.

2.2 Enter the Project Directory

`1`	`cd www-blog`

3. Add a Theme

3.1 Add an Official Theme via Git (Example: Ananke)

1
2

git init
git submodule add https://github.com/theNewDynamic/gohugo-theme-ananke.git themes/ananke

Tip: If you encounter network or proxy issues, manually download the ZIP file and extract it into the themes/ananke folder.

3.2 Modify Config File to Enable the Theme

Edit hugo.toml in the project root directory and add or modify the following:

baseURL = "http://example.org/"
languageCode = "zh-CN"
title = "My Hugo Blog"
theme = "ananke"

4. Create Content

4.1 Create a New Markdown Post

`1`	`hugo new posts/hello.md`

4.2 Edit the Post Content

Open content/posts/hello.md, change draft: true to draft: false. Example content:

---
title: "Hello Hugo"
date: 2025-07-11T14:00:00+08:00
draft: false
---

This is my first blog post created with Hugo.  
Welcome to read and share!

5. Preview the Website Locally

Start the local Hugo server:

`1`	`hugo server -D`

Then open your browser and visit:

`1`	`http://localhost:1313`

You’ll see the homepage rendered with your theme and content.

6. Generate Static Site Files

After stopping the server, run:

hugo

The static files will be generated in the public/ folder under the project root.

7. Deploy to GitHub Pages

7.1 Create a New GitHub Repository (e.g., `www-blog`)

7.2 Push the `public` Folder Content to `gh-pages` Branch

cd public
git init
git remote add origin https://github.com/your-username/www-blog.git
git checkout -b gh-pages
git add .
git commit -m "Initial Hugo site deployment"
git push -f origin gh-pages

7.3 Enable GitHub Pages in Repository Settings

Go to Settings → Pages
Select the gh-pages branch as the publishing source
After saving, wait a few minutes and visit:

`1`	`https://your-username.github.io/www-blog/`

8. Summary Notes

The folder name in hugo new site <folder-name> is only the project directory name, it does not affect the blog title or URL.
Blog title and site configuration are set in hugo.toml, and can be changed anytime.
Themes are added via Git submodules, but you can also download and extract the theme manually.
Make sure to set draft: false when writing posts, or they won’t be published.
Use hugo server -D for local preview, and hugo command to generate static site files.