Born after 2005, Gen Z, sophomore majoring in Electronic Information Engineering. I play basketball, game (LoL, CS2), and I'm learning English on the side — not great at it yet, but working on it.

Science student. My writing has always been pretty plain. But I think a good article has only one standard: the reader can understand it. That, I can manage.

What This Blog Is For​

Written for myself. To record things I've figured out, and to verify whether I've actually figured them out. If you can follow along too, great.

The content is mostly technical: AI tools, Mac development, things I've used and found worth writing down. You know the feeling — a lot of GitHub projects hit you with "set up your environment" right at step one. I don't want to write like that.

About This Site​

No ads, and there won't be. I can guarantee that. I hate ads, and I don't want anyone here to be interrupted — including me, because I'm a reader here too.

I care about the experience. The site should be fast, pages should be clean, open it and you don't have to think — just find what you want to read.

As for making money, I'll figure that out later. But only one condition: it won't come at the cost of the experience.

I don't really care how many people read this. I care about how well I write.

Summary​

okay, that's everything I want this site to be.

There's a Chinese saying: "知行合一" — to unify knowing and doing. I'll hold myself to that: turn what I think, and what I demand of myself, into reality.

Why Claude Code "Wastes" Tokens​

When you ask Claude Code an architecture question — like "how does this request reach the database?" — it first spins up an Explore sub-agent, runs a bunch of grep/ls/Read operations to find files, and only then starts analyzing. The whole exploration process burns tokens, and a lot of the time it reads a bunch of irrelevant files along the way.

CodeGraph's approach: do all that exploration work up front, index it into a local SQLite database. Claude Code queries it directly — one tool call returns the source code of relevant symbols, call graphs, and dependency relationships, without scanning files.

Installation​

Install the CLI (macOS/Linux, no Node.js required):

curl -fsSL https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.sh | sh

After installing, open a new terminal — otherwise the codegraph command won't be found.

Hook into Claude Code:

codegraph install

It auto-detects which AI tools you have installed (Claude Code, Cursor, Gemini CLI, etc.) — just select Claude Code, no need to check anything else.

Initialize a project:

cd your-project
codegraph init -i

-i is --index — creates the directory and indexes the codebase in one step. After that, a file watcher handles incremental updates automatically — no manual management needed.

How to tell if a project is already initialized?

ls your-project/.codegraph

If the folder exists, it's been indexed. If not, run codegraph init -i once.

Quick note: I initially thought GSAP was for video editing, like HeyGen — turns out it's completely different. GSAP is for web animations — the kind you see in a browser: elements flying in, scroll parallax, number counters rolling up, all rendered live on the page, not as video files. Once I got that straight, I decided to install it in Claude Code and give it a shot.

What Is GSAP​

GSAP (GreenSock Animation Platform) is currently the most popular JavaScript web animation library. Its core strengths:

• Fine-grained control: pause, reverse, and precisely time every animation
• ScrollTrigger: handles scroll-linked animations — parallax, scroll-triggered effects, pinned elements, all straightforward
• Timeline: sequence multiple elements' animations in just a few lines
• Performance: operates on transforms under the hood, on par with CSS animations

Compared to CSS animations:

Good news: GSAP is now completely free — including previously paid-only plugins like SplitText and MorphSVG. Everything is open to everyone, including commercial use.

What Is gsap-skills​

AI models' knowledge of GSAP may be outdated — for example, how ScrollTrigger is written today, or how to clean up in React. With gsap-skills installed, Claude Code can write code using the correct APIs, knows how each plugin works, and follows React best practices.

It includes 8 skills:

Installing gsap-skills​

Run in your terminal:

npx skills add https://github.com/greensock/gsap-skills

The first run will prompt you to install skills@1.5.9 — enter y to confirm.

You'll then be asked which skills to install. Use spacebar to check, Enter to confirm. For a blog project (Docusaurus / React), these four are enough:

• ✅ gsap-core
• ✅ gsap-scrolltrigger
• ✅ gsap-timeline
• ✅ gsap-react

