Ant JS Runtime: 8MB Binary, Custom Engine, 5ms Cold Start

What Is Ant and Why Does It Matter?

On July 12, 2026, a Show HN post for Ant hit 252 points and 107 comments within 12 hours. The pitch: a JavaScript runtime with its own engine — not wrapping V8, JavaScriptCore, or SpiderMonkey — shipping as a single 8.6MB binary that cold-starts in 5 milliseconds. For context, Node 26 is 120MB. Bun is 60MB. Deno is 90MB.

Built by solo developer Mack (theMackabu), Ant started as an experiment in January 2026 — "building a JavaScript runtime in one month" — and has since grown to 1,759 commits on GitHub with 861 stars. The engine, called Ant Silver, is written primarily in C (74% of the codebase). It includes a custom bytecode compiler, a MIR-based JIT backend, NaN-boxed value representation, and a generational garbage collector.

What makes Ant genuinely interesting is not the benchmark numbers alone — it's the architectural bet that a purpose-built engine can compete with decades of V8 optimization by being smaller, simpler, and more focused on server-side workloads. This matters for serverless computing, edge deployments, embedded systems, and any context where binary size and cold start time are hard constraints.

The Ant Silver Engine: Architecture Deep Dive

Ant Silver is not a wrapper. It is a complete JavaScript engine implemented in C from scratch. Here is how it differs from the established engines:

• Custom bytecode compiler — JavaScript source is compiled to Ant's own bytecode format, not V8 Ignition bytecode. The compiler targets fast compilation over deep optimization, which contributes to the sub-5ms cold start.
• MIR JIT backend — Ant uses MIR (Medium Internal Representation) as its JIT compiler framework. MIR is a portable, open-source JIT infrastructure that generates optimized machine code. The JIT kicks in for hot paths like any modern runtime.
• NaN-boxed values — All JavaScript values (numbers, strings, objects, booleans, undefined, null) are encoded in 64-bit NaN-boxed representations. This is the same technique V8 uses for its 64-bit platforms, avoiding heap allocations for small integers and allowing pointer tagging.
• Generational GC — Ant uses a generational garbage collector with a young generation (fast nursery) and old generation (mark-sweep). The GC is designed for server workloads with short-lived objects and moderate heap sizes.
• Written in C — The entire engine is C (not C++, not Rust). This keeps the binary lean and avoids runtime dependencies. The build system is Meson.

According to the project's architecture documentation, Ant Silver is designed for "predictable performance at small scales" — favoring fast startup and modest memory usage over peak throughput on multi-hour server processes. This is a deliberate trade-off that makes sense for serverless and edge use cases.

Compatibility and Standard Compliance

Ant passes 100% of the compat-table suite — 1,511 out of 1,511 tests spanning ES1 through ESNext. It is also WinterTC conformant, meaning it meets the Ecma TC55 Minimum Common API specification for server-side JavaScript. The full test262 conformance is approximately 64%, which covers everyday JavaScript but may miss edge cases in advanced language features like Temporal or RegExp Unicode property escapes.

Binary Size and Cold Start Benchmarks

The numbers published by the Ant project compare importing Hono, registering two routes, and exiting — no HTTP server is started, isolating module resolution and initialization overhead:

The cold start advantage is felt immediately when running scripts. Ant is 6x faster cold-starting than Node for this workload. The binary size difference is also dramatic — Ant at 8.6MB fits on a floppy disk (yes, literally), while Node at 120MB is 14x larger. For Docker images, CI pipelines, and serverless deployments, that size delta translates directly to faster pulls and lower storage costs.

However, the benchmark intentionally avoids measuring long-running process performance. On sustained workloads with hot JIT compilation, V8's deeply optimized pipeline will outperform Ant's lighter JIT. The numbers are most relevant for short-lived processes like serverless function invocations.

Installation and First Steps

Installing Ant is a one-liner — no package manager, no Homebrew tap, no npm install:

curl -fsSL https://antjs.org/install | bash

The script detects your OS (macOS or Linux on arm64/x86_64) and drops a single binary into place. Verify it worked:

$ ant --version
Ant 12.1.15dd25d.1

No native Windows support yet (WSL works), but macOS and Linux are fully supported.

Running JavaScript and TypeScript

Ant runs plain JavaScript and TypeScript with no configuration. Here is a simple HTTP server using the standard fetch-based model:

// server.js
const handler = (req) => {
  const url = new URL(req.url);
  const name = url.searchParams.get('name') || 'World';
  return new Response(`Hello, ${name}! — from Ant`);
};

export default {
  port: 3000,
  fetch: handler
};

$ ant server.js
Listening on http://localhost:3000

$ curl http://localhost:3000/?name=Felix
Hello, Felix! — from Ant

TypeScript works natively — no tsconfig.json, no bundler, no dist folder:

// server.ts
import { Hono } from 'hono';

const app = new Hono();

app.get('/', (c) => c.text('Hello from Ant with TypeScript!'));

export default app;

$ ant server.ts
Listening on http://localhost:3000

Ant handles module resolution, type stripping, and compilation transparently. The type stripping uses a custom fast path that saves approximately 900KB of binary size compared to using the full TypeScript compiler.

Package Management: 40x Faster Than npm

Ant installs packages through its own registry at ants.land, which speaks the npm protocol. Any package you publish there also works with npm, yarn, pnpm, and bun.

$ ant i hono
installed  hono@latest
1 package installed  [155ms]

155 milliseconds from zero to a working Hono installation. The same operation in npm takes approximately 6 seconds on the same machine. Ant claims up to 40x faster package installs, and for small-to-medium dependency trees, the difference is genuinely noticeable.

