Right, if you look at say, Blue Prince, one of the most important "out of nowhere" type video game releases of 2025, the actual software engineering is trash. I'd fail code reviews for a lot of what was done, and there are cracks in the façade where a player will hurt themselves as a result - e.g. there's a bug where animations overwrite so you get short changed on the resources you were gathering when you go "too fast". Some of the intended features, especially in the 1.0 release, just don't work for reasons like somebody typo'd a variable name, or they forgot how a function worked.

But the game is amazing and that's what matters. Nobody wants to play six hours of carefully engineering tasteless crap, let alone (as many did with Blue Prince) six weeks. The 1.0 Blue Prince game was already excellent, unless you run into a nasty save corruption bug on PlayStation, whereas a game made Jon's way might be a soulless waste of your life even though perhaps the engineering is "better" in some sense.

>People laugh at games with thousand-case switch statements or if/else chains but they shipped and the end user doesn't care about logarithmic complexity.

This "not caring", from both coder and end user, is why the end user constantly gets buggy, slow, and resource hungry software, be it games, or other kinds.

> People laugh at games with thousand-case switch statements or if/else chains but they shipped and the end user doesn't care about logarithmic complexity.

Both Blow and Muratori would likely advocate for the this type of code to some degree.

> Or does it, like Typescript for JS, only exist because of extreme antipathy towards C++?

Typescript exist because people want a type-checked language.

> What features in Jai make it superior to C++ for writing games specifically?

Some examples that come to mind from my personal experience.

- Compile times. 1-2 seconds vs the typical build times in a C++/Rust game can be a game changer

- Massive compile time capabilities.. you can have an entire content pipeline executed at compile time, all written in Jai

- Builtin Type reflection.. another gamechanger in games for editors and such

- Very easy to debug, the minimalistic approach means the code is not heavily transformed by the compiler thus really easy for a debugger to follow and still performant. Example: loading the same gltf file in my engines in Rust and C++ debug mode is MUCH slower than debug mode in Jai.. again, game changer.. you hit build/run and you're back in the game in few seconds.

- Very easy to learn

- Very ergonomic in its minimalism

- A lot of small things you instantly miss when jumping to other language.. one thing on the top of my head.. the ability to have struct members "overlay" other specific locations.. so you could have a Matrix4 struct with Vector members "forward" "right" "up" etc

- The builtin "context" based "temp allocator".. perfect for games, anything that is needed for a frame goes in there with close to zero allocation time and it gets reset every frame at zero cost

Jai has a HUGE potential if it can survive Mr. Blow's ego.. which is a big big ask.

> People laugh at games with thousand-case switch statements or if/else chains but they shipped

You have a very incorrect view of both of them if you think this is the kind of thing they are arguing against.

> What features in Jai make it superior to C++ for writing games specifically?

I know that Jonathan Blow can be abrasive and one-sided in his talks on programming, but I think we should be open-minded about Jai. Yes, he is making this language because he doesn't like C++, but you make it sound like he is hating on C++ just for the sake of it.

I mean, is it really so hard to imagine that someone might not like something about C++? There are plenty of people who think we could have a better systems language, which is why we have seen languages like Rust, Zig, and Odin pop up.

In Blow's case, he has said that he doesn't like Rust because he feels that satisfying the borrow-checker slows down iteration time[1], which is important especially in the early stages of game development when you are still experimenting with mechanics are where requirements and architecture are still very much subject to change.

As far as what Jai offers, it seems his focus is on making a simple but powerful language (contrary to C++'s ever-growing bag-of-tricks), with fast compile times (less than 3 seconds on a full build of his new game), better build and dependency management (no more cmake), and powerful meta-programming features.

In a talk on the language[2], he demos how he is able to use the language's meta-programming features to develop powerful code-analyzing and memory-analyzing tools.

These tools, in particular, hint at his philosophy: lots of ideas in programming like RAII, garbage collectors, and borrow-checking exist to save the programmer from themselves. He's not interested in this and believes that these features come with hidden costs. Instead of accepting those costs, he would rather have a language that gives him the tools to save himself.

Personally, I don't understand the hate. If Jai is a good language, then it will benefit all of us. If it's not, then his making it still hurts none of us.

[1] https://www.youtube.com/watch?v=4t1K66dMhWk [2] https://www.youtube.com/watch?v=IdpD5QIVOKQ

Looking at this, there's some nice features in there, I guess. Likely the major features are about what it doesn't have. https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md

A syntax to mark structs to be stored as SOA in arrays is the only one I see that doesn't have a modern C++ analogue (besides things like no header files).

Const expressions, defer (but not sure its significantly different than using destructors), some smart pointer stuff...

I assume you need to compare it to C++ from more than a decade ago.

Jonathan Blow makes Jai because he wants to make Jai. It's the same reason he makes his games at all.

This. As much as I love listening to JB, graphics wise he’s not doing anything ground breaking, it could even be done on the web. But I understand for him the architecture for his games being perfect is what makes it worth it for him.

> What features in Jai make it superior to C++ for writing games specifically?

You can write games in C or Fortran, so why write games in C++? You can write things in C++, why make Rust? Basic worked, why make Python or Ruby?

Why does it need "features" that make it "superior"? It should be good enough that he didn't want to use C++, so he made a new thing...

This reads as if the process and the finished work are somehow separable. If your code is a mess that you hate working on, it seeps through to your design and your design process. I too had a brief period where, for example, I thought dynamic typing lessens friction, but in reality it just causes massively more friction down the line. Many people never get to go down the line, so that is fine for them, but not me.

Jai is designed for games, it aims to do a few things that can help game developers, as well as developers in general.

- Lower compilation times for debug builds. - Better debug messages. - A standard library that comes with a production ready graphics API, so gamedevs don't need to worry about the current state of graphics API and can just dig in. - Standard input API for cross OS development. - AOS to SOA automatic conversion to simplify code that needs to be performant, while retaining a clean syntax. - A context system, which should help with simplifying functions definitions while keeping things strongly typed. - The ability to rewrite ASTs, to do compile time programming. Ideally simplifying code, while keeping runtime speed performant, and keeping compilation speed fast.

This is just to name a few off the top of my head. The performance and API stuff is directly going to help game devs. I view it similar to Odin, something that is in production software right now, where you can have a clean langugae, with a strong standard library and primitives to help you develop quickly.

Except, this complexity isn't saving time and resources. This complexity admiration culture has resulted in slower code thats harder to understand, debug and maintain too. What should be used only for small amount of time is used from get go like complex architecture and deep abstraction. Fetishizing simplicity is bad too for sure but a blip on a radar and not such a trend and far less of an issue compared to fetishizing complexity thats rampant. Not a game dev or even a gamer, I'm defending attack on simplicity not blow or muratori.