For the remaining prompts:

• Agent: select Claude Code
• Installation scope: select Global (global install — works across all projects without reinstalling)
• Installation method: select Symlink (recommended — auto-syncs when the skill updates)

After installation, the skills are saved to ~/.claude/skills/.

Can't find the .claude folder? It's hidden. In Finder, press ⌘ + Shift + . (period) to show all hidden files. Press again to hide them.

How to Use It​

No special commands needed after installation. Just describe the animation you want in Claude Code, and Claude will automatically use the relevant skill to write correct code.

For example:

"Add an entrance animation to the title on my blog homepage using GSAP"

"Use ScrollTrigger to make an animation trigger when the user scrolls to a certain section"

Real Example: Scroll-In Animation for Blog Post Cards​

Say your blog has a post list page where each card flies in from below when the user scrolls to it — a very common effect.

First, install GSAP:

npm install gsap

Then in your React component:

import { useEffect, useRef } from "react";
import { gsap } from "gsap";
import { ScrollTrigger } from "gsap/ScrollTrigger";

gsap.registerPlugin(ScrollTrigger);

export default function BlogCard({ title, date, description }) {
  const cardRef = useRef(null);

  useEffect(() => {
    const ctx = gsap.context(() => {
      gsap.from(cardRef.current, {
        y: 60,           // flies in from 60px below
        opacity: 0,      // fades in from transparent
        duration: 0.7,
        ease: "power2.out",
        scrollTrigger: {
          trigger: cardRef.current,
          start: "top 85%",  // triggers when element top enters 85% of viewport
        },
      });
    }, cardRef);

    return () => ctx.revert(); // cleanup on unmount — prevents memory leaks
  }, []);

  return (
    <div ref={cardRef} className="blog-card">
      <h2>{title}</h2>
      <span>{date}</span>
      <p>{description}</p>
    </div>
  );
}

The result: as the user scrolls down, each card flies in from below one by one, creating a layered entrance effect. Change start: "top 85%" to "top 70%" to trigger later — experiment until it feels right.

Summary​

GSAP is for web animations — not video. That's the important thing to get right first 😂.

The value of gsap-skills is that it lets Claude Code truly understand GSAP — not just write code, but write correct code: no outdated APIs, no missing cleanup in React. Setup takes five minutes. After that, just describe what you want and let Claude write it — no need to memorize any API.

If your blog or project needs scroll animations, page transitions, or element entrances, GSAP is the best open-source option out there right now.

What It Is​

Open CoDesign is a desktop AI design tool. The core idea is simple: you enter a prompt, it generates a viewable HTML prototype page. It's positioned as an open-source alternative to Claude Design, v0, and Lovable. Key points:

• Runs locally — your data stays on your machine
• BYOK (Bring Your Own Key) — supports Claude, GPT, Gemini, and Ollama
• MIT open-source — free to use; you only pay for your own model's API costs
• Exports real files — HTML, PDF, PPTX, ZIP, all supported

Deployment​

Requirements​

• Node.js v22+
• pnpm 10.x

# Check Node version
node -v

# Install pnpm
npm install -g pnpm@10.33.4

Clone & Install​

git clone https://github.com/OpenCoworkAI/open-codesign.git
cd open-codesign
pnpm install

pnpm install takes a minute or two — wait for it to finish.

Start​

pnpm dev

After a moment, an Electron window will appear. The first time, it asks you to configure a provider — paste in your Claude API key (sk-ant-...), test the connection, and you're ready to go.

How It Feels in Practice​

Generation Speed​

With the Claude API, a medium-complexity page takes about 20–40 seconds to generate. During generation, there's an Agent panel on the left showing what the AI is doing in real time — which files it wrote, which tools it called. It's not a black box, and it's kind of interesting to watch.

Output Quality​

There are 15 built-in demo templates (landing pages, dashboards, pricing pages, chat UIs, etc.) — pick one and tweak the prompt, and you have a solid starting point. It also comes with 12 design skill modules that are automatically selected based on your prompt, so the output doesn't look like that typical generic "AI aesthetic."

