Built with Milo

Real programs written in Milo. Every one is a single .milo file. Clone the repo and run or build any of them yourself with the ./milo wrapper. They double as integration tests for the standard library.

What do you want to build today?

Pick what you have in mind. Each row jumps to real, runnable examples further down this page, and to the docs that teach the language features they lean on. New to Milo? Start with the Language Tour and the Playground — no install needed.

I want to build…	See it working	Learn the pieces
A game or console emulator	Emulators, graphics demos	Ownership, Concurrency, FFI (SDL)
A web server or API	Servers & network apps	Error handling, Concurrency, Get started
A command-line tool	CLI tools	Quickstart, Strings, Collections
A terminal app (TUI)	Terminal & graphics apps	Concurrency: green tasks & Select
A debugger or dev tool	Debugger: hades, java-dap	FFI, Modules
A language or interpreter	Data & interpreters, the compiler itself	Enums & pattern matching, Ownership
Low-level / embedded	flightController	Safety, FFI

Emulators: desktop and browser

Three retro-console cores. Same Milo source runs two ways: native binary on desktop (SDL video/audio/input) or JavaScript in the browser via milo emit-js. No plugins. Drop a ROM and play.

NES

Cycle-stepped 6502, PPU, and APU with DMC audio and multiple mappers. Ships six free homebrew games playable in one click: Blade Buster, Battle Kid, Super PakPak, Sir Ababol, Lawn Mower, Mad Wizard. Drag in your own .nes ROM to play anything else.

Genesis / Mega Drive

Motorola 68000 + Z80 dual-CPU core with the VDP graphics processor and FM/PSG audio. Preset homebrew: Headship, Astro Perdido, Gravity Pig, Dragon's Castle. Accepts .md / .bin / .gen / .smd ROMs.

SNES

65C816 CPU plus the SNES PPU, including a Super FX (GSU) coprocessor core. Plays Super Mario World and Donkey Kong Country; Star Fox boots with GSU-rendered 3D. Load an .sfc / .smc ROM.

All three run natively too: examples/emulators/arcade.sh <rom> builds the right core with SDL video, audio, and input. examples/emulators/retro/ turns them into a Raspberry Pi couch console with a gamepad-driven menu.

Debugger

hades

A web + AI interface for any DAP debugger (lldb-dap, debugpy), written in Milo. One binary, two subcommands: hades web serves a React + Monaco + xterm.js debugging UI from a Milo HTTP/WebSocket server: breakpoints, stepping, call stacks, expandable locals, watch expressions, an ARM64/x86 disassembly pane, and a real PTY terminal you can type into while your program runs. hades mcp exposes the same session to an AI over MCP: both you and the model see and drive the same debuggee. Debugs Milo binaries too; the compiler emits standard DWARF.

java-dap

A standalone Debug Adapter Protocol server for the JVM, written in Milo. No Eclipse, no jdt.ls, no JVM-side code: the whole adapter is a DAP-to-JDWP protocol translator in about 1300 lines. Works with any DAP client, and hades finds it automatically, so you can debug Java the same way you debug Milo.

Terminal & graphics apps

TUIs in examples/terminal/ and examples/graphics/, built on the standard library's terminal, PTY, SDL, and green-thread APIs.

Program	What it is
tetris	Event-driven terminal Tetris; one green task parked on a Select, no polling
sysmon	htop-style live system monitor
donut	The classic spinning 3D torus, truecolor-shaded
plasma	Full-screen truecolor animation; doubles as a render-throughput benchmark
aquarium	Truecolor pixel aquarium: fish, bubbles, swaying seaweed
chihuahua	DVD-logo-style bouncing screensaver with a shaded pixel-art sprite
splitPty	Two commands side-by-side in real PTYs; a mini tmux
flightController	Single-axis PID altitude controller with an interactive TUI
menu	Fullscreen SDL retro-console front-end with a gamepad/keyboard ROM picker

Servers & network apps

Program	What it is
termpair	Share your terminal in the browser: WebSocket relay with end-to-end AES encryption, client and server both in Milo
weather	weather.gov frontend served from a single static binary
serve	Static file server with directory listing
webserver	HTTP server with routing, path params, middleware
httpClient	HTTP client for fetching URLs
fetch	Fetch an HTTP API over TLS and parse the JSON response

Data & interpreters

Program	What it is
milojs	A JavaScript engine in Milo: parser, evaluator, mark-sweep GC. Runs express
kvstore	Page-based key-value store with cursors, in the sled/buffer-pool style
minilang	Tree-walking interpreter for a small expression language

The language, feeding itself

Program	What it is
src-milo	The Milo compiler, in Milo. Self-hosting: it compiles itself, and the result is identical every time
smtSolve	The SMT solver behind milo prove. Milo's contracts are discharged by a Milo binary
fmt	The Milo source formatter, in Milo

CLI tools

Coreutils-style tools in examples/cli-tools/, each a single .milo file.

Program	What it is
grep	Pattern search with color, -i / -n / -c / -v
rg	ripgrep-lite: regex-powered recursive search
jq	JSON query tool
tree	Recursive directory tree with depth limiting
cat	File viewer with line numbers and syntax highlighting
wc	Line/word/char counter
hex	Hex dump viewer with ASCII column
shuf	Shuffle input lines
calc	Expression evaluator
parallel	Run shell commands in parallel across input lines (fork-based)
timeout	Run a command with a time limit
pkg	Milo's own package manager: install and publish packages over git, with a lockfile and GitHub registry

Run these yourself

Every program above is a single .milo file. Clone the repo and run or build any of them with the ./milo wrapper:

./milo run examples/cli-tools/grep.milo -- "hello" myfile.txt
./milo build examples/net/serve.milo -o serve && ./serve

A taste: grep in Milo

from "std/argparse" import { newParser }
from "std/io" import { readFile }

fn main(): i32 {
    var parser = newParser("grep", "search for a string pattern in files")
    parser.addPositional("pattern", "string pattern to search for")
    parser.addPositional("file", "file to search")
    parser.addBool("ignore-case", "i", "case-insensitive search")
    parser.addBool("line-number", "n", "show line numbers")
    parser.addBool("count", "c", "only print count of matching lines")
    let args = parser.parse()

    let pattern = args.getString("pattern")
    let filePath = args.getString("file")

    let content = readFile(filePath)!
    let lines = content.split("\n")

    for line in lines {
        if line.contains(pattern) {
            print(line)
        }
    }
    return 0
}

Prefer no install? Compile and run Milo in your browser on the Playground.