v0.0.1-dev / pre-alpha

Clun is JavaScript tooling,
rewritten in pure Common Lisp.

A from-scratch JavaScript engine with TypeScript stripping, a package manager, test runner, HTTP server, and runtime APIs. Purity and a clearly scoped surface come before breadth or benchmark wins.

Linux + macOS 13+ / x64 + arm64

Install Clun

View shell script

curl -fsSL https://clun.sh/install | sh

The installer verifies the release checksum and writes to ~/.clun/bin.

Implementation: Pure Common Lisp
Curated test262 pass list: 22,643 tests
License: GPL-3.0-or-later
Cross-runtime speed: Not measured

One binary, a focused workflow

Run, install, test, and serve without a JavaScript implementation underneath.

Clun's runtime and tooling are implemented in Common Lisp. JavaScript and TypeScript appear as user programs and test fixtures, not as implementation code.

Read the scope contract

clun / quickstart pre-alpha

$ clun app.ts

hello from Common Lisp

$ clun test

(pass) adds two values

1 pass 0 fail 1 expect() call

$ clun run start

clun serving on http://127.0.0.1:3000

Measured, with the weak results included

Faster than Clun used to be.

These are Clun-versus-Clun measurements on fixed workloads, not comparisons with Bun or Node.js. Lower is better; each result is the best of five runs.

Phase 25 / milestone 2

Classic JavaScript workloads

Phase 24 baseline Milestone 2 result

Richardsscheduler simulation

3600.4 ms

2262.0 ms

1.59x

DeltaBlueconstraint solver

2942.0 ms

2182.0 ms

1.35x

Splayallocation + trees

1520.3 ms

901.2 ms

1.69x

5x goal not met at milestone 2. Gains ranged from 1.35x to 1.69x against Clun's own baseline.

Methodology and raw numbers

Four tools, one experimental toolkit

The daily loop is already here.

Each surface is real, tested, and intentionally narrower than Bun's equivalent.

01$ clun app.ts

JavaScript runtime

Execute JavaScript, CommonJS, ESM, JSON, and erasable TypeScript with a from-scratch engine.

Strict and sloppy language modes
ESM and CommonJS resolution
Timers, promises, files, fetch, and URL
No JSX, Proxy, Intl, or native addons

Scope ES2017-tier, partial

02$ clun install

Package manager

Resolve semver graphs into a deterministic hoisted tree with a content cache and lockfile.

SRI SHA-512 verification before extraction
Offline reinstall from clun.lock
Hardened tarball extraction
Lifecycle scripts are never executed

Known gap Public npm TLS interop

03$ clun test

Test runner

Discover JavaScript and TypeScript tests and run them with familiar Jest-style globals.

Hooks, skip, only, todo, and filters
Async tests and timeouts
About 22 built-in matchers
No snapshots, coverage, mocks, or concurrency

Output Deterministic by design

04$ clun server.ts

HTTP toolkit

Serve fetch-style handlers and make HTTP or experimental HTTPS requests from the runtime.

Clun.serve HTTP/1.1 server
Request, Response, and Headers
AbortController and timeout support
Buffered bodies; no WebSocket or HTTP/2

Security TLS is unaudited

A small, coherent surface

The APIs you need for the parts Clun implements.

The surface follows familiar web and JavaScript conventions while keeping unsupported behavior loud. Select a task to see code the current runtime accepts.

hello.ts

const project: string = "Clun";
const runtime = "Common Lisp";

console.log(`${project} runs on ${runtime}`);

const server = Clun.serve({
  port: 3000,
  fetch: async (request: Request) => {
    return Response.json({ ok: true });
  },
});

console.log(server.url);

test("math stays honest", () => {
  expect(2 + 2).toBe(4);
});

const file = Clun.file("message.txt");

Clun.write(file, "hello from Clun\n")
  .then(() => file.text())
  .then((text) => console.log(text));

Compatibility without the hand-waving

Clun is narrower. The table says where.

This is a capability snapshot, not a speed chart. Official Bun and Node.js sources are linked below; Clun cells reflect the repository's tested scope.

Capability	Clun 0.0.1-dev	Bun 1.3	Node.js 26
JavaScript runtimeLanguage execution	Partial ES2017-tier scoped engine	Yes broad JS + Web APIs	Yes broad JS + Node APIs
TypeScriptExecute without a separate build	Partial erasable syntax; no TSX	Yes TypeScript and JSX transpilation	Partial erasable syntax stripping
Package managerResolve and install npm packages	Blocked local fixture passes; public npm TLS fails	Built in `bun install`	Separate npm is distributed alongside Node
Test runnerFirst-party test command	Partial Jest-style core, no coverage	Built in Jest-compatible runner	Built in stable `node:test`
HTTP serverFirst-party server API	Partial HTTP/1.1, buffered bodies	Built in `Bun.serve`	Built in `node:http`
BundlerProduction asset bundling	No explicit non-goal	Built in browser and server targets	No use ecosystem tooling
Native addonsN-API / C or C++ modules	No conflicts with the purity contract	Partial Node-API compatibility	Yes stable Node-API
Cross-runtime benchmarkClun versus Bun or Node.js	Not measured no claim made	N/A no shared Clun run	N/A no shared Clun run

Sources: Clun scope, Bun documentation, and Node.js documentation.

The implementation is the point

Common Lisp all the way down.

Clun permits ANSI Common Lisp, SBCL contribs, and vendored libraries written in Common Lisp. It rejects CFFI and foreign-library entry points in the runtime implementation.

01
From-scratch engine
Lexer, parser, object model, modules, async execution, and runtime APIs live in the repository.
02
Vendored and pinned
A fresh source build fetches no Lisp dependencies and uses no Quicklisp installation.
03
Purity is checked
make purity scans source and vendored code at every phase gate.
04
Security limits stay visible
The pure-Lisp TLS stack is experimental, unaudited, and documented as such.

Try the current release

Install Clun with one shell command.