Comment Mode​

A genuinely useful feature: click any element in the preview and leave a comment, then let the AI rewrite just that section without having to re-describe the whole page. Much more precise than modifying the prompt from scratch.

AI Sliders​

After generation, the AI automatically identifies "tunable parameters" — like primary color, font size, spacing — and presents them as sliders. No need to write "change the button color to blue" in a new prompt.

vs. Claude Design​

Summary​

If you already have a Claude API key, the setup cost is low — worth trying.

Setting Up the Environment​

Your Mac needs the following four tools. Install them in order.

Homebrew​

macOS package manager — the foundation for installing everything else.

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Verify:

brew --version

✅ Success: shows Homebrew 4.x.x ❌ Failure: shows command not found

ffmpeg​

Merges audio and video streams — without it you'll only get a silent video.

brew install ffmpeg

Verify:

ffmpeg -version

✅ Success: shows ffmpeg version 7.x.x ❌ Failure: shows command not found

Node.js​

Solves YouTube's JS encryption challenge — without it all format options are lost.

brew install node

Verify:

node --version

✅ Success: shows v26.x.x ❌ Failure: shows command not found

yt-dlp​

The core download library.

pip3 install yt-dlp --break-system-packages

Verify:

yt-dlp --version

✅ Success: shows 2026.x.xx ❌ Failure: shows command not found

Two Extra Configuration Steps​

Grant Terminal Full Disk Access (needed to read Safari cookies)

System Settings → Privacy & Security → Full Disk Access → Add "Terminal"

Enable a proxy (required to access YouTube outside China)

I'm definitely not going to teach you that one!

Get the Code​

You can download the script I wrote, or write it yourself (or have AI write it — see the next section).

Download main.py

Script contents:

import subprocess
import sys
import os

# ── Configuration ────────────────────────────────────────────────────────────
VIDEO_URL  = "XXXX"                           # Replace with a real YouTube URL
OUTPUT_DIR = os.path.expanduser("~/Desktop")  # Output to Desktop
NODE_PATH  = "/opt/homebrew/bin/node"         # Node.js path (installed via Homebrew)
# ─────────────────────────────────────────────────────────────────────────────


