Forem: 阿豪

ytdlp-jsc: A JS Challenge Solver Without Runtime Dependencies

阿豪 — Fri, 05 Dec 2025 14:25:59 +0000

ytdlp-jsc is a yt-dlp plugin that solves YouTube's JavaScript challenges without requiring external JS runtimes like Node.js or Deno.

GitHub: ahaoboy/ytdlp-jsc

Quick Start

pip install ytdlp-jsc --target ~/.yt-dlp/plugins/
yt-dlp -F "https://www.youtube.com/watch?v=BnnbP7pCIvQ"

[youtube] BnnbP7pCIvQ: Downloading player c816c7d8-main
[youtube] [jsc:ytdlp-jsc] Solving JS challenges using ytdlp-jsc
[info] Available formats for BnnbP7pCIvQ:

Why Not Just Use a JS Runtime?

Runtime vs Engine

Type	Capabilities	Security
Runtime (Node, Deno)	Full system access: file I/O, network, shell	Higher risk
Engine (QuickJS)	JS execution only	Sandboxed

ytdlp-jsc embeds a lightweight JS engine — no system access, no security concerns.

Startup Time Matters

deno a.js    → 400ms
qjs a.js     → 27ms

Deno is safe but slow to start. For a single challenge solve:

Approach	Breakdown	Total
External runtime	CLI start (200ms) + parse (50ms) + codegen (50ms) + run (50ms)	~350ms
ytdlp-jsc (SWC + QJS)	Load .pyd (50ms) + parse (100ms) + codegen (100ms) + run (100ms)	~350ms

Despite using a slower engine, ytdlp-jsc matches runtime performance by eliminating CLI startup overhead.

Benchmarks

Tested on GitHub CI (~5MB binary):

ejs --runtime qjs     1.00x (baseline)
node                  1.35x slower
ytdlp-jsc             1.44x slower
ytdlp-jsc-cli         1.54x slower
bun                   1.56x slower
deno                  1.59x slower

Improving yt-dlp-ejs with Rust: Smaller and Faster

阿豪 — Tue, 02 Dec 2025 13:26:51 +0000

Motivation

In the mpv-easy project, there's a web tool for customizing mpv players and scripts, including yt-dlp. To leverage GitHub CDN (which requires files under 25MB), file size is a constraint. Node/Bun/Deno runtimes are nearly impossible to compress below 25MB, and QuickJS performance in yt-dlp-ejs is suboptimal.

The Problem

The yt-dlp/ejs implementation uses meriyah to parse JavaScript, modifies the AST, regenerates code, and executes it via a JS engine.

Profiling reveals that for lightweight engines like QuickJS and Boa, the bottleneck is code generation. When generating code from a large AST, extensive string concatenation occurs—something these engines don't optimize well. (Note: QuickJS recently added optimizations for this scenario.)

In contrast, SWC's code generation is highly efficient. This explains why SWC + QuickJS outperforms Deno/Node/Bun—their CLI startup time is comparable to JS execution time.

[TRACE] → readFile
[TRACE] ← readFile (2.14ms)
[TRACE] → main
  [TRACE] → preprocessPlayer
    [TRACE] → parse
    [TRACE] ← parse (3187.57ms)
    [TRACE] → filterExpressions
    [TRACE] ← filterExpressions (251.01ms)
    [TRACE] → generate

Solution

Using Rust, SWC replaces meriyah for AST manipulation. For Deno/Node/Bun, code is saved to a temp file and executed via CLI. For QuickJS/Boa, code is executed directly, eliminating CLI startup overhead.

Benchmark Results (Ubuntu)

JavaScript Implementation

Runtime	Pass	Total	Time
bun	316	316	93.207s
node	316	316	90.037s
deno	316	316	100.980s

Rust Implementation

Runtime	Pass	Total	Time
qjs	316	316	80.101s
node	316	316	87.947s
bun	316	316	147.197s
boa	316	316	178.557s
deno	316	316	238.250s

Binary Size Analysis

Using bloaty-metafile for analysis:

Boa: ~6MB
SWC: ~2MB
QuickJS + std::core: ~1MB

With Boa's intl_bundled feature, an additional ~10MB is added. Using SWC + QuickJS keeps the binary under 5MB.

Conclusion

Based on benchmarks, SWC + QuickJS appears to be a compelling alternative—faster execution with a smaller footprint.

Analyzing OpenWrt Storage Usage with wiztree-metafile

阿豪 — Sun, 30 Nov 2025 09:23:33 +0000

