A fast, simple language that compiles to native code.

Get started

One line, on Linux/macOS/MSYS2 UCRT64 bash on Windows — it clones the source and checks/installs build dependencies for you:

$ curl -fsSL https://raw.githubusercontent.com/uraikus/festina/main/install.sh | sh

Or from an existing checkout:

$ sudo apt install clang libsqlite3-dev libcairo2-dev libx11-dev libasound2-dev pkg-config
$ bin/festina compile examples/hello.f -o hello
$ ./hello

Or skip the intermediate binary and just run it:

$ bin/festina run examples/hello.f

Not sure your machine has everything Festina needs? bin/festina doctor checks every dependency above and tells you exactly what's missing and how to install it — including whether festina itself is on PATH yet. Add --fix and it installs whatever's missing for you (via apt/Homebrew/MSYS2's pacman, whichever this machine has) and adds festina to PATH too.

That's the whole loop — see setup.md for the full dependency breakdown, packaged-binary installs, and running the test suite. macOS and Windows are supported too, each with its own CI-verified toolchain section in setup.md.

Editing .f files in Vim or Neovim? See editors/vim for syntax highlighting (Vim's own bundled Fortran filetype otherwise claims the .f extension).

A familiar language, statically typed

int count = 10
text message = 'Hello'
bool active = true

if active {
    log(`${message}, ${count} times`)
}

int func add(a:int, b:int) {
    return a + b
}

for int i = 0, i < 10, i++ {
    log(i)
}

int and float mix freely — the int side promotes to float automatically, and / always returns float. The only way back to int is Math.floor/ceil/round/trunc. Division and modulo by zero return null instead of crashing. See the API reference for the full language and standard library documentation.

Built in, not bolted on

// SQLite -- no setup code, no ORM
table People { id:int  name:text }
arr[People] people = sqlite('SELECT * FROM People')

// Graphics -- a real window, opened on first use
color brand = '#4a90d9'
font  title = 'bold 24px sans-serif'
fillStyle(brand)
changeFont(title)
drawRect(0, 0, 100, 100)
on mouseDown(x:int, y:int, button:int) { log(`pressed ${x}, ${y}`) }
on mouseUp(x:int, y:int, button:int)   { log(`released ${x}, ${y}`) }

// Audio
aud music = 'music.wav'
music.play()

// Files -- a blob is a file's bytes, and knows its own path
blob notes = 'notes.txt'
notes.write('hello')
log(notes.toText())
notes.saveCopy('notes.bak')           // img and aud save the same way

// Timers
setTimeout(showMessage, 1000)
setInterval(tick, 500)

// Regex, literal syntax
'room 42'.replace(/[0-9]+/, 'N')

// Maps -- text-keyed, object-literal-flavored
map[int] npcHealths = { 'npc1': 10, 'npc2': 15 }
npcHealths['npc1'] = 30

// Threads -- isolated, message-passing, no shared mutable state
thread doubler {
    on message(sender:thread, msg:int) { sender.reply(msg * 2) }
}
doubler.postMessage(21).callback(void (answer:int) => log(answer))

// Config straight from the environment, no extra library
text apiKey = environment.API_KEY

How it compares

Festina, Rust, Go, and Bun on the same small equivalent-logic benchmarks. Not a claim that Festina is faster in general — see benchmark.md for methodology and the full, regularly-refreshed results.

HTTP: Festina vs Rust vs Go vs Bun

Four servers answering the same two routes — / (plain text) and /json — load-tested with wrk. All four are held to the same connection-handling logic: single-threaded, one connection at a time. Festina's HTTP server works this way natively (see HTTP Limitations), and the Rust/Go servers here are hand-rolled raw sockets matching it rather than hyper's or net/http's own multi-threaded defaults. Every response closes the connection, matched uniformly across all four: Rust's and Go's raw-socket servers close by default, Bun's server sets Connection: close explicitly to opt out of its own native keep-alive, and since Festina supports HTTP/1.1 keep-alive by default (see Keep-alive), the load generator itself sends an explicit Connection: close request header against all four servers uniformly, which Festina honors per-request the same way any other client's explicit close request would be.

Festina clears Go on both routes and lands right around Bun's own number, with Rust ahead of all three — read that as "at matching connection-handling logic," not as a claim about what hyper/axum or net/http would report with their own concurrency and keep-alive defaults turned on, or about Bun's own native Bun.serve(). The /json route runs Festina's request struct through the same JSON-via-.toText() path every other container response already uses, so the gap between the two routes reflects that serialization cost rather than connection handling. Numbers are one client machine talking to one server process on the same machine — no network hop, no TLS — the same disclaimer every other benchmark on this page carries.

Short version: Festina holds its own against Rust and Go on compute-bound native code and lands right at them on allocation-heavy work too, comfortably outruns a JIT on cold single-shot execution, sits second on string_concat — ahead of both Go and Bun and within ~2.4x of Rust's spare-capacity-reusing String, the one gap here that's genuinely algorithmic, not an allocator artifact — and clears Go on HTTP throughput too, landing right around Bun's own number, with Rust's raw-socket implementation ahead of all three.

Project status

The compiler frontend, LLVM codegen backend, and native C runtime are real and tested. Every specification.md language construct this project has committed to is implemented end to end, not just parsed. That includes a leak stress suite — scripts/leak_stress.sh runs mixed churn programs plus one isolation program per data type under AddressSanitizer and LeakSanitizer, because "the answers are right" and "nothing accumulates while producing them" are different claims. Native builds on Linux, macOS, and Windows, plus cross-compiling to wasm32-wasi, are all supported today. See tests/CONTRACT.md for exactly what's covered, and todo.md for what's next.

Documentation

Design philosophy

Festina intentionally favors:

• Performance over flexibility
• Static typing over runtime inference
• Simple language rules over extensive syntax
• Compile-time work over runtime work
• Native representations over unnecessary abstraction
• Familiar syntax without dynamic-language semantics

Festina is not a scripting language with a compiler bolted on — it's a compiled, statically typed language designed from the start for native performance, that happens to keep its syntax approachable.