def download_video(url: str, output_dir: str) -> None:
    """
    Calls the yt-dlp CLI to download a YouTube video in H.264 MP4 format.
    """
    output_template = os.path.join(output_dir, "%(title)s.%(ext)s")

    cmd = [
        "yt-dlp",
        # Prefer H.264 video stream + best audio
        "--format", "bestvideo[vcodec^=avc1]+bestaudio/bestvideo[ext=mp4]+bestaudio/best",
        # Force MP4 container
        "--merge-output-format", "mp4",
        # Specify Node.js path for solving YouTube's JS encryption
        "--js-runtimes", f"node:{NODE_PATH}",
        # Download JS challenge decryption script from GitHub (requires internet on first run)
        "--remote-components", "ejs:github",
        # Read Safari cookies to bypass bot detection
        "--cookies-from-browser", "safari",
        # Output file path template
        "--output", output_template,
        url,
    ]

    print(f"[INFO] Starting download: {url}")
    print(f"[INFO] Output directory: {output_dir}\n")

    result = subprocess.run(cmd)

    if result.returncode == 0:
        print("\n[✓] Download complete! Video saved to Desktop.")
    else:
        print("\n[✗] Download failed. Check the error output above.", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    # Supports passing a URL as a command-line argument: python3 main.py <url>
    url = sys.argv[1] if len(sys.argv) > 1 else VIDEO_URL

    if url == "XXXX":
        print("[✗] Please replace VIDEO_URL with a real URL, or pass it as a command-line argument.",
              file=sys.stderr)
        print("    Usage: python3 main.py \"YouTube URL\"", file=sys.stderr)
        sys.exit(1)

    download_video(url, OUTPUT_DIR)

The Lazy Approach: Let AI Write the Code​

Don't want to write the code yourself? Just paste one of these prompts into ChatGPT, DeepSeek, or Claude and they'll output a working script.

English prompt (recommended — more stable output):

I need you to help me set up a YouTube video download environment on macOS and write a complete Python script.

## My Environment
- Device: MacBook (Apple Silicon, M-series chip)
- OS: macOS

## What I Need You To Do

### Step 1 — Check and Install Dependencies
Check whether the following tools are installed one by one. If not, provide the install command:
1. Homebrew: via https://brew.sh/
2. ffmpeg: via brew install ffmpeg
3. Node.js: via brew install node
4. yt-dlp: via pip3 install yt-dlp --break-system-packages

### Step 2 — Write the Python Script
Filename: youtube_downloader.py
Requirements:
- Use subprocess to call the yt-dlp CLI (do NOT use the yt_dlp Python API)
- Video format: H.264 codec, MP4 container
- Quality: automatically select the highest available quality
- Cookies: read from Safari (--cookies-from-browser safari)
- Node.js path: /opt/homebrew/bin/node
- Include --remote-components ejs:github to solve JS challenges
- Output directory: Desktop (~/Desktop)
- Accept video URL as a command-line argument: python3 youtube_downloader.py "YouTube URL"
- Add comments in English

### Step 3 — Tell Me How To Use It
Explain how to run the script in one sentence.

## Important Notes
- macOS root directory / is read-only — do NOT output files there
- Terminal needs Full Disk Access enabled in System Settings to read Safari cookies — please remind me to do this
- Do NOT use "ios" as the player_client — it does not support cookies

AI can write the code for you, but you still need to set up the environment yourself (the four tools above). If you don't want to do that manually either, use Claude Code or Codex to run the install commands automatically — just keep clicking yes.

Usage​

Once the environment is set up, every download only takes one command.

Open Terminal and run:

python3 ~/Downloads/main.py "paste your YouTube URL here"

If you saved main.py somewhere else, replace ~/Downloads/main.py with the actual path. ~/Downloads refers to your Downloads folder — no need to substitute your username.

Example:

python3 ~/Downloads/main.py "https://www.youtube.com/watch?v=5wvq8w7YBXU"

Press Enter and wait — the video will appear on your Desktop when done.

Two things to check before each use:

① Your proxy is active (e.g. Shadowrocket is connected)

② You're using a freshly opened Terminal window (not one that's been open for days)

You only need to set up the environment once. After that, any YouTube URL works.

FAQ​

What is Homebrew? I wrote a separate post about it — check that out.

What video quality will I get? The highest available by default. This line in the script controls the resolution selection logic:

"bestvideo[vcodec^=avc1]+bestaudio/bestvideo[ext=mp4]+bestaudio/best"

It selects the highest-quality stream among all H.264-encoded video tracks.

Terminal is stuck and nothing's happening? The first run downloads a decryption script from the internet, which can be slow on some networks. Make sure your proxy is active, or wait 1–2 minutes.

command not found error? A dependency didn't install correctly. Go back to the "Setting Up the Environment" section and verify each tool one by one.

permission denied or cookie read failure? Terminal doesn't have Full Disk Access. Go to System Settings → Privacy & Security → Full Disk Access → Add "Terminal", then open a new Terminal window and try again.

Download failed and you can't read the error? Check in order: ① Is your proxy on? ② Is yt-dlp up to date? (pip3 install -U yt-dlp --break-system-packages) ③ Is the URL complete and wrapped in quotes?

"The most popular command-line package manager for macOS."

Still hunting down installers one by one on official websites? With Homebrew, one command handles everything — install, update, uninstall — all managed in one place. Say goodbye to manual downloads.

Homebrew is a package manager for macOS and Linux. Its core value in one sentence: manage all your software from the command line, unified.

Installing Homebrew​

In China​

Due to network restrictions, using a domestic mirror is recommended: source

/bin/bash -c "$(curl -fsSL https://gitee.com/ineo6/homebrew-install/raw/master/install.sh)"

Outside China​