https://github.com/ahaoboy/wiztree-metafile

https://esbuild.github.io/analyze/

ei ahaoboy/wiztree-metafile

wiztree-metafile / -i "/proc" -o w.json

Building and Installing Neovim on OpenWrt

阿豪 — Sun, 30 Nov 2025 04:22:04 +0000

Pre-compiled Neovim binaries fail on OpenWrt with interpreter/linker errors:

ei https://github.com/neovim/neovim/releases/download/nightly/nvim-linux-x86_64.tar.gz
nvim
# Error: Failed to execute process: The file exists and is executable.
# Check the interpreter or linker?

This happens due to glibc/musl incompatibility. Building from source ensures compatibility with OpenWrt's musl libc.

Prerequisites

This guide uses OpenWrt 24.10.4 x86_64. For other versions, refer to the original guide.

Installing Dependencies

Install the required build tools and libraries:

opkg update
opkg install git git-http python3 python3-pip make luajit gcc coreutils-install
pip install cmake

Fixing Missing Libraries

OpenWrt's minimal environment lacks some standard libraries that Neovim expects.

Fix Missing libdl

The dynamic linker library is built into musl but needs a stub for linking:

printf "!<arch>\n" > /usr/lib/libdl.a

This creates an empty archive that satisfies the linker without adding actual code (musl already provides dlopen and friends).

Fix Missing libutil

Create a dummy shared library for the utility functions:

echo "int main() { return 0; }" > dummy.c
gcc -shared -o /usr/lib/libutil.so dummy.c
rm dummy.c

Most libutil functions (like forkpty) are either unused by Neovim or provided by other libraries on musl systems.

Building Neovim

Clone the repository (shallow clone to save space):

git clone https://github.com/neovim/neovim --depth=1
cd neovim

Build with release optimizations and debug symbols:

make CMAKE_BUILD_TYPE=RelWithDebInfo

This takes 10-30 minutes depending on your system. The RelWithDebInfo build type provides good performance while keeping some debug information for troubleshooting.

Installing Neovim

Install to the default location:

make install

This installs to /usr/local/bin/nvim. Create a symlink for convenience:

ln -sf /usr/local/bin/nvim /usr/bin/nvim

Verify the installation:

nvim --version

Setting Up LazyVim

LazyVim is a modern Neovim configuration with sensible defaults and a plugin manager.

git clone https://github.com/LazyVim/starter --depth=1 ~/.config/nvim

On first launch, Neovim will automatically install plugins:

nvim

Installing tmux

opkg install tmux

Setting Up VS Code SSH Remote Development on OpenWrt

阿豪 — Sat, 29 Nov 2025 14:45:21 +0000

VS Code's Remote SSH extension requires SFTP (SSH File Transfer Protocol) support, which isn't available in Dropbear, OpenWrt's default SSH server. You'll need to switch to OpenSSH for full compatibility.

Installing OpenSSH

Follow the official OpenWrt guide to replace Dropbear with OpenSSH

Installing Modern tar

VS Code Remote requires a recent version of tar with specific features. OpenWrt's BusyBox tar is too limited:

opkg install tar
tar --version

Configuring SSH on Your Host

Create or edit your SSH config file to simplify connections.

Windows: C:\Users\YourUsername\.ssh\config
Linux/Mac: ~/.ssh/config

Add this configuration:

Host openwrt
  HostName 192.168.56.66
  User root
  IdentityFile ~/.ssh/openwrt

This allows you to connect with just ssh openwrt instead of typing the full command each time.

Connecting with VS Code

Install the Remote - SSH extension in VS Code
Press F1 or Ctrl+Shift+P to open the command palette
Type "Remote-SSH: Connect to Host"
Select openwrt from the list
VS Code will connect and install the VS Code Server on OpenWrt

The first connection takes a few minutes as VS Code downloads and installs its server components (~50-100MB).

Complete Guide to OpenWrt in VirtualBox: Setup and Disk Expansion

阿豪 — Sat, 29 Nov 2025 14:19:59 +0000

Default OpenWrt images have limited storage space. For development and testing, use pre-expanded images from openwrt-virtualbox-build.

Recommended: openwrt-24.10.4-x86-64-generic-ext4-combined.img.vdi

The ext4 filesystem allows post-installation expansion if you need more space later.

Pre-Configuration: Network Setup

Critical: Configure networking before the first boot, or OpenWrt won't have internet access.

Configure VirtualBox Host-Only Network

