Within weeks of OpenClaw going viral, the rewrites began. The original TypeScript implementation — brilliant for rapid development and ecosystem reach — carries a runtime footprint that many developers find unacceptable: over 390 MB of RAM at idle, a runtime that requires Node.js, and startup times measured in seconds. For an always-on personal AI gateway, that’s a meaningful cost.
The response from the community has been swift and multilingual. Rust, Go, and Zig all have credible OpenClaw rewrites in active development. Here’s a detailed breakdown of what each brings to the table.
The Baseline: TypeScript (openclaw/openclaw)
The original OpenClaw is written in TypeScript and runs on Node.js. It’s the most feature-complete implementation by a wide margin: 50+ messaging platform connectors, 5,700+ community skills via ClawHub, a rich control dashboard, and the full weight of npm’s ecosystem behind it.
Profile:
- RAM: ~390 MB+ at runtime
- Binary: Distributed via npm — no single binary
- Startup: Several seconds (Node.js initialization)
- Platform: macOS, Linux, Windows (WSL2)
- Ecosystem: Unmatched — every plugin and skill targets this first
The TypeScript version is the right choice if you’re running it on any modern hardware and want the widest compatibility. The 390 MB RAM footprint is negligible on a server or desktop. The problem is the long tail of hardware where it matters: Raspberry Pis, old laptops, ARM boards, and embedded devices.
The Rust Contenders
Rust has attracted the most rewrite activity, and for good reason: zero-cost abstractions, no garbage collector, and memory safety without a runtime. Four significant Rust variants have emerged.
ZeroClaw — zeroclaw-labs/zeroclaw
ZeroClaw is the flagship Rust rewrite, developed by a community spanning Harvard, MIT, and the Sundai Club. The numbers are striking:
- Binary size: ~3.4 MB
- RAM: <5 MB
- Startup: <10ms (claimed 400x faster than OpenClaw)
- Providers: 22+ AI providers supported
- Platforms: Linux, macOS, Windows; ARM, x86, RISC-V
ZeroClaw includes a migration tool (zeroclaw migrate openclaw) that imports existing OpenClaw config and memory, lowering the switching cost. It’s security-first by design: device pairing, sandbox execution, and allowlisting are all built in.
IronClaw — nearai/ironclaw
Near AI’s IronClaw takes a different angle: every untrusted tool runs inside an isolated WebAssembly container. This makes it arguably the most security-hardened of the Rust variants, with a capability-based permission model, endpoint allowlisting, credential injection, leak detection, rate limiting, and Trusted Execution Environment (TEE) support.
Moltis — moltis-org/moltis
Moltis reached v1.0 in February 2026 with a notable claim: zero unsafe Rust code, denied at the workspace level. It ships as a single binary with a built-in web UI, WebSocket streaming, WebAuthn (passkey) authentication, and Docker/Apple Container sandboxing. Multi-provider support covers OpenAI, Anthropic, and GitHub Copilot.
Carapace — puremachinery/carapace
Carapace was explicitly developed in response to the January 2026 vulnerability disclosures. Its defining characteristic is fail-closed authentication — if auth fails, nothing runs. It adds OS-level subprocess sandboxing, signed plugin verification (no unsigned plugins execute), and encrypted secret storage. Provider support is broad: Anthropic, OpenAI, Ollama, Gemini, Vertex AI, AWS Bedrock, and Venice AI.
OpenCrust — opencrust-org/opencrust
OpenCrust positions itself as a straightforward Rust rewrite: a single 16 MB binary with 13 MB idle RAM, encrypted credential storage, and config hot-reload. Less opinionated than Moltis or Carapace, more of a clean-slate reimplementation.
The Go Contender: PicoClaw
PicoClaw — sipeed/picoclaw
PicoClaw is the most downloaded non-Rust variant, built by Sipeed — a company that makes RISC-V embedded hardware. That origin story explains everything about its design philosophy:
- RAM: <10 MB (99% smaller than mainline OpenClaw)
- Binary: Single Go binary
- Startup: <1 second on a 0.6 GHz single-core processor
- Platforms: Raspberry Pi Zero 2 W, embedded devices, x86_64, ARM64, RISC-V, MIPS
- Build targets:
make build-pi-zero,make build-linux-arm,make build-linux-arm64
PicoClaw hit 12,000 stars in its first week — the fastest initial traction of any rewrite variant. Sipeed’s engineers reportedly let an AI agent self-drive the entire Go migration from the TypeScript source.
Go’s garbage collector is occasionally cited as a disadvantage compared to Rust, but in practice, for a gateway process with modest I/O load, it’s not a meaningful concern. PicoClaw’s main limitation is ecosystem: ClawHub skills written for OpenClaw don’t automatically work here.
The Zig Contender: NullClaw
NullClaw — nullclaw/nullclaw
Zig is the most exotic choice in this space, and NullClaw makes a compelling case for it:
- Binary size: 678 KB
- RAM: ~1 MB
- Startup: <8ms
- Stars: ~6,830
- Platforms: Linux x86_64, macOS arm64, macOS x86_64
No garbage collector. No runtime. The 678 KB binary is smaller than many JavaScript files. NullClaw includes the same migrate openclaw tooling as ZeroClaw for config import, and adds Novita AI provider support.
The trade-off is Zig’s ecosystem maturity — it’s a young language with fewer libraries, and NullClaw’s platform support is narrower than the Rust or Go variants (no Windows, no ARM cross-compile targets listed yet).
The Comparison Table
╔═══════════════╦════════════╦═══════════╦══════════╦════════════════════╗ ║ Variant ║ Language ║ RAM ║ Binary ║ Boot Time ║ ╠═══════════════╬════════════╬═══════════╬══════════╬════════════════════╣ ║ openclaw ║ TypeScript ║ ~390 MB+ ║ npm pkg ║ seconds ║ ║ ZeroClaw ║ Rust ║ <5 MB ║ 3.4 MB ║ <10ms ║ ║ PicoClaw ║ Go ║ <10 MB ║ single ║ <1s on 0.6GHz ║ ║ NullClaw ║ Zig ║ ~1 MB ║ 678 KB ║ <8ms ║ ║ OpenCrust ║ Rust ║ 13 MB ║ 16 MB ║ fast ║ ║ NanoClaw ║ TypeScript ║ ~800 KB ║ npm pkg ║ fast (container) ║ ╚═══════════════╩════════════╩═══════════╩══════════╩════════════════════╝
Who Should Use Which?
Use mainline OpenClaw if you want maximum skill/plugin compatibility, are running on modern hardware, and want the full dashboard experience.
Use ZeroClaw if you want Rust's memory safety, near-zero RAM overhead, and 22+ AI provider support on any architecture including ARM and RISC-V.
Use PicoClaw if you're targeting Raspberry Pi or other embedded hardware and want the most battle-tested embedded Go binary with a gentle learning curve.
Use NullClaw if you're chasing absolute minimal resource usage and are comfortable with Zig's rougher edges. 678 KB and 1 MB RAM is genuinely impressive.
Use Moltis or Carapace if security is your primary concern — both offer signed plugins, sandboxed execution, and fail-closed defaults that mainline OpenClaw doesn't.
The rewrite wars aren't over. With NullClaw adding platforms and ZeroClaw pushing its migration tooling, the gap between these variants and the TypeScript original is closing faster than anyone expected.