Use the official script: source

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Core Concepts: formula and cask​

Before using Homebrew, understand two key concepts:

• formula: installs command-line tools like git or python — no graphical interface
• cask: installs GUI apps like Firefox or VS Code

Simple rule: App with an icon → cask; command-line only → formula.

Not talking about Gragas from League of Legends 😂

Installing Software​

Install a command-line tool (formula), e.g. git:

brew install git

Install a GUI app (cask), e.g. Firefox:

brew install --cask firefox

Updating Software​

Before upgrading, refresh Homebrew's package list to get the latest versions:

brew update  # refresh the package list (like refreshing the App Store)

Then upgrade a specific package, e.g. Python:

brew upgrade python

Note: brew update updates Homebrew's own package index; brew upgrade actually upgrades the software. They are different.

Pinning a Version​

Sometimes you don't want a package to be auto-upgraded — for example, your project depends on a specific version of Python and upgrading would break things. Use pin to lock the version:

brew pin python  # lock python, prevent auto-upgrade

List pinned packages:

brew list --pinned

Unpin to allow upgrades again:

brew unpin python

Uninstalling Software​

Uninstall a command-line tool:

brew uninstall node

Uninstall a GUI app:

brew uninstall --cask firefox

Uninstall Homebrew itself:

/bin/bash -c "$(curl -fsSL https://gitee.com/ineo6/homebrew-install/raw/master/uninstall.sh)"

Summary​

These commands cover the vast majority of everyday Homebrew usage. In my opinion, Homebrew is an essential tool for every Mac — it's simply too convenient to go without.

Preface:​

I personally enjoy browsing instructables — the site helpfully provides an "Export article as PDF" button in the top right, but no "Export as Markdown" option. I really wanted Markdown format, since AI tools prefer reading .md over PDF. After searching online, I found this GitHub project.

Setting Up the Environment​

Prerequisites​

• Python 3.10 or higher
• Conda is recommended for environment management (explained below)

If you're on a Mac M1/M2/M3, no extra configuration is needed — PyTorch natively supports Apple Silicon.

Install Conda​

Miniforge is recommended: lightweight and well-supported on Apple Silicon.

# macOS Apple Silicon
curl -L -O https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-MacOSX-arm64.sh
bash Miniforge3-MacOSX-arm64.sh

After installation, run this command so Terminal recognizes conda:

~/miniforge3/bin/conda init zsh

Then close and reopen Terminal. You'll see (base) at the start of your prompt — conda is ready.

Create a Virtual Environment​

Think of a virtual environment as a separate "room" for this project — packages installed here won't affect anything else on your system.

conda create -n marker python=3.11 -y
conda activate marker

Once activated, your prompt changes from (base) to (marker).

Install Marker​

pip install marker-pdf

If you also need to convert Word, PPT, or EPUB files:

pip install marker-pdf[full]

Verify Installation​

marker_single --help

Wait about 10–15 seconds. If a list of parameters is printed, you're good to go.

Activating the Environment Each Session​

Every time you open a new Terminal, remember to activate the environment first:

conda activate marker

How to Use​

The basic format is a single line:

marker_single /path/to/your/file --output_dir /output/directory

Useful options:

• --output_dir: specify the output folder
• --output_format: output format — markdown, json, or html
• --page_range: convert specific pages, e.g. "0,5-10" (pages are 0-indexed)
• --force_ocr: force OCR — use this when text in the PDF is actually an image
• --langs zh: tells Marker the document is in Chinese for better accuracy
• --use_llm: use an LLM for assistance — higher accuracy, requires an API key

After conversion, the output folder will contain a .md file and extracted images. Open with Typora or Obsidian for proper rendering.

Practical Examples​

Convert a Research Paper​

marker_single ~/Downloads/paper.pdf \
  --output_dir ~/Documents/notes

The first run downloads the AI models (~1 GB) — be patient. Afterwards, math formulas are converted to LaTeX, tables and headings are preserved. Results are quite good.

Let AI Tools Handle the Deployment​