Open VirtualBox → File → Host Network Manager
Note the adapter IP (default: 192.168.56.1)
In the DHCP Server tab, uncheck "Enable Server"

This prevents IP conflicts between VirtualBox's DHCP and OpenWrt's network configuration.

Creating the Virtual Machine

Basic Settings

OS Type: Linux 2.6
OS Version: Linux 2.6 (64-bit)
Memory: 4096 MB
CPU Cores: 4

Attach the Disk

When prompted for a hard disk, select "Use an existing virtual hard disk file" and choose the downloaded .vdi file.

Network Configuration

Configure two network adapters:

Adapter 1: Host-Only Adapter (for management access from host)
Adapter 2: Bridged Adapter (for internet access)

First Boot Configuration

Set Root Password

After booting, immediately set the administrator password:

passwd

Configure Static IP

Set OpenWrt's IP to match your host-only network range (192.168.56.2-255). Choose a higher number to avoid conflicts:

uci set network.lan.ipaddr=192.168.56.66
uci commit
reboot

The system will reboot with the new IP address.

Setting Up SSH Key Authentication

Generate SSH Key on Host

If you don't already have an SSH key:

ssh-keygen -t rsa

Save it with a descriptive name like ~/.ssh/openwrt.

Add Public Key to OpenWrt

Option 1: Web UI

Navigate to http://192.168.56.66
Go to System → Administration → SSH-Keys
Paste the contents of your ~/.ssh/openwrt.pub file
Click Add Key

Option 2: Command Line

OpenWrt uses Dropbear SSH server, which stores keys in a different location:

cat ~/.ssh/openwrt.pub | ssh root@192.168.56.66 "cat > /etc/dropbear/authorized_keys"

Note: The standard ~/.ssh/authorized_keys path won't work with Dropbear.

Connect via SSH

ssh root@192.168.56.66 -i ~/.ssh/openwrt

You can simplify this by adding an entry to ~/.ssh/config:

Host openwrt
    HostName 192.168.56.66
    User root
    IdentityFile ~/.ssh/openwrt
    Port 22

Then connect with just:

ssh openwrt

Verifying Storage

Check the current filesystem usage:

df -h

Initial output shows limited space:

Filesystem                Size      Used Available Use% Mounted on
/dev/root                98.3M     25.5M     70.7M  27% /
tmpfs                     1.9G    204.0K      1.9G   0% /tmp
/dev/sda1                15.7M      5.7M      9.7M  37% /boot
tmpfs                   512.0K         0    512.0K   0% /dev

Only ~70MB is available on the root filesystem, even though the VDI image is 4GB.

Expanding the Root Filesystem

To utilize the full 4GB capacity, follow the official expansion guide.

# Install packages
opkg update
opkg install parted losetup resize2fs blkid

# Download expand-root.sh
wget -U "" -O expand-root.sh "https://openwrt.org/_export/code/docs/guide-user/advanced/expand_root?codeblock=0"

# Source the script (creates /etc/uci-defaults/70-rootpt-resize and /etc/uci-defaults/80-rootpt-resize, and adds them to /etc/sysupgrade.conf so they will be re-run after a sysupgrade)
. ./expand-root.sh

# Resize root partition and filesystem (will resize partiton, reboot resize filesystem, and reboot again)
sh /etc/uci-defaults/70-rootpt-resize

Verify Expansion

After the reboots complete, check storage again:

df -h

Expected output:

Filesystem                Size      Used Available Use% Mounted on
/dev/root                 4.0G     27.3M      4.0G   1% /
tmpfs                     1.9G    188.0K      1.9G   0% /tmp
/dev/sda1                15.7M      5.7M      9.7M  37% /boot
tmpfs                   512.0K         0    512.0K   0% /dev

The root filesystem now has ~4GB available, perfect for development work.

Running QuickJS Engine with Rust on OpenWrt

阿豪 — Sat, 29 Nov 2025 13:26:04 +0000

Installing Dependencies

Install the required build tools and development packages:

opkg install git git-http python3 python3-pip make gcc coreutils-install

Installing CMake

CMake is required for building native dependencies:

pip install cmake

Installing Rust

Install Rust using rustup, the official Rust toolchain installer:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Building and Running QuickJS

Clone the rquickjs-cli test repository:

git clone https://github.com/ahaoboy/rquickjs-cli.git
cd rquickjs-cli/
echo "console.log('hello openwrt')" > test.js
cargo run -- ./test.js

Expected Output

hello openwrt

Running Node.js and Modern Web Development Tools on OpenWrt

