About the project · Open source · MIT licensed
Chuchu is a statically typed language with automatic type inference. Cheeku is the Rust compiler that turns it into native programs through LLVM. Both are young, both are open source, and this page is honest about what exists today — and what does not.
01 · TWO THINGS, TWO NAMES
The names are easy to mix up, so it is worth being precise: one is the thing you write, the other is the thing that turns it into a binary.
THE LANGUAGE
A high-performance, statically typed language with inferred local types, explicit function signatures and checked numerical operations. It reads like plain sentences and compiles to native code.
assign greeting to 42
show greetingTHE COMPILER
The command-line compiler, distributed as the Rust crate chuchu. It type-checks first, then lowers through LLVM, optimises, and links a native executable with the system Clang.
02 · DESIGN PRINCIPLES
Everything else in Chuchu follows from these. When a feature is ambiguous, they are the tie-breaker.
READABILITY
declare is assign, update is reassign, print is show. A program says what it does, so the reader never has to translate it first.
INFERENCE
Local variables take their type from the value you assign. Only function parameters and return types are annotated, where the contract actually matters.
SAFETY
Static type checking rejects mismatches before a single instruction is generated, and runtime guards stop overflow, division by zero and out-of-range indexes.
NATIVE OUTPUT
Cheeku lowers to LLVM and links a host-native executable. Pick O0 through O3 and change the speed, never the behaviour.
03 · HOW CHEEKU WORKS
One compiler, one pipeline. Each stage hands a checked result to the next, and nothing reaches the LLVM backend that has not already passed the type checker.
The source becomes tokens — keywords, literals, symbols, newlines — each carrying the byte span it came from.
Tokens become an abstract syntax tree with precedence-based expressions, blocks, calls and indexing.
A symbol table tracks lexical name lookup and scope, so shadowing and forward references resolve the way they read.
The type checker infers local types, validates signatures, conditions, arrays, scope and returns, and collects function signatures before any body is checked.
Validated statements are lowered into an LLVM module: i64 integers, f64 floats, i1 booleans and fixed-size numeric arrays.
The target triple and data layout are configured, then LLVM's O1 to O3 pass pipelines run. O0 skips the optional passes.
A native object is emitted and handed to the system Clang linker. The executable is staged beside the destination and renamed only after linking succeeds.
.chuchu source
↓ lexer
tokens with byte spans
↓ parser
abstract syntax tree
↓ type checker + symbol table
validated program
↓ typed code generation
LLVM module
↓ target configuration + optimisation
host-native object
↓ Clang linker
executable04 · UNDER THE HOOD
05 · WHERE IT STANDS
Chuchu is in early development. These are the current boundaries of the implementation, not a roadmap — the documentation is the source of truth.
IMPLEMENTED
NOT YET
The validated native environment is macOS on Apple Silicon. Linux and Windows builds exist, but the public docs do not yet claim native support for them.
06 · OPEN SOURCE
Chuchu is MIT licensed. The compiler, the documentation and this website all live in public repositories, and contributions are welcome — compiler behaviour, diagnostics, examples or docs.
COMPILER
The Rust crate and the Cheeku binary. Lexer, parser, type checker, LLVM backend, optimisation and native linking.
View repositoryDOCUMENTATION
The reference for the language, the tooling and the compiler architecture, published at docs.chuchu-lang.org.
View repositoryWEBSITE
This site. A Next.js App Router project with plain CSS and no runtime dependencies beyond React.
View repositoryInstall Cheeku, compile the bundled example, and run a native program you built yourself.