A predictable language for modern workflows.

v0.1.0 · MIT Licensed · Windows

Quokka is a strictly self-hosted programming language designed for clarity and reliability. It features deterministic programming language design, Result and Option error handling, and seamless LoRA fine-tuning via Unsloth out of the box.

Download for Windows View on GitHub

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

$ quokka run hello.qka
Hello, World!

Core Design Principles

Self-hosted by design.

Our entire toolchain is built in Quokka. We use a multi-stage bootstrap process to cryptographically verify correctness.

// The Quokka compiler is written in Quokka.
// Run our built-in check to verify the build.
$ quokka check-self

Predictable errors.

We do not use hidden control flow for exceptions. Handle failures explicitly with Result and Option types.

let config = fs.read("settings.qka")?

// Errors are returned as values.
// No unexpected exceptions thrown at runtime.

Explicit mutability.

Variables are immutable by default. State changes require explicit opt-in, making your code easier to trace.

let version = "1.0"      // immutable by default
let mut retries = 0      // explicitly mutable

retries = retries + 1

Simple toolchain.

Our installer automatically configures your PATH, file associations, and editor setup in one step.

$ Quokka-Setup.exe
Installing Quokka v0.1.0...
Configuring PATH...                done
Registering .qka file extension... done
Installing VS Code extension...     done

Quokka is ready. Open a new terminal and run: quokka

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 that interfaces cleanly with Python and PyTorch via a strictly typed JSON IPC boundary, keeping the core language minimal.

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.

Today: Joey orchestrates fine-tuning through this Python/Unsloth bridge, including CUDA-accelerated training. AMD/ROCm is untested. A fully native Joey runtime — removing the Python process entirely for supported operations — is in progress; see the Roadmap below.

Project Roadmap

completed

Core language and compiler

C bootstrap host (Stage 0)
Self-hosted lexer, parser, AST, and evaluator, written in Quokka
`quokka check-self` verifier
Result / Option error handling, `match`, and the `?` operator
Immutable-by-default bindings (`let` / `let mut` / `shadow`)
Joey ML extension via Python/Unsloth IPC, with CUDA support
Windows installer and VS Code syntax highlighting

in progress

Native execution

Native Joey runtime, removing the Python process hop for supported operations
Expanded standard library

planned

Broader reach

AMD / ROCm support
macOS and Linux builds

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 starting at v0.1.0 — read the source, run the verifier yourself, and see exactly how it works.

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

Get started

Download

Grab Quokka-Setup.exe from the Releases page.

Install

Run the installer. It configures your PATH, file associations, and VS Code extension automatically.

Run

quokka run hello.qk

Read the docs · Language grammar · Self-hosting explained · Joey specification