阿豪 — Fri, 28 Nov 2025 15:40:21 +0000

Prerequisites and Limitations

This guide is specifically for x86 architecture only. On ARM devices, both pnpm and Node.js may fail due to libgcc_s.so.1 dependency issues.

System Configuration

First, configure your build target for musl-based systems:

ei config x86_64-unknown-linux-musl

Installing Required Dependencies

Install libstdc++

OpenWrt's minimal environment lacks the C++ standard library:

opkg install libstdcpp

Install Bash

OpenWrt ships with a basic sh shell, but Node.js and pnpm require bash's advanced syntax features.

Download a static bash binary from robxu9/bash-static:

ei robxu9/bash-static

Replace the default shell symlinks:

which bash
ln -sf /root/.ei/bash /bin/sh
ln -sf /root/.ei/bash /bin/bash

Installing Node.js

Node.js requires approximately 200MB of storage. On space-constrained OpenWrt devices, install to /tmp:

ei https://unofficial-builds.nodejs.org/download/release/v25.2.1/node-v25.2.1-linux-x64-musl.tar.xz -d /tmp
node --version

Note: Use the unofficial-builds repository for musl-compatible binaries.

Installing Package Managers and Tools

Install pnpm

ei pnpm/pnpm
pnpm --version

# pnpm fish completions
ei ahaoboy/coreutils-build --name stat

Install Git (Gitoxide)

For a lightweight Git implementation:

ei GitoxideLabs/gitoxide
gix --version

Creating and Running a Vite Project

Now you can use modern web development tools:

# Create a new Vite project
pnpm dlx create-vite

# Navigate to your project
cd react-ts

# Start the development server (accessible from network)
pnpm run dev --host

The --host flag exposes the dev server to your local network, allowing you to access it from other devices.

openwrt: error while loading shared libraries: libgcc_s.so.1: wrong ELF class: ELFCLASS32

阿豪 — Thu, 20 Nov 2025 06:41:20 +0000

The 32-bit version of libgcc_s.so.1 was used on the 64-bit system.

RT-BE88U-A1F0

uname -a
Linux RT-BE88U-A1F0 4.19.294 #1 SMP PREEMPT Wed Jan 22 22:58:22 CST 2025 aarch64 RT-BE88U_Koolcenter_mod

file /lib/libgcc_s.so.1
libgcc_s.so.1: ELF 32-bit LSB shared object, ARM, EABI5 version 1 (SYSV), dynamically linked, stripped

openwrt

uname -a
Linux OpenWrt 6.6.110 #0 SMP Sun Oct 19 16:37:45 2025 x86_64 GNU/Linux

file /lib/libgcc_s.so.1
./libgcc_s.so.1: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, no section header

easy-install: A Rust-Powered Package Installer That Actually Works on OpenWrt

阿豪 — Fri, 14 Nov 2025 10:06:06 +0000

What is easy-install?

easy-install is a cross-platform cli tool written in rust that simplifies installing binaries from GitHub releases and other sources. Think of it as a universal package installer that works across windows, linux, macOS, android and OpenWrt routers.