If the steps above feel tedious, paste this prompt into Claude Code, Cursor, or a similar AI tool and let it set up the environment automatically.

You are a professional Python environment configuration engineer. Please fully deploy the marker-pdf runtime environment on this machine.

My setup: macOS Apple Silicon (M1 Pro), shell is zsh, Conda is installed at ~/miniforge3.

Please complete the following steps in order, check the result after each step, and immediately diagnose and fix any errors:

1. Check if conda is available (conda --version). If not, run ~/miniforge3/bin/conda init zsh and remind me to reopen Terminal.
2. Create and activate a virtual environment: conda create -n marker python=3.11 -y && conda activate marker
3. Install marker: pip install marker-pdf
4. Verify PyTorch: python -c "import torch; print(torch.__version__)". If you see a libtorch_cpu.dylib error, reinstall immediately: pip uninstall torch torchvision torchaudio -y && pip install torch torchvision torchaudio
5. Verify marker: run marker_single --help, wait ~20 seconds. A list of parameters means success.

Tell me what you're doing before each step. Do not modify system-level configuration. When done, output the installed versions of Python, PyTorch, and marker-pdf.

Uninstalling​

Uninstall only the marker package, keep the environment:

conda activate marker
pip uninstall marker-pdf

Delete the entire environment (more thorough):

conda deactivate
conda env remove -n marker

Troubleshooting​

Terminal is stuck? The first run downloads models, which can be slow on some networks. Try configuring a proxy for Terminal:

export https_proxy=http://127.0.0.1:YOUR_PORT

libtorch_cpu.dylib error on Mac? Reinstall PyTorch:

pip uninstall torch torchvision torchaudio -y
pip install torch torchvision torchaudio

Poor Chinese recognition? Add --langs zh. For scanned documents, also add --force_ocr.

command not found? The environment isn't activated. Run conda activate marker first.

Summary​

Marker is essentially a locally-running document parsing engine, powered by AI models specifically trained on document layouts — not a general-purpose LLM. This makes it fast, offline-capable, and effective without any API key. It excels at complex academic PDFs: converting math formulas to LaTeX, preserving table structure, and extracting images separately. If you need to organize large volumes of documents into a knowledge base, or want to feed PDF content into an LLM for further processing, Marker is one of the best open-source options available.

Based on datalab-to/marker, compatible with marker v1.x

1. Qi Li Xiang (Seven-Mile Fragrance) - A timeless melody with the taste of summer.
2. Ye Qu (Nocturne) - The moment that intro plays, memories come flooding back.
3. Qing Tian (Clear Sky) - The secret crush and regret of adolescence.
4. Yi Fu Zhi Ming (In the Name of the Father) - The pinnacle of his dark style.
5. Qing Hua Ci (Blue and White Porcelain) - A beautiful ode to Chinese aesthetics.

These songs are more than just melodies — they are the mark of time.

Want to listen? Click below to open the player. You can upload local audio files and .lrc lyrics files to enjoy Apple Music-style scrolling lyrics.

In most cases, running DNS flush + DHCP reset is enough to fix the majority of network issues.

Common Commands (in recommended order)​

1. Flush DNS Cache​

sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder

2. Release and Renew IP Address (DHCP)​

sudo ipconfig set en0 DHCP

Recommended Order​

Google is great for everyday searches. DuckDuckGo and Brave are better for privacy-conscious users. Yandex is good for finding edgier content. Bing (Chinese version) works as a fallback if you can't access international sites.

Engine Characteristics​

• Google: Results for controversial content lean toward mainstream PC viewpoints; opposing views are sparse and weak.
• DuckDuckGo: More neutral than Google, but search keywords aren't highlighted in results — you'll need a userscript to fix that (see end of post). (Any AI can write the script for you.)
• Yandex: Completely ignores Western political correctness; good for sensitive or edgy content.
  • e.g. Search "Epstein list" — only Yandex puts the actual list at the top
  • e.g. Search "Hollywood scandals" — only Yandex shows hard-hitting results
