Jai in 2026: The State of Jonathan Blow's Programming Language

It's been over a decade since Jonathan Blow first demoed his ideas for a new programming language built for game developers. Back in 2014 I started collecting Jai links and in 2019 I excitedly wrote that Jai was close to beta. A lot has happened since then. Here's where things stand in 2026.

Beta Status and Access

Jai entered closed beta around late 2019/early 2020 and has remained invite-only ever since. Jonathan Blow has been gradually expanding access, but there is no public download. If you want in, you need an invite — typically through the Jai Secret Beta Discord or by connecting with existing beta users.

The compiler has matured significantly during this period. People like Smari McCarthy, who joined the beta in early 2020, have been using Jai professionally for years now. Forrest Smith completed all 25 days of Advent of Code in Jai (4,821 lines) and wrote extensively about the experience. These aren't toy experiments — people are shipping real work in Jai.

Order of the Sinking Star and the Open-Source Promise

The biggest Jai news is about the biggest project built with it. Jonathan Blow's next game, Order of the Sinking Star, is scheduled for release on Windows in 2026. Blow has described it as "the biggest single-player puzzle game that anybody's ever made," estimating 250 hours at a normal pace and over 500 hours for completionists.

The game is built entirely on a custom engine written in Jai. And here's the kicker: in the December 2025 press release, Thekla announced that "not too long after the game releases, we will give out the engine for free as an open-source project." Blow has also stated that the language itself will eventually be released as open-source software.

This is huge. After years of closed development, the Jai ecosystem is about to blow wide open.

What Makes Jai Special

For those who haven't been following closely, here's what makes Jai stand out:

Compile-time execution. Any function can be tagged to run at compile time using the #run directive. During compilation, your code has full read-write access to the program's abstract syntax tree. This means your build system, your code generation, your data baking — it's all just Jai code. No separate macro language, no external build tools.

Compilation speed. Blow's target is compiling a million lines of code in under a second. Public demos have shown the game's 80,000-line codebase compiling in under a second on desktop — a far cry from C++ build times.

Data-oriented defaults. The language is designed around cache-friendly data layouts and structures-of-arrays patterns. The #insert directive provides a generalized metaprogramming system for data layout transformations.

Built-in reflection. Jai can inspect its own types natively at both runtime and compile-time, without external tooling.

No hidden control flow. No exceptions, no hidden allocations, no constructors/destructors running behind your back. You can see what your code is doing.

Community Resources

Despite the closed beta, a healthy community has formed:

• Jai Community — Forums for discussion and learning
• Jai Community Library Wiki — Community-written tutorials and cheatsheets
• awesome-jai — Curated list of libraries, tutorials, and examples
• The Way to Jai — A comprehensive guide by Ivo Balbaert, built from the ground up
• r/Jai — Subreddit for Jai discussion
• Inductive's Jai Page — Long-running resource page (still updated)
• Jonathan Blow's Twitch and YouTube — Live development streams and archived videos

Recent Writing and Talks

• Four Years of Jai (Dec 2024) — Smari McCarthy's in-depth reflection on using Jai professionally since 2020
• Jai, the Game Programming Contender (Apr 2025) — Bitshifters' overview of Jai's design and how it fits the landscape
• Learning Jai via Advent of Code — Forrest Smith's hands-on experience learning the language
• Simplicity, Jai, and Joy — James Oswald's first impressions
• Wookash Podcast: Jonathan Blow on Jai (Jan 2025) — Status update on macros, release timeline, and the upcoming game

The Landscape: Odin and Zig

When I first started tracking Jai in 2014, it was essentially the only game in town for "a better C for games." That's no longer the case. Two other languages have emerged with overlapping goals, and both are publicly available today:

Odin started as a "sister project" inspired by Jai's ideas and has grown into its own thing. It's pragmatic, stable, and has a Go-like tooling experience with low-level control. The community runs game jams, and there's an active ecosystem around Raylib bindings and hot-reloading workflows. Odin favors simplicity — built-in vectors, matrices, and quaternions instead of operator overloading. If you want something Jai-like that you can use right now, Odin is your best bet.

Zig takes a different approach — it's a "better C" with comptime metaprogramming, no hidden allocations, and seamless C interop. Zig 1.0 is expected in 2026. The game dev ecosystem is growing fast, with projects like Mach Engine and the zig-gamedev collection. Indie game adoption has been growing rapidly.

Both Odin and Zig can trace parts of their DNA back to Jai's early ideas, but they've each carved out their own identity. Jai's deeper metaprogramming, faster compile speeds, and tighter focus on game development may still differentiate it — especially once the compiler and engine go open-source.

What's Next

The timeline is finally becoming concrete. Order of the Sinking Star ships in 2026. The engine goes open-source shortly after. The language itself is expected to follow. After twelve years of development, we're in the home stretch.

I've been watching this project since the very first video in 2014. It's been a long wait, but it looks like the payoff is coming.

See also: Jai Compiler References (my original 2015 link collection) and Jai close to Beta! (2019)