The beauty of ei is that it handles all the tedious stuff automatically: downloading the correct binary for your platform, extracting archives (even formats like xz that some devices don't support), setting permissions, and managing your PATH.

OpenWrt devices typically have extremely limited storage—often just 30-100MB of usable space. Plus, many regions have restricted GitHub access, and some systems blacklist curl/wget for GitHub domains. easy-install handles all these edge cases elegantly with built-in proxy support and automatic compression.

Installation

Getting started is simple. Use curl or wget:

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

wget -qO- https://raw.githubusercontent.com/easy-install/easy-install/main/install.sh | sh

Or if GitHub access is restricted in your region, use a CDN proxy:

curl -fsSL https://cdn.jsdelivr.net/gh/ahaoboy/ei-assets/install.sh | sh -s -- --proxy jsdelivr

This installs ei to ~/.ei/ei. Add it to your PATH:

export PATH="$HOME/.ei:$PATH"

Configuration for OpenWrt

Configure ei for your architecture (I recommend musl to avoid libgcc_s.so.1 errors):

ei config target x86_64-unknown-linux-musl  # or aarch64-unknown-linux-musl

If GitHub is blocked, set up a proxy:

ei config proxy gh-proxy

For storage-constrained devices, you can change the install directory:

ei config dir /tmp/large_ei

The UPX Trick

Here's where it gets interesting. Most OpenWrt devices have very limited storage:

Filesystem                Size      Used Available Use% Mounted on
/dev/root                98.3M     25.5M     70.7M  27% /

UPX (Ultimate Packer for eXecutables) is a compression tool that can reduce binary sizes by 30-60%. install it with ei:

ei upx/upx
export PATH="$HOME/.ei/upx:$PATH"

Compress ei itself:

upx ~/.ei/ei

     File size         Ratio      Format      Name
--------------------   ------   -----------   -----------
5726880 ->   2388972   41.72%   linux/amd64   ei

Enable automatic UPX compression for all future installs:

ei config upx true

Software I've Installed

Here are some tools I'm running on my OpenWrt router, all installed with a single command:

Fish Shell

Fish is a user-friendly, cross-platform shell with excellent autocompletion.

ei fish-shell/fish-shell
# Output: -rwxr-xr-x 14.5M fish -> 2.9M /root/.ei/fish

That's a 14.5MB binary compressed down to 2.9MB!

Starship

Starship is a blazing-fast, customizable prompt written in rust. It works across any shell and looks gorgeous.

ei starship/starship

Coreutils (rust Edition)

If you hit missing dependency errors (like mktemp), uutils/coreutils provides rust implementations of Unix core utilities.

ei ahaoboy/coreutils-build --name mktemp

Neofetch Alternative

The original neofetch doesn't work well with OpenWrt's default sh. There's a rust implementation that works perfectly:

ei ahaoboy/neofetch

You could also use Brush, a rust-based bash shell implementation.

Dufs

Dufs is a powerful file server with WebDAV support—perfect for sharing media across your local network.

ei sigoden/dufs

Amp

Amp is a text editor with syntax highlighting support for multiple languages.

ei jmacdonald/amp

iperf3

iperf3-static is essential for network speed testing.

ei userdocs/iperf3-static

I shrunk my Rust binary from 11MB to 4.5MB with bloaty-metafile

阿豪 — Sun, 09 Nov 2025 06:48:51 +0000

TL;DR: Used bloaty-metafile to analyze binary size, disabled default features on key dependencies, reduced size by 59% (11MB → 4.5MB)

The Problem

I've been working on easy-install (ei), a CLI tool that automatically downloads and installs binaries from GitHub releases based on your OS and architecture. Think of it like a universal package manager for GitHub releases.

Example: ei ilai-deutel/kibi automatically downloads the right binary for your platform, extracts it to ~/.ei, and adds it to your shell's PATH.

I wanted to run this on OpenWrt routers, which typically have only ~30MB of available storage. Even with standard release optimizations, the binary was still ~10MB:

[profile.release]
debug = false
lto = true
strip = true
opt-level = 3
codegen-units = 1
panic = "abort"

Not good enough.

The Analysis

I used bloaty-metafile to analyze where the bloat was coming from. Turns out, ~80% of the binary size came from just 20% of dependencies:

clap - CLI argument parsing
reqwest - HTTP downloads
tokio - Async runtime
regex - Parsing non-standard release filenames (e.g., biome-linux-x64-musl → x86_64-unknown-linux-musl)
easy-archive - Archive extraction (tar.gz, zip, etc.)

The Optimization

The key insight: disable default features and only enable what you actually use.

1. clap - Saved 100-200KB

clap = { version = "4", features = ["derive", "std"], default-features = false }

Only enable basic functionality. No color output, no suggestions, no fancy formatting.

2. reqwest - Saved ~4MB (!!)

reqwest = { version = "0.12", features = [
  "json",
  "rustls-tls",  # Instead of native-tls
  "gzip"
], default-features = false }

Switching from native-tls to rustls-tls was the biggest win. Native TLS pulls in system dependencies that bloat the binary significantly.

3. tokio - Saved ~100KB

tokio = { version = "1", features = [
  "macros",
  "rt-multi-thread",
], default-features = false }

Only enable the multi-threaded runtime and macros. No I/O, no time, no sync primitives we don't use.

4. regex - Saved ~1MB

regex = { version = "1", default-features = false, features = ["std"] }

Since we only use regex occasionally for URL parsing, we can disable Unicode support and other features.

5. easy-archive - Saved ~1MB

Only enable tar.gz decoding, skip encoding and other formats we don't need.

Results

Before: 11MB
After: 4.5MB

Most crates enable way more than you need. The 80/20 rule applies here - optimizing a few key dependencies can yield massive savings.

Links:

Run FishShell anywhere~

阿豪 — Fri, 17 Oct 2025 13:04:07 +0000

Finally got fish running on all my devices