A game development
platform, built
from scratch.

// the pipeline

Source in, native code out.
One stack, no borrowed parts.

Every panel below is real: the programs compile and run with today’s toolchain, and the IL is the compiler’s actual -O1 output.

module Hello;

bind Zanna.Terminal as Term;

func start() {
    var total = 0;
    for i in 1..6 {
        total = total + i;
    }
    Term.Say("Zanna says hello");
    Term.SayInt(total);
}

DIM total AS INTEGER = 0
FOR i = 1 TO 5
  total = total + i
NEXT i
PRINT "Zanna says hello"
PRINT total

il 0.3.0
extern @Zanna.Terminal.SayInt(i64) -> void
extern @Zanna.Terminal.Say(str) -> void
global const str @.L0 = "Zanna says hello"
func @main() -> void {
entry_0:
  br forin_cond_0(1, 0)
forin_cond_0(%t31:i64, %t33:i64):
  %t7 = scmp_lt %t31, 6
  cbr %t7, forin_body_1, forin_end_4(%t33)
forin_body_1:
  %t11 = iadd.ovf %t33, %t31
  %t16 = scmp_gt %t31, 9223372036854775806
  %t18 = zext1 %t16
  %t20 = trunc1 %t18
  cbr %t20, forin_end_4(%t11), forin_update_do_3
forin_update_do_3:
  %t23 = iadd.ovf %t31, 1
  br forin_cond_0(%t23, %t11)
forin_end_4(%t35:i64):
  %t24 = const_str @.L0
  call @Zanna.Terminal.Say(%t24)
  call @Zanna.Terminal.SayInt(%t35)
  ret
}

$ zanna run hello.zia
Zanna says hello
15

// in the tree today

What exists right now

No roadmap slides here — this is what is in the repository and working, in varying states of finish. Each of these has a page of its own.

The platform

Two languages, a typed SSA intermediate language, an optimizer, and native backends that emit executables without a third-party toolchain.

• Zia and BASIC, lowering to one documented IL
• IL 0.3.0 — block parameters, checked arithmetic, a strict verifier
• ARM64 and x86-64 backends; ELF, Mach-O and PE written in-tree
• JSON diagnostics, LSP and MCP language servers

Read about the platform →

Zanna Studio

The workbench: a Zia editor with language services, a VM debugger, and visual 2D and 3D scene editors — itself written in Zia.

• 455 Zia source files; exactly one C file in the tree
• Runs on the same GUI and 3D runtime it ships to games
• Scene editors that write the files the games actually load

Read about Studio →

The game engine

Not a separate download — the runtime every Zanna program already links against, with 2D and 3D rendering, physics, audio and input.

• Metal, Direct3D 11, OpenGL 3.3 and a software rasterizer
• Rigid bodies, characters, vehicles, cloth, navmesh
• Image, audio and model formats decoded from scratch

Read about the engine →

Games built on it

The programs that keep the platform honest. First-person and third-person 3D, 2D campaigns authored as scene files, and a shelf of arcade classics — all in Zia, all on this runtime.

• Ashfall, Ridgebound, XenoScape, 3D Bowling and more
• Two campaigns rebuilt from authored scenes, parity-checked
• Every screenshot a real captured frame

See the games →

Counted from the tree on 2026-08-05: SLOC via scripts/count_sloc.sh (blank and comment lines excluded), opcodes via zanna --dump-opcodes, classes via zanna --dump-runtime-api. The last one is counted by reading the build files.

// getting it

No installer yet.
The source builds anywhere.

Installers for macOS, Windows and Linux are built and tested, but none is published — there is no version worth asking you to install yet. Building from source is how everyone working on Zanna uses it, and there is no dependency-fetch step because there are no dependencies.

$ git clone https://github.com/zannagames/zanna
$ cd zanna

# macOS
$ ./scripts/build_zanna_mac.sh
# Linux
$ ./scripts/build_zanna_linux.sh
# Windows (PowerShell)
$ ./scripts/build_zanna_win.ps1

# then
$ zanna init my-game
$ zanna run my-game

CMake 3.20 or newer and a C++20 compiler — that is the whole list. The scripts configure, build, test and install.

// status, plainly

Pre-alpha means pre-alpha