zlow
The blazing fast polyglot toolkit
Compilers and transpilers you can run from one binary
4.8×
faster than esbuild
296×
faster than Gradle
20.5×
faster than CPython
16.3×
faster than rustc
6.7×
faster than
go
npm install @zlow/cliExplore a sample
Open the source, the config zlow reads, and the command that builds it.
is the integration. zlow build reads outDir and include, then writes JavaScript there.
export function add(a: number, b: number): number {
return a + b;
}{
"compilerOptions": {
"outDir": "dist",
"sourceMap": true
},
"include": ["src"]
}$ zlow build src/ --out-dir dist/is the integration. The entry is , and is compiled with it.
fun entry(): Double {
return add(1.0, 2.0)
}fun add(a: Double, b: Double): Double {
return a + b
}{
"language": "kotlin",
"entry": "src/main.kt"
}$ zlow native .is the integration. The entry is , and is compiled with it.
def entry() -> float:
return helper() + 1.0def helper() -> float:
return 2.0{
"language": "python",
"entry": "src/main.py"
}$ zlow native .is the integration. The entry is , and is compiled with it.
package main
func entry() float64 {
return add(1.0, 2.0)
}package main
func add(a float64, b float64) float64 {
return a + b
}{
"language": "go",
"entry": "main.go"
}$ zlow native .is the integration. The entry is , and is compiled with it.
fn entry() -> f64 {
helper(1.0, 2.0)
}fn helper(a: f64, b: f64) -> f64 {
a + b
}{
"language": "rust",
"entry": "main.rs"
}$ zlow native .is the integration. The entry is , and is compiled with it.
double entry() {
return step(1.0);
}double step(double x) {
return x + 1.0;
}{
"language": "cpp",
"entry": "main.cpp"
}$ zlow native . --emit-llvm kernel.llLightning fast
Same TypeScript. Less waiting.
Same kernel. Minutes become milliseconds.
Same kernel. The interpreter walks the loop; the binary just runs it.
Same kernel. The gc binary walks the call chain; the LLVM binary just runs it.
Same kernel. The rustc binary walks the branches; the LLVM binary just runs them.
Same kernel. Both sides are -O2 binaries; only entry() is timed.
Fully featured
A faster TypeScript toolchain. Transpile, check, bundle, and ship from one binary.
Compile the hot path to native. Keep writing Kotlin.
Compile the hot path to native. Keep writing Python.
Compile the hot path to native. Keep writing Go.
Compile the hot path to native. Keep writing Rust.
Compile the hot path to LLVM. Keep writing C++.
Instant builds
Turn TypeScript into JavaScript in milliseconds, not seconds.
Type checking
Catch mistakes without slowing emit. Check when you want, skip when you do not.
Bundling
Fold a module graph into one file you can ship.
Tree shaking
Drop unused code so the output stays small.
Declarations
Publish a .d.ts for your package from the same tool.
Watch mode
Rebuild a directory as you save. Linux only for now; elsewhere --watch exits with a clear error.
Source maps
Debug the TypeScript you wrote, not the JavaScript we emitted.
Your tsconfig
Directory builds read tsconfig.json: include, outDir, rootDir, extends. No project references.
JSX
Leave JSX as JSX. No surprise rewrite in the middle of your stack.
Embeddable API
transformSync strips types in-process on Linux and macOS. Emit only; no check API yet.
Native binaries
Compile a kernel to something you can run. No JVM in the way.
Skip Gradle
One command. No daemon, no kotlinc warmup.
Tiny output
Kilobytes, not hundreds of kilobytes, for the same kernel.
Fast compiles
The wait is milliseconds, not half a minute.
Familiar Kotlin
fun, val, if, while, the numeric Kotlin you already write.
Simple setup
A small zlow.json is the whole project file.
Same-project calls
Functions see each other across files. No import maze.
No JVM tax
Source goes straight to native. No .class files in between.
One project
Every .kt file compiles together. Point zlow at the folder and go.
Clear errors
Unsupported code fails by name. You always know why.
Matches Kotlin/Native
Accepted kernels compute the same result as the compiler you already trust.
Built for the hot path
Keep the app in Kotlin. Compile the numeric core.
Native binaries
Your numeric core becomes a binary. No interpreter at runtime.
Skip the interpreter
32.3 ms versus 661 ms on the same kernel. No CPython at runtime.
Familiar Python
def, if, while, floats and bools, write it like Python.
Simple setup
A zlow.json and one command — that’s the whole setup.
Matches CPython
Accepted kernels match the interpreter you already trust.
Clear errors
Out of scope fails loudly. You never ship a binary that almost works.
Built for the hot path
Compile the numeric core. Keep the rest of the app in Python.
Same-project calls
Functions in the project can call each other. No import maze.
One project
Every .py file compiles together. Point zlow at the folder and go.
Fast to try
Install the CLI, add a project file, and run zlow native .
No surprise runtime
We do not pretend print, imports, or the stdlib work.
Honest by default
Nothing is written unless we can honour it.
Native binaries
Your numeric core becomes a binary. No go run at runtime.
Skip go build
One command. No go.mod, no module cache, no go build.
Tiny output
A small native binary; no binary-size comparison is measured yet.
Fast compiles
119 ms to compile the dense corpus (zlow frontend, 32 files, 2 MB).
Familiar Go
func, var, if, for, arithmetic — the numeric Go you already write.
Simple setup
A zlow.json and one command — that’s the whole setup.
Same-project calls
Functions in the project can call each other. No import maze.
No runtime tax
Source goes straight to native. No go run in between.
One project
Every .go file compiles together. Point zlow at the folder and go.
Clear errors
Out of scope fails loudly. You never ship a binary that almost works.
Matches go
Accepted kernels match the gc compiler you already trust.
Built for the hot path
Compile the numeric core to a shared library the rest of the app can load.
Native binaries
Your numeric core becomes a binary. No interpreter at runtime.
Skip Cargo
One command. No Cargo.toml, no crate graph, no cargo build.
Tiny output
A small native binary; no binary-size comparison is measured yet.
Fast compiles
142 ms to compile the dense corpus (zlow frontend, 32 files, 2 MB).
Familiar Rust
fn, let, if, while, loop, arithmetic — the numeric Rust you already write.
Simple setup
A zlow.json and one command — that’s the whole setup.
Same-project calls
Functions in the project can call each other. No use/mod maze.
No rustc on the path
Source goes straight to native. No rustc as a driver in between.
One project
Every .rs file compiles together. Point zlow at the folder and go.
Clear errors
Out of scope fails loudly. You never ship a binary that almost works.
Matches rustc
Accepted kernels match the compiler you already trust.
Built for the hot path
Compile the numeric core to a shared library the rest of the app can load.
Native binaries
The bench links LLVM text with zig cc. zlow native -o is refused in kernel-v0.
Skip CMake
One command. No CMakeLists.txt, no Makefile, no compile_commands.json.
Tiny output
A small native binary; no binary-size comparison is measured yet.
Matches Clang
6.4 ms vs 6.4 ms on the branchy kernel. Five kernels sit at parity with clang++ -O2.
Familiar C++
double, bool, if, while, arithmetic — the numeric C++ you already write.
Simple setup
A zlow.json and one command — that’s the whole setup.
Same-project calls
Functions in the project can call each other. No headers, no #include.
No clang++ on the path
Source goes straight to LLVM. No clang++ as a driver in between.
One project
Every .cpp file compiles together. Point zlow at the folder and go.
Clear errors
Out of scope fails loudly. You never ship a binary that almost works.
Checked against Clang
Accepted kernels match the compiler you already trust.
Built for the hot path
Pass --emit-llvm to write the kernel. A shared library is a later step; kernel-v0 refuses it.
Packages too
The same binary installs dependencies for TypeScript, Kotlin, and Go. Exact versions, a lock file, and a checksum on everything it keeps.