# Quokka

> A deterministic, strictly self-hosted programming language built for modern AI workflows, featuring Result/Option error handling and LoRA fine-tuning via the Joey ML extension.

Quokka is an open-source programming language released under the MIT License at v0.1.0, built by a solo developer and hosted on GitHub under the Akshraj2022 account. It is designed around verifiable self-hosting and deterministic semantics, with a current Windows-only installer and a VS Code syntax-highlighting extension included out of the box. The project was created and first published in September 2026.

## What It Is

Quokka is an expression-oriented, strictly self-hosted programming language whose core design goal is provable correctness: the canonical lexer, parser, AST, and evaluator are all written in Quokka itself, bootstrapped from a minimal C host of roughly 2,150 lines. It targets developers who want predictable, exception-free code with explicit error handling, and who need a clean boundary between a pure language core and heavy ML workloads.

## Core Language Design

Quokka's design centers on three principles that distinguish it from mainstream scripting languages:

- **No exceptions** — errors are returned as values using `Result` (`Ok`/`Err`) and `Option` types, combined with `match` expressions and the `?` postfix operator for ergonomic propagation.
- **Immutable by default** — variables declared with `let` are immutable; mutation requires explicit `let mut`, and shadowing requires the `shadow` keyword.
- **Deterministic semantics** — the language avoids hidden control flow, making program behavior traceable and auditable.

## Verifiable Self-Hosting Architecture

The self-hosting model is a central technical claim of the project. A small C bootstrap host (Stage 0) runs the canonical Quokka interpreter, which is itself written in Quokka. Running `quokka check-self` re-bootstraps the interpreter through multiple stages and compares cryptographic hashes of the AST and output at each stage. If the hashes match, self-hosting is verified on the user's own machine rather than taken on faith from the project page.

## Joey: ML Integration via Process Isolation

Joey is a standard library extension that lets Quokka orchestrate Python/PyTorch/Unsloth workflows — including Llama-3 QLoRA fine-tuning — without embedding Python in the language core. The architecture works through a strictly typed JSON IPC boundary: Quokka code writes a configuration manifest, spawns an isolated Python and Unsloth process for training (with CUDA acceleration), and reads the result back as a typed `Result` value. AMD/ROCm support is listed as untested. A fully native Joey runtime that removes the Python process hop for supported operations is listed as in progress on the project roadmap.

## Update: v0.1.0 Launch

The project published its first release, v0.1.0 (tagged `v0.1.0-updated`), on September 18, 2026. The completed milestone set includes the C bootstrap host, the self-hosted lexer/parser/AST/evaluator, the `quokka check-self` verifier, Result/Option error handling, immutable-by-default bindings, the Joey ML extension with CUDA support, a Windows installer, and VS Code syntax highlighting. Active development targets a native Joey runtime, an expanded standard library, AMD/ROCm support, and macOS and Linux builds.

## Setup Path

Installation on Windows is a single-step process: download `Quokka-Setup.exe` from the GitHub Releases page, run the installer, and it automatically configures PATH, registers the `.qka` file extension, and installs the VS Code extension. Scripts are run with `quokka run hello.qk` from any terminal. Building from source requires GCC to compile the C bootstrap, after which `quokka bootstrap` re-bootstraps the canonical interpreter.

## Features
- Strictly self-hosted compiler written in Quokka itself
- Deterministic semantics with no hidden exceptions
- Result and Option error handling with match and ? operator
- Immutable-by-default variable bindings (let / let mut / shadow)
- quokka check-self cryptographic verifier for self-hosting
- Joey ML extension for Python/PyTorch/Unsloth IPC workflows
- LoRA fine-tuning via Unsloth with CUDA acceleration
- Windows installer with automatic PATH and file association setup
- VS Code syntax highlighting extension
- C bootstrap host (~2,150 lines) for Stage 0 bootstrapping
- JSON IPC boundary isolating ML workloads from language core
- CLI runner (quokka run)

## Integrations
Python, PyTorch, Unsloth, VS Code, CUDA, Llama-3 (via Joey)

## Platforms
WINDOWS, MACOS, LINUX, API, VSC_EXTENSION, CLI

## Pricing
Open Source

## Version
v0.1.0

## Links
- Website: https://quokka.space
- Documentation: https://quokka.space/docs.html
- Repository: https://github.com/Akshraj2022/quokka
- EveryDev.ai: https://www.everydev.ai/tools/quokka-language