zlow
zlow;
The blazing fast polyglot toolkit
Compilers and transpilers for the agentic era
Lightning fast
Same TypeScript. Less waiting.
Same kernel. Minutes become milliseconds.
Same kernel. The interpreter walks the loop; the binary just runs it.
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.
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 as you save, without restarting the toolchain.
Source maps
Debug the TypeScript you wrote, not the JavaScript we emitted.
Your tsconfig
Uses the project file you already have. No second config language.
Modern TypeScript
Current syntax works as written, satisfies, using, decorators, and friends.
JSX
Leave JSX as JSX. No surprise rewrite in the middle of your stack.
Embeddable API
Call the compiler from Node without spawning a process.
Honest errors
If we cannot do it, you get a clear error, never a silent miss.
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
21.7 ms versus 266 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 is 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, add a project file, 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.