Publishing packages works similarly:

$ ant land login
$ ant land publish
published  @you/[email protected]

Building a REST API with Hono

Hono works out of the box with Ant. Here is a REST-style API with CORS, route params, and POST body parsing:

import { Hono } from 'hono';
import { cors } from 'hono/cors';

const app = new Hono();

app.use('*', cors());

const todos = [
  { id: 1, title: 'Try Ant', done: true },
  { id: 2, title: 'Write a tutorial', done: true },
  { id: 3, title: 'Deploy something', done: false },
];

app.get('/api/todos', (c) => c.json(todos));

app.get('/api/todos/:id', (c) => {
  const todo = todos.find(t => t.id === Number(c.req.param('id')));
  return todo
    ? c.json(todo)
    : c.json({ error: 'Not found' }, 404);
});

app.post('/api/todos', async (c) => {
  const body = await c.req.json();
  const newTodo = { id: todos.length + 1, ...body };
  todos.push(newTodo);
  return c.json(newTodo, 201);
});

export default app;

$ ant todos.ts
Listening on http://localhost:3000

No adapter layer, no configuration file — just write Hono code and run it. Ant's default fetch export model means any framework that uses the standard fetch-based server pattern works without modifications.

VM-Isolated Sandbox: A Unique Security Feature

Neither Node.js nor Bun ships a built-in sandbox for running untrusted code. Ant does — and it is hardware-isolated using KVM (Linux) or Hypervisor.framework (macOS):

import { Sandbox } from 'ant:sandbox';

const box = new Sandbox({
  mount: '.:/workspace',  // read-only mount by default
});

await box.run('untrusted.js');
await box.close();

Sandbox security properties include:

• Hardware isolation — Each sandbox runs as its own lightweight VM. This is process-level isolation (Linux namespaces + KVM), not just JavaScript sandboxing.
• Read-only mounts — The filesystem is immutable unless you explicitly grant write access.
• No network by default — Deny-all outbound network. Only ports you explicitly forward are open.

This is meaningful for serverless platforms, code evaluation tools, plugin systems, and any workload where third-party code runs alongside your own. It provides defense-in-depth beyond npm audit or permission prompts.

Comparison: Ant vs Node vs Bun vs Deno

The JavaScript runtime landscape in 2026 is more diverse than ever. Here is how the four runtimes compare across dimensions that matter for production decisions:

Current Limitations and Maturity Assessment

Ant is an impressive technical achievement, but it is early-stage software. Here are the limitations to be aware of:

• test262 conformance at ~64% — While everyday JavaScript works well, edge cases in advanced language features like Temporal, regular expression Unicode property escapes, and tail call optimization may not behave correctly.
• No debugger or profiler — You are working with console.log for debugging. There is no Chrome DevTools protocol support, no heap profiler, no performance flamegraph. For production debugging, this is a significant gap.
• Partial N-API support — Complex native addons that rely on N-API may not work. If your project depends on native modules like sharp, bcrypt, or node-canvas, check compatibility first.
• Windows via WSL only — No native Windows binary. If your team develops on Windows, you need WSL2.
• Small community — One primary maintainer and 4 contributors. The project's bus factor is 1. Compare this to Node.js (OpenJS Foundation, thousands of contributors).

The limitations are characteristic of a solo-developed runtime that is 6 months old. They do not invalidate the project — but they should inform where and how you evaluate it.

Where Ant Shines: Use Cases

Based on the architecture and current state, Ant is best suited for:

• Serverless functions — The 5ms cold start and 8.6MB binary make Ant ideal for AWS Lambda, Cloudflare Workers, or similar FaaS platforms where cold start time directly impacts user experience.
• Edge computing — Deploying to edge locations with limited storage and startup budget benefits from Ant's minimal footprint.
• Embedded systems — IoT devices, Raspberry Pi, and resource-constrained environments where 120MB of Node is impractical.
• CI/CD pipelines — Faster installs (40x) and smaller Docker images mean faster CI builds.
• CLI tools — Distributing a CLI tool written in JavaScript with a bundled Ant binary keeps the download tiny.
• Side projects and experimentation — Ant's simplicity makes it fun to use for personal projects where Node's complexity is overkill.

For context on how the runtime landscape is evolving, see my analysis of the Bun Rust rewrite, which covers a different approach to runtime optimization — porting an existing engine from Zig to Rust for better memory safety rather than building a new engine from scratch.

How to Get Started

If you want to try Ant today:

1. Install: curl -fsSL https://antjs.org/install | bash
2. Create a file: echo 'console.log("hello from ant")' > test.js
3. Run it: ant test.js
4. Install a framework: ant i hono
5. Build a server: use the Hono example above

The official site at antjs.org has documentation, and the GitHub repository has the source code, examples, and benchmark scripts. The author's blog at themackabu.dev documents the project's development from the initial one-month sprint to the current ecosystem vision.

FAQ

Need Expert Web Development?

The JavaScript runtime landscape is expanding faster than ever — from Ant's custom engine to the AI-assisted Bun Rust rewrite, the tools available for web development continue to diversify. Choosing the right runtime for your project requires understanding the trade-offs between performance, ecosystem maturity, and operational constraints.

I'm a full-stack web developer with 20+ years of experience building production applications. Whether you're evaluating Ant for a serverless project, migrating an existing codebase, or need advice on the modern JavaScript ecosystem, I'm happy to help. Reach out to me for a free initial consultation.

I also write in-depth technical articles on the tools and frameworks that matter — follow my articles for the latest in web development.