• Political correctness level: Google > Brave > DuckDuckGo > Yandex

2. Practical Search Tips​

Software Resources & Free Music Downloads​

Use Yandex and search:

software name + cracked / premium / unlocked / Скачать

Look for results with Russian-language links — they usually allow direct download. Works for Android, PC, and Mac.

Finding E-books (Anna's Archive / Z-Library)​

Quick tip: if you Google "Anna's Archive" or "Z-Library", you'll likely get a bunch of unrelated results. Try Yandex instead — the first result is almost always what you're looking for. (Yandex is genuinely underrated!)

keyword + edition      
keyword + translation  

3. DuckDuckGo Keyword Highlight Userscript​

Requires the Tampermonkey browser extension.

javascript

// ==UserScript==
// @name         DuckDuckGo Search Keyword Highlight
// @namespace    http://tampermonkey.net/
// @version      2025-08-05
// @description  Highlights search keywords in DuckDuckGo results
// @author       You
// @match        https://duckduckgo.com/?*
// @grant        GM_addStyle
// ==/UserScript==
(function() {
    'use strict';
    GM_addStyle(`
        .kY2IgmnCmOGjharHErah span b {
            color: #ff897e !important;
        }
    `);
})();

4. FAQ​

1. I searched the way you described but got no results — why? Search engines use safe mode by default. Go to Settings and turn it off — look for "No filter" (filter = content filtering; no filter = uncensored results). That's the one you want.

What Is Kokoro​

Kokoro is an open-source TTS (text-to-speech) model with 82M parameters — lightweight but surprisingly good. English quality approaches ElevenLabs commercial level, with 88 voices to choose from and an Apache 2.0 license, free for commercial use.

We'll use kokoro-web — a project that wraps Kokoro into a local service, launched with a single Docker command, with a web UI included, ready to use out of the box.

Choosing a Voice​

Kokoro voices are graded A–D by quality, A being highest. For English, just pick from these:

The first time you use a voice, its model file is downloaded automatically and cached — no need to re-download.

Installing Docker​

If you don't have Docker yet, install it first.

International network: download from the official site: docker.com/products/docker-desktop

Chinese network: the official site can be slow, use Aliyun's mirror:

https://mirrors.aliyun.com/docker-toolbox/mac/docker-for-mac/

Download the .dmg, double-click to install, open Docker Desktop, and wait for the 🐳 icon to appear in the menu bar.

Then configure the command-line path so Terminal can find the docker command:

echo 'export PATH="$PATH:/Applications/Docker.app/Contents/Resources/bin"' >> ~/.zshrc
source ~/.zshrc

Verify the installation:

docker --version && docker compose version

Deploying kokoro-web​

1. Create a project directory​

mkdir kokoro-web && cd kokoro-web

Make sure you cd into the folder before doing anything else. The docker compose commands must run inside this directory, otherwise you'll get no configuration file provided.

2. Create the config file​

cat > compose.yaml << 'EOF'
services:
  kokoro-web:
    image: ghcr.io/eduardolat/kokoro-web:latest
    ports:
      - "3000:3000"
    environment:
      - KW_SECRET_API_KEY=my-secret-key
    volumes:
      - ./kokoro-cache:/kokoro/cache
    restart: unless-stopped
EOF

KW_SECRET_API_KEY is the access password for the local service — for local use, anything works, just remember what you set. I'd suggest leaving it as the default.

3. Start the service​

docker compose up -d

The first start pulls the image, which can be slow on some networks — be patient.

Once you see this, it's up:

docker compose logs -f
# Success: Listening on http://0.0.0.0:3000

Using the Web UI​

Open your browser and go to http://localhost:3000.

Configure the API (important)​

Click API Settings in the top right corner:

• Base URL: http://localhost:3000/api/v1 (default, no change needed)
• API Key: my-secret-key

Gotcha: the API Key is just the value itself — don't include the - KW_SECRET_API_KEY= prefix from the compose file.

Click OK.

Generation Settings​

Back on the main screen, a few key options:

Always set Execution place to API (Self-hosted). Running in the browser runs the model in your browser — much slower and re-downloads every time.

Paste your article into Text to process, then click Generate.

Demo​

Input text:

Google is renowned for its innovative and employee-centric work environment. The company's campuses, often called "Googleplexes," feature vibrant designs with open spaces, recreational facilities, free gourmet meals, and wellness centers. Employees enjoy flexible work hours, remote options, and a strong emphasis on collaboration through team projects and hackathons.

A culture of creativity thrives with "20% time," encouraging personal passion projects that have led to major products like Gmail. Diversity, inclusion, and continuous learning are prioritized through training programs and supportive leadership. This unique blend of fun, freedom, and purpose fosters high productivity and job satisfaction, making Google a top destination for tech talent worldwide.

Generated with the Heart voice (~150 words, ~30 seconds on local CPU):

Processing Markdown Files​

Kokoro only accepts plain text. Pasting a .md file directly will cause it to read out ##, **bold**, and other Markdown syntax aloud.

Use pandoc to convert first:

# Install pandoc
brew install pandoc

# Convert md to plain text, then copy-paste the output
pandoc article.md -t plain

Useful Commands​

docker compose logs -f    # view live logs
docker compose stop       # stop the service
docker compose start      # start the service
docker compose pull       # update to the latest version

Environment: MacBook Pro M1 Pro · macOS · Docker Desktop 29.4.3

2. prevent

   • Example: This option will ==prevent== Shadowrocket from being set as the default route.
   • Meaning: to stop something from happening; to block

3. modifier

   • Example: A new ==modifier== creates a new view based on the original one.
   • Meaning: (in SwiftUI) a method that transforms or configures a view

4. components

   • Example: One of the most common and recognizable user interface ==components== is the combination of an icon and a label.
   • Meaning: individual parts or elements that make up a larger system; components

5. idiom

   • Example: This ==idiom== appears across many kinds of apps and shows up in collections, lists, menus of action items, and disclosable lists, just to name a few.
   • Meaning: a common pattern or convention in UI/programming; an established way of doing something

6. just to name a few

   • Example: This idiom appears across many kinds of apps and shows up in collections, lists, menus of action items, and disclosable lists, ==just to name a few==.
   • Meaning: used to indicate that only a small number of examples are being given; "among others"

7. interface

   • Example: You create the user ==interface==, or UI, for your app inside the body; the entire contents of your app are in the code below.
   • Meaning: the visual layer of an application that users interact with; user interface (UI)

// NOTE: - Demo code
import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundColor(.tint)
            
            Text("Hello World")
        }
    }
}

