Built for serverless
Fast cold starts, roughly 5 MB RSS on Apple silicon, and one binary. No npm install for the core.
fairyfly
The serverless-first JavaScript runtime for the backend.
Built for cold starts, tight memory, and short-lived handlers. One binary with HTTP, TLS, HTTP/2, WebSocket, fetch, SQLite, Postgres, workers, and FFI.
Install
curl -fsSL https://www.fairyfly.dev/install.sh | sh165kreq/sec
~10 mscold start
2.9 msp50
1binary
One binary, batteries included
HTTP, TLS, HTTP/2, WebSocket, fetch, SQLite, Postgres, workers, crypto, and FFI ship in the same binary.
Small enough to audit
About 24k lines of Zig across 54 files. The whole runtime fits in your head.
ESM without the baggage
Pure-JS ESM packages via ff imprint, one flat node_modules, and a lockfile with integrity hashes.
Predictable limits
Every hard cap is documented — connections, bodies, timers, workers, and fetch slots.
Deploy anywhere
Prebuilt binaries, containers, and bytecode for serverless, edge, and long-lived deployments.
Serverless first
Built for the shape of serverless.
Fairyfly is designed first for short-lived, memory-constrained workloads: fast cold starts, one binary, no npm install for the core, and a process that exits when the event loop drains.
- Start fast: one binary with no runtime dependency tree.
- Stay small: roughly 5 MB RSS for a hello-world server on Apple silicon.
- Exit cleanly: no referenced work means the process stops.
const port = Number(process.env.PORT ?? 3000);
http.serve({ port }, (url) => {
if (url === "/health") return Response.json({ ok: true });
return new Response("hello from fairyfly");
});Fairyfly is a native POSIX binary: it fits container-based serverless platforms and edge VMs, not V8-isolate runtimes such as Cloudflare Workers.
Quick start
Serve, call, and store — with zero setup.
No package.json, no node_modules, no build step for the core. The server, client, and database are already in the binary.
- Start an HTTP server with
http.serve. - Call any API with the built-in
fetch. - Persist data with embedded SQLite through
Database.open.
http.serve({ port: 3000 }, (url, method, body) => {
if (url === "/json") return Response.json({ ok: true });
if (url === "/echo" && method === "POST") return new Response(body);
return new Response("not found", { status: 404 });
});Batteries included
Everything you need is already in the binary.
HTTP, WebSocket, fetch, SQLite, Postgres, workers, crypto, and FFI. No dependency tree to install or audit.
HTTP server
HTTP/1.1, TLS, HTTP/2, and automatic WebSocket upgrades.
fetch
16 concurrent HTTP/1.1 slots, redirects, proxies, and a 30 s timeout.
WebSocket
Server upgrades and a client with text and binary frames.
SQLite
Embedded, synchronous Database.open() with transactions.
Postgres
Tagged-template sql queries and a 10-connection pool.
Workers
Up to 8 OS threads with structured-clone messaging.
Crypto
UUIDs, random values, SHA digests, and base64 helpers.
FFI
Call C-ABI shared libraries with --allow-ffi.
Performance
MicroVM benchmark: 10ms cold start, 165k RPS.
Four runtimes benchmarked inside isolated microVMs (2 vCPUs, 1 GB RAM): Phase 1 isolated cold-start telemetry vs. Phase 2 5,000,000 requests across 500 concurrency via oha.
165kwarm req / second
~10 msapp cold start
2.93 msp50 latency
5.01 msp99 latency
| Runtime | App Cold Start | Warm RPS | p50 | p99 | Slowest |
|---|---|---|---|---|---|
| Fairyfly | 10.4 ms | 164,967 /s | 2.93 ms | 5.01 ms | 25.5 ms |
| Bun | 80.6 ms | 163,610 /s | 2.94 ms | 5.29 ms | 21.8 ms |
| Deno | 79.4 ms | 163,566 /s | 2.93 ms | 5.27 ms | 117.2 ms |
| Node | 118.6 ms | 15,523 /s | 32.33 ms | 34.17 ms | 7,983 ms |
2 vCPU / 1 GB RAM microVMs · 5M requests @ 500 concurrency via oha (100% success rate across all 5M requests) · Full microVM benchmark & telemetry →
Architecture
Small enough to read. Fast enough to ship.
About 24k lines of Zig across 54 files. One event loop, no hidden request threads, and a hot path designed for the common case.
- 512-slot SoA connection table with packed 2-byte flags.
- 64 KB static response staging per slot, spilling to the heap at 10 MB.
- libxev event loop: io_uring on Linux, kqueue on macOS, epoll fallback.
JavaScript source
↓
QuickJS parser + bytecode
↓
Zig API layer
↓
libxev · io_uring / epoll / kqueue
CLI
One binary for the whole workflow.
Scaffold, run, test, and ship with the same ff binary. No separate task runner or build tool.
ff init
Write ff.json and an entry file in one command.
ff init -y my-app
ff start
Run the project's main, with optional TLS cert and key.
ff start
ff test
Run test/*.test.js through the runtime.
ff test
ff compile
Ship bytecode with source and debug info stripped.
ff compile app.js -o app.ffbc
Deploy
Ship it anywhere.
Ship a prebuilt binary, a container, or bytecode with the source stripped.
Prebuilt binary
macOS and Linux, installed to ~/.local/bin/ff with a SHA-256 check.
curl -fsSL https://www.fairyfly.dev/install.sh | sh
Docker
A container image with the runtime and tools ready to run.
docker run --rm ghcr.io/abdelmajidouhamane/ff:latest ff --version
Bytecode
Compile to .ffbc with source and debug info stripped.
ff compile app.js -o app.ffbc
ES modules
Install packages without the baggage.
ff imprint installs pure-JS ESM packages, writes a lockfile with integrity hashes, and keeps one flat node_modules.
- No CommonJS, require(), or node: imports.
- One flat node_modules — conflicting versions fail loudly.
- Direct GitHub, Codeberg, and tarball sources with integrity pins.
ff imprint marked@18.0.11
# adds marked to ff.json and ff.lock
# materializes node_modules/Get started
Start with one binary. Stay small.
Install Fairyfly, run a server, and measure the memory yourself.
Install
curl -fsSL https://www.fairyfly.dev/install.sh | sh