A predictable language for modern workflows.

v0.9.5 · MIT Licensed · Windows, macOS, Linux

Quokka is a self-hosted, deterministic programming language designed for clarity, safety, and modern AI workflows. Featuring a high-performance Bytecode VM, ahead-of-time Static Type Checking, native preemptive concurrency, and the ATSRS tiered storage AI engine.

Download for Windows

View on GitHub

Quickstart — Get running fast → Core features — Learn the design principles → Roadmap — Project milestones → Contributing — Join the community →

$ quokka --vm task.qka
Completed: Verify VM

Core Design Principles

Self-hosted by design.

Our complete compiler toolchain is written in Quokka, bootstrapped from a small C host and verified with SHA-256 AST hashes across stages.

// Re-bootstrap & verify correctness
$ quokka check-self
// Stage 1 == Stage 2 == Stage 3 AST hash

Bytecode VM.

High-speed stack-based bytecode virtual machine featuring call frames, chunk constants, opcode dispatch, and compiled execution.

// Compile to bytecode or run directly
$ quokka --vm app.qka
// Fast stack execution with zero overhead

Static type checking.

Ahead-of-time semantic analysis checks type signatures, struct schemas, function calls, and monadic expressions before runtime.

// Catch bugs before running code
$ quokka --check main.qka
// Type analysis: 0 errors detected.

Native concurrency.

Preemptive OS-level threads and typed message-passing channels with zero global interpreter locks or thread stalls.

let ch = chan(4)
spawn(fn() { send(ch, "done") })
let msg = recv(ch)

Structs & modules.

Custom record data structures with named fields and aliased multi-file imports for scalable software architecture.

struct Model { name, layers }
import "math.qka" as math
let m = Model("Llama-3", 32)

Predictable errors.

No nulls, no exceptions. Explicit Result (Ok/Err) and Option (Some/None) monads with automatic propagation via ?.

let config = fs.read("config.qka")?
match config {
    Ok(cfg) => println(cfg),
    Err(e)  => println("Error: " ++ e),
}

ATSRS AI engine.

Adaptive Tiered Storage for Resource-Starved training: stream QLoRA models larger than VRAM+RAM across T0 VRAM, T1 RAM, and T2 NVMe.

// Train large models on modest hardware
let pipe = joey.atsrs_pipeline()
pipe.train("llama-3-8b", 8192)

Zero-leak guarantee.

Every language feature and VM instruction is verified by our 100-way automated test suite and Valgrind clean (0 leaks, 0 errors).

$ python tests/test_100_ways.py
100/100 tests passed (0.82s)
Valgrind: 0 errors in 0 blocks

Verifiable builds.

Quokka boots from a small C host (src/bootstrap, roughly 2,150 lines: a lexer, parser, and tree-walking interpreter) just once — Stage 0. Stage 0's only job is to run the canonical Quokka interpreter, which is itself written entirely in Quokka. From there, Quokka compiles Quokka.

Run quokka check-self and it re-bootstraps the interpreter through multiple stages, then compares cryptographic hashes of the AST and the output at each stage. If they match, self-hosting isn't a claim on this page — it's a number you can verify on your own machine.

Illustrative output — run `quokka check-self` yourself to see your machine's actual hashes.

Joey: ML integration without the bloat.

Joey is a standard library extension for AI and deep learning. It powers QLoRA fine-tuning and features ATSRS (Adaptive Tiered Storage for Resource-Starved training) to train models larger than physical VRAM and RAM across T0 VRAM, T1 pinned RAM, and T2 NVMe SSD storage.

import joey

let mut pipeline = joey.pipeline()
pipeline.load_model("meta-llama/Llama-3-8B", "4bit")
pipeline.train("quokka_dataset", 512)

let result = pipeline.run()

match result {
    Ok(status) => println("Training complete! " ++ status),
    Err(e)     => println("Training failed: " ++ e),
}

Quokka code

JSON IPC manifest

Python + Unsloth process

Result back to Quokka

Joey's process-isolation architecture: Quokka code writes a JSON manifest, spawns an isolated Python and Unsloth process for training, and reads the result back.

Project Roadmap

completed

Core Language & Toolchain

C bootstrap host (Stage 0)
Self-hosted compiler & evaluator in Quokka (Stage 1)
Cryptographic verifier (`quokka check-self`)
Bytecode VM with call frames & opcodes (`--vm`)
Static Type Checker ahead-of-time (`--check`)
Native Concurrency (preemptive threads & channels)
User-defined structs & aliased module imports
Result / Option monads, match & `?` operator
ATSRS 3-Tier Storage (VRAM / RAM / NVMe QLoRA)
TCP sockets & dynamic foreign function interface (FFI)
100-way automated test suite with Valgrind 0-leak proof
Windows (x64), Linux (x86_64), macOS (arm64 / x86_64) builds

in progress

Native Execution & Systems

Native Joey C/CUDA runtime engine (zero Python hop)
Expanded standard library (JSON, HTTP, Async I/O)
Interactive REPL with syntax coloring

planned

Advanced Ecosystem

JIT compiler tier for bytecode
Distributed ATSRS cluster training
WebAssembly (Wasm) compilation target

Quokka v0.9.5 brings high-performance bytecode compilation, static type checking, native preemptive concurrency, ATSRS tiered storage for training large AI models, and complete cross-platform support. Quokka was built solo, from a small C bootstrap host up through a fully self-hosted compiler written in the language itself. It's open source under the MIT License — read the source, run the 100-way verifier yourself, and see exactly how it works.

If you'd like to contribute, start with the Contributing Guide.

Get started

Download

Download the Quokka standalone zip archive.