#Preview {
    ContentView()
}

8. instance

   • Example: To construct your narrative, the app needs an ==instance== of Story, which takes an array of StoryPage instances.
   • Meaning: a specific occurrence of an object created from a class or struct

9. hold

   • Example: The text property ==holds== a String that describes the choice readers can make.
   • Meaning: to store or contain a value; to hold

10. present

    • Example: Use a navigation stack to ==present== a stack of views over a root view.
    • Meaning: to display or show a view on screen

11. indicates

    • Example: A value-destination ==indicates== that you are pushing a value onto the path.
    • Meaning: to signal or show that something is the case; to indicate

2. One for all, all for one

   • Example: The three friends made a pact: ==one for all, all for one==. They promised to stand by each other no matter what challenges lay ahead.
   • Meaning: a phrase expressing mutual support and solidarity within a group

3. Be careful, though

   • Example: The restaurant is amazing and cheap. ==Be careful==, though: it gets really crowded on weekends.
   • Meaning: used to add a warning or caveat after a positive statement; "that said, watch out for..."

4. embedded in

   • Example: These attitudes are ==embedded in== our society.
   • Meaning: deeply ingrained or firmly fixed within something; deeply rooted in

5. enthusiasts

   • Example: She is one of the most dedicated fitness ==enthusiasts== I have ever met.
   • Meaning: people who are highly interested in and passionate about a particular activity or subject