Dodo

Dodo is an ahead-of-time compiled systems language with checked borrowing, explicit memory ownership, and native output. Start with small terminal programs; use the same language for portable libraries, hosted applications, and low-level hardware code.

Compiler 0.1.4 · Language design 0.1 · BSD-2-Clause

Start in five minutes

Install Dodo and a C toolchain, create a folder named hello, and save this as main.dodo inside it:

package main

import "std/console"

fn main() {
    console.println("Hello, world!")!
}

From that folder, run:

dodo run

It prints Hello, world!. println returns a Result because output can fail; postfix ! takes success or panics on failure. The first-program tutorial explains every line, shows how to change the program, and builds a persistent executable on Linux or Windows.

The standard library is embedded in the compiler. Projects use ordinary folders and imports; no manifest, lockfile, or package manager is needed.

Learn the language

The documentation has a sequential learning path and a separate reference:

1. Variables, values, and expressions
2. Types and functions
3. Control flow
4. Ownership and borrowing
5. Patterns, options, and Results
6. Generics
7. A complete temperature-report walkthrough
8. Packages and imports and testing

Use the glossary for unfamiliar terms, the syntax reference for exact rules, and diagnostics when a program is rejected. Runnable examples are also in examples/.

Dodo implements part of the broader 0.1 design. Read implementation decisions and limits alongside the language specification. The specification is also available as plain text and PDF.

These docs follow main, which can contain APIs added after a release. Use the v0.1.4 tag for released source and CHANGELOG.md for version changes.

Find a library

The standard-library guide helps you choose a package. The API reference contains exact public signatures, types, fields, methods, and source contracts for every bundled source package. It is generated from the library at each documentation build.

Build with	Guides
Terminal input/output	Console, formatting
Data and storage	Bytes, UTF-8 text, JSON, collections, allocation
Calculations	Core, math, hashing, time
OS services	Files, environment, processes, threads, synchronization
Network applications	Sockets and DNS, TLS, HTTP, web servers

Portable packages work with explicit storage and no required OS, global allocator, or scheduler. Hosted adapters currently support Linux GNU x86-64 and Windows x64. Each guide documents its actual target and dependency requirements.

Everyday commands

dodo fmt
dodo check
dodo run
dodo test
dodo build --release
dodo --help

check, run, and compile select main.dodo by default. Pass a filename or project folder to choose another input. compile is an alias for build. dodo test discovers named tests and explicitly executable Markdown examples. Add an optional dodo.toml for named targets, profiles, and saved arguments. Use dodo build -b NAME, dodo targets, and dodo build --print-config to work with configured projects. dodo init creates a small project without overwriting files.

See the command-line guide for output paths, debug information, optimization, cross-compilation, and linkers. The VS Code extension supplies highlighting and connects to dodo lsp; other editors can use the same language server.

Build and contribute

Frontend development needs Rust 1.98.1 and its platform linker. LLVM is optional for parser, checker, formatter, package-loader, and editor-analysis tests:

cargo test --locked --no-default-features --all-targets
cargo clippy --locked --no-default-features --all-targets -- -D warnings

A full compiler build additionally needs LLVM 23 development files and a C toolchain. The source-build guide explains prerequisites, Windows setup, release builds, debugging checks, and CI. After configuring LLVM_SYS_231_PREFIX:

cargo build --locked
cargo test --locked --all-targets
cargo run --locked -- test
cargo run --locked -- test -O 3

For repeatable JSON, routing, and loopback HTTP performance measurements, see the stdlib benchmark guide and recorded baseline.

To edit and verify documentation with Node.js 24+ and Python 3.10+:

npm ci --prefix docs
npm run build --prefix docs
python3 scripts/generate_api_docs.py --check
python3 scripts/render_spec.py --check
python3 scripts/check_docs.py

npm run dev --prefix docs previews the site. Follow Edit these docs for writing standards, executable examples, generated API pages, and navigation. The existing GitHub Actions workflow publishes documentation changes on main.

Repository layout

Path	Contents
src/	Compiler, CLI, formatter, semantic checker, and language server.
stdlib/	Bundled Dodo library sources and dependency notices.
examples/	Small programs to read, check, and run.
tests/	Acceptance, rejection, execution, and platform fixtures.
docs/	Guides, canonical specification, generated API reference, and Astro site.
editor-support/	VS Code extension and editor instructions.
scripts/	Documentation generation, release tooling, and validation.
.github/workflows/	Compiler, editor, release, and documentation automation.

Generated target/, build/, documentation build outputs, and extension packages are ignored by Git. They can contain local toolchains or unfinished work; inspect paths before deleting them. The contributor guide explains which documentation files are generated.

Copyright © 2026 Johannes Müller and Dodo contributors. Licensed under BSD-2-Clause.