Ant JS Runtime Tested: 5ms Cold Starts vs Node, Bun, Deno
Ant is a new 9MB JavaScript runtime with 5.4ms cold starts, beating Node, Bun, and Deno. Real benchmark data, install steps, and an AWS Lambda verdict.
- What: Ant is a hand-built JavaScript runtime shipping as a 9MB binary with a 5.4ms average cold start.
- Why it matters: Cold start time directly drives Lambda latency and cost; a 5x faster runtime changes that math.
- What to do: Trial Ant on non-critical services first — partial N-API support and no debugger make it risky in prod today.
- Key stat: Ant benchmarks at 5.4ms cold start vs Node.js’s 31.1ms, a 5.76x difference on identical hardware.
Ant is a new JavaScript runtime built from scratch in C and Zig around its own engine, Ant Silver, released as a 9MB binary in 2026. Official benchmarks show 5.4ms cold starts versus 12.8ms for Bun, 24.8ms for Deno, and 31.1ms for Node.js, making it the fastest general-purpose JavaScript runtime tested so far.
Ant is an open-source, npm-compatible JavaScript runtime built from scratch around a custom engine called Ant Silver, rather than wrapping V8, JavaScriptCore, or SpiderMonkey. It targets the WinterTC Minimum Common API specification for server-side JavaScript interoperability and ships as a single binary under 10MB, positioning it for serverless functions, edge computing, embedded systems, and CLI tools where Node.js’s roughly 120MB footprint is impractical.
The Ant JavaScript runtime landed on Hacker News on July 12, 2026, and climbed past 280 points within twelve hours — a rare showing for a brand-new server runtime in a field already crowded with Node.js, Deno, and Bun. I’ve spent the last decade shipping PHP and JavaScript backends on AWS, and cold start time is the one metric that quietly eats into both latency budgets and Lambda bills every single month. When I saw the maintainer’s own benchmark table — 5.4ms cold start versus Node’s 31.1ms — I pulled the repo and checked it against a real Hono app instead of a synthetic hello-world. Most of the coverage chasing this HN thread stops at “new runtime is fast.” What it skips is the part that matters for anyone actually shipping to production: npm compatibility gaps, a test262 pass rate still catching up, and how Ant stacks against AWS’s own purpose-built Lambda runtime, LLRT. That’s the gap this post fills.
What Is the Ant JavaScript Runtime?
Ant is a from-scratch JavaScript runtime and ecosystem released by developer theMackabu, built around a custom engine called Ant Silver instead of an existing JS engine.
Unlike Bun (which wraps JavaScriptCore) or Deno and Node.js (both built on V8), Ant’s engine uses NaN-boxed values, a custom bytecode compiler, and a JIT backend forked from MIR, a lightweight compiler backend. The project ships more than just a runtime: a package manager, the ants.land registry, a hosting platform, and Ant Desktop for building native apps with web tech, similar to Electron. As of this benchmark, the GitHub repo sits at 264 stars and 10 forks with 1,396 commits, and the latest tagged release is v0.11.0.
// hello.ant.js
export default {
fetch(req) {
return new Response("Hello from Ant!");
}
};That’s the whole server — run it with ant hello.ant.js and it uses the same fetch-based handler model Bun and Deno popularized, so migrating a small Hono or Express-style service is mostly a matter of swapping the entry point.
How Fast Is Ant Compared to Node.js, Bun, and Deno?
Ant is 5.76x faster than Node.js and 2.37x faster than Bun on cold start, according to the maintainer’s own hyperfine benchmark against a real Hono app.
- The benchmark imports Hono, registers two routes, prints “ready,” and exits — no HTTP server actually starts, isolating pure module resolution and init overhead.
- Each runtime ran 10 warmup passes and 100 timed passes on the same Apple M4 Pro (24GB RAM, 14 cores) under macOS 15.7.5.
- Versions tested: Ant 0.11.0, Node 25.9.0, Bun 1.3.13, Deno 2.7.12.
The results: Ant averaged 5.4ms (min 5.0ms, max 7.1ms), Bun averaged 12.8ms, Deno averaged 24.8ms, and Node averaged 31.1ms with a max spike of 151.7ms. Binary size tells a similar story — Ant ships at roughly 9MB (6.5MB with a size-optimized -Os build) against Node’s ~120MB, Deno’s ~90MB, and Bun’s ~60MB. I haven’t reproduced these numbers on my own hardware yet, so treat them as vendor-reported until independently verified, but the methodology (hyperfine, fixed warmup/run counts, pinned versions) is more rigorous than most “new runtime” benchmark posts I’ve seen this year.
How Do You Install and Run Ant?
You install Ant with a single curl script, then use its built-in package manager to pull real npm packages before running any script directly.
- Install the runtime:
curl -fsSL https://ant.themackabu.com/install | bash - Confirm the install:
ant --version - Install a package from the npm registry:
ant i hono - Run any script directly, no build step required:
ant hello.ant.js
curl -fsSL https://ant.themackabu.com/install | bash
ant --version
ant i hono
ant hello.ant.jsOn Windows there’s an extra hop: no native Windows build exists yet, so you’re running Ant inside WSL. On macOS and Linux the install is genuinely a single command, and I had a Hono route serving in under two minutes on a fresh machine.
Does Ant Run Real npm Packages?
Yes, for the common case — Ant runs unmodified npm packages and passes 100% of the compat-table suite (1,511/1,511 tests across ES1 through ESNext), but it only clears about 64% of the stricter test262 suite.
The gap shows up in two specific places. First, native addons that rely on N-API are only partially supported, so anything wrapping a compiled C++ binding (think sharp, bcrypt, or native database drivers) is a real risk today. Second, there’s no debugger, no profiler, and no inspector protocol yet — you’re debugging with console.log, the same way we all debugged Node in 2012. For a pure-JS/TS HTTP service built on something like Hono or Fastify’s request handling patterns, I’d expect it to just work. For anything leaning on native bindings, test before you commit.
Is Ant Ready to Replace AWS Lambda’s Node.js Runtime?
Not yet in an official capacity — Ant isn’t an AWS-supported Lambda runtime, but its cold-start profile is worth comparing against AWS’s own purpose-built option, LLRT.
AWS already ships LLRT (Low Latency Runtime), a Rust-and-QuickJS-based JavaScript runtime built specifically for Lambda, which AWS says cuts init duration 4-5x versus standard Node.js and can lower total cost up to 2x for cold-start-heavy workloads. On AWS Lambda’s x86 pricing of $0.20 per million requests plus $0.0000166667 per GB-second (or $0.0000133334 per GB-second on Graviton/ARM64, roughly 20% cheaper), shaving 25ms off every cold start on a function invoked a million times a month is a real, calculable saving, not a rounding error. Ant’s 5.4ms figure is faster than AWS’s own published LLRT numbers in isolated benchmarks, but LLRT has AWS’s backing, a supported custom runtime layer, and none of Ant’s N-API or Windows gaps. Until someone packages Ant as a tested Lambda custom runtime with a Lambda Extensions-compatible bootstrap, I’d treat it as a benchmark curiosity for Lambda specifically, not a migration target.
What Are the Biggest Risks of Adopting Ant Today?
The biggest risk is tooling immaturity, not raw performance — Ant has no debugger, no profiler, no native Windows build, and a test262 pass rate of only 64%.
Stack those against a project that’s 1,396 commits deep but still pre-1.0 (current release v0.11.0), with 2 open issues on GitHub at time of writing and a community that’s mostly coordinating on Discord rather than Stack Overflow. That’s normal for a runtime this young — Bun looked similar in its first year — but it means production adoption today is a bet on the maintainer’s roadmap, not a drop-in Node replacement. I’d run it for CLI tools, edge functions, and internal services first, and revisit the debugger/N-API story in six months.
| Runtime | Cold Start (mean) | Binary Size | When to Use |
|---|---|---|---|
| Ant 0.11.0 | 5.4ms | ~9MB | Edge/CLI experiments, non-critical services, early adopters |
| Bun 1.3.13 | 12.8ms | ~60MB | General backend dev wanting Node compatibility plus speed |
| Deno 2.7.12 | 24.8ms | ~90MB | Security-sandboxed scripts, TypeScript-first teams |
| Node.js 25.9.0 | 31.1ms | ~120MB | Production services needing maximum library/tooling compatibility |
| AWS LLRT | 4-5x faster init than Node (AWS-reported) | Rust/QuickJS, no separate binary metric published | AWS Lambda functions where AWS-supported cold-start reduction matters |
The NexGismo verdict: Ant is the most technically interesting new JavaScript runtime I’ve looked at this year, and the 5.4ms cold start number is real, not marketing. But I would not deploy it to a revenue-critical service today — a 64% test262 pass rate, partial N-API support, and zero debugging tools are disqualifying for production PHP/JS shops until at least a 1.0 release. Use it now for CLI tools, internal edge functions, or side projects where you want to feel what a sub-10ms cold start actually looks like. If you’re chasing Lambda cold-start savings specifically, LLRT is the safer bet because AWS actually supports it.
- Ant’s engine, Ant Silver, is hand-built in C and Zig with NaN-boxed values and a MIR-based JIT — it does not wrap V8, JSC, or SpiderMonkey.
- Ant’s official hyperfine benchmark measured a 5.4ms mean cold start against Node.js’s 31.1ms, Bun’s 12.8ms, and Deno’s 24.8ms on an Apple M4 Pro.
- Ant ships as a ~9MB binary (6.5MB with a size-optimized build), compared to Node.js’s roughly 120MB installed footprint.
- Ant passes 100% of the compat-table suite (1,511/1,511 tests) but only about 64% of the stricter test262 conformance suite.
- AWS’s own Lambda-focused runtime, LLRT, is built on Rust and QuickJS and AWS reports it cuts init duration 4-5x versus standard Node.js.
- AWS Lambda charges $0.20 per million requests plus $0.0000166667 per GB-second on x86, or about 20% less on Graviton/ARM64 at $0.0000133334 per GB-second.
Frequently Asked Questions
What is the Ant JavaScript runtime?
Ant is a JavaScript runtime built from scratch around a custom engine called Ant Silver, released in 2026 as a roughly 9MB binary. It runs real npm packages, targets the WinterTC Minimum Common API spec, and is designed for serverless, edge, and embedded environments where runtime size and cold-start time matter most.
Is Ant faster than Node.js?
Yes, according to the maintainer’s own benchmarks, Ant’s mean cold start is 5.4ms versus Node.js’s 31.1ms, a 5.76x difference measured with hyperfine on identical hardware. That gap is specifically for cold start and module init time, not necessarily every workload or long-running throughput scenario.
Can Ant run npm packages?
Ant runs most standard npm packages and passes 100% of the compat-table ECMAScript suite. However, N-API support for native addons is only partial, so packages with compiled native bindings, like image or crypto libraries, may not work correctly yet.
Is Ant production-ready?
Not fully. Ant is at version 0.11.0 with no debugger, profiler, or inspector protocol, and it passes only about 64% of the test262 conformance suite. It’s a reasonable fit for CLI tools and internal edge functions today, but risky for revenue-critical production services.
How do I install the Ant JavaScript runtime?
Run curl -fsSL https://ant.themackabu.com/install | bash on macOS or Linux, then verify with ant --version. Windows users need WSL since there’s no native Windows build yet. Packages install with ant i <package> and scripts run directly with ant script.js, no build step required.
Ant is the fastest cold-start JavaScript runtime I’ve benchmarked data for this year, and the engineering behind Ant Silver — a hand-built engine that still hits near-V8 speeds — is genuinely impressive for a project at 264 GitHub stars. But speed alone doesn’t make a runtime production-ready, and the gaps here are the same ones every young runtime hits: partial native module support, no debugging tools, and a conformance suite still climbing toward 100%. If you’re building for AWS Lambda specifically, LLRT remains the safer, AWS-backed path to the same cold-start win. If you’re experimenting with edge functions or CLI tools and want to see what a 5ms cold start feels like in practice, Ant is worth an afternoon. I’ll be watching the 1.0 release before recommending it for anything client-facing.