Jai

Jai is a high-performance, statically typed systems programming language created by game designer and programmer Jonathan Blow, best known for Braid and The Witness. Conceived as a modern, no-nonsense alternative to C++ for game development, Jai prioritizes raw performance, deep compile-time metaprogramming, extremely fast compilation, and what Blow calls “joy of programming.” Despite being in active development for over a decade and used to ship real software, Jai has never had a public release — as of 2026 it remains available only through an invite-only closed beta.

History & Origins

Blow began designing Jai in 2014, toward the end of development on The Witness. After years of large-scale C++ game programming, he had concluded that C++ was needlessly complex and actively made software harder to build than it should be. Rather than adopt an existing alternative — he evaluated languages such as Go and Rust but found them unsuited to his goals — he set out to design a language tailored specifically to the realities of shipping games.

In 2014 Blow recorded a now-widely-watched series of talks, including “Ideas about a new programming language for games,” in which he laid out his motivations and sketched the language’s direction. The name “Jai” started as an informal working codename and simply stuck. In 2016, after The Witness shipped, he transitioned to working full-time on three intertwined projects: the Jai compiler, a game engine written in Jai, and a new game. Building a real engine and a real game in the language has been central to its development, letting Blow validate design decisions against production code rather than theory.

A closed, invite-only beta began around late 2019 to early 2020. Access has expanded gradually over the years, but there has been no public download, and the language remains unreleased to the general public.

Design Philosophy

Jai is unapologetically aimed at experienced, performance-conscious programmers — Blow describes it as a language “designed for good programmers” rather than one that tries to prevent every possible mistake. Its guiding principles are high performance, simplicity, low friction, and programmer productivity.

No Hidden Behavior

A recurring theme in Jai’s design is the elimination of hidden control flow and hidden costs. The language avoids exceptions, implicit memory allocations, and automatically invoked constructors and destructors. The intent is that code does what it appears to do, with performance characteristics that are easy to reason about — a philosophy closely tied to data-oriented design, which favors laying out data for efficient access by the hardware.

A Better C++

Jai keeps the low-level, close-to-the-metal model that systems and game programmers rely on, while removing what Blow sees as C++’s accumulated complexity. Blow has argued that a language designed around game programming could meaningfully reduce development time and increase the satisfaction of writing code.

Key Features

1. Compile-time execution — Arbitrary code can run at compile time via the #run directive. Because the compiler exposes the program’s abstract syntax tree, programs can inspect and even generate or modify code during compilation.
2. Powerful metaprogramming — Polymorphic procedures, macros, and full compile-time reflection let programmers build abstractions without runtime overhead.
3. Fast compilation — A core goal is dramatically faster builds than C++. The project has long targeted compiling on the order of a million lines per second, and beta users have reported large game codebases (tens of thousands of lines) compiling in roughly a second on desktop hardware. (These figures come from project goals and informal beta reports rather than standardized benchmarks.)
4. Data-oriented design support — First-class facilities for structure-of-arrays (SOA) layouts make it easy to organize data for cache-friendly, high-throughput processing.
5. Implicit context and custom allocators — A built-in context carries an allocator and other ambient state, making custom and temporary memory allocation strategies a natural part of the language.
6. Static, strong typing with inference — Types are checked at compile time, with type inference (the := syntax) reducing annotation noise while keeping the code strongly typed.
7. Integrated build process — The build itself is driven by Jai code rather than an external build system, so configuring a project is just more programming.

A minimal program illustrates the syntax:

#import "Basic";

main :: () {
    print("Hello, World!\n");
}

The Compiler and Backends

The Jai compiler ships with two code-generation backends:

According to community documentation, Jai targets Windows, Linux (Ubuntu), and macOS, along with at least one game console, primarily on the x86/x64 architecture. Because optimized builds go through LLVM, the range of reachable targets is in principle as broad as LLVM’s, though cross-compilation support has historically been a work in progress. (Platform details are drawn from community documentation of the closed beta; specifics may shift before any public release.)

Current Relevance

Jai occupies an unusual position in the programming-language landscape: it is widely discussed and influential in spirit, yet still unreleased after more than a decade. Its emphasis on compile-time metaprogramming, fast builds, and a no-hidden-cost philosophy has helped popularize ideas now visible in newer systems languages. Odin, created by Ginger Bill, shares a similar declaration syntax and is frequently compared to Jai; Bill has cited a talk by Blow as a minor inspiration, though he describes Jai’s overall influence on Odin as limited (Odin’s primary lineage being Pascal, C, and Go).

The clearest signal of Jai’s maturity is that it is being used to build a full commercial game and engine. Thekla’s Order of the Sinking Star, a 3D puzzle game in the lineage of Braid and The Witness, is scheduled for a 2026 Windows release and is written entirely in Jai. In a December 2025 announcement, Thekla said it intends to release the engine as open source not long after the game ships, and Blow has indicated the language itself will eventually be open-sourced as well.

Why It Matters

Jai is a notable experiment in language design from a practitioner rather than an academic — someone shipping commercial games who set out to fix the specific pain points he encountered in C++. Even without a public release, its talks, demos, and circulating ideas have shaped conversations about compile-time programming, data-oriented design, and what a pragmatic “better C++” might look like. Whether or not Jai becomes broadly adopted once it opens up, it stands as one of the most closely watched language projects of its era and a case study in designing a language hand-in-hand with the real software it is meant to build.