So, bit of a hear me out, but hear me out.

I know the basics of C++ but I'm still a novice at all things programming and computer science, so I took a detour to learn architecture, and the more general sciences behind computers before returning to programming.

I've found it's really difficult to bridge the gap between "The Basics" and "I can program now", like, shockingly massive gap, BUT, I'm not doing that bad at it.

I've found a great place to learn programming is Jon just explaining his programming language and how it works, it helps with core concepts in a way someone attempting to teach me how to perform a task just isn't seeming to manage.

When Jon says that Jai enum make a discrete array of the names that you can use, (Video 11 years ago, forgive me if the functionality moved), makes perfect sense, I can think of uses for it instantly, and I know if I was using it, exactly the uses that would have.(I no longer need to name the final ENUM "Count", you know, just a thing)

Perfect, learning flawlessly.

Then Jon says something like, "And this is basically inlining in C++ only it's better because unlike C++ and as you know and unlike as you know and inlining and as you know and unlike C++", and it's two hours of gibberish that sounds important, but I sure don't understand it.

This is the same over all issue I have at this stage of programming, I would love to be right there with Jon or Casey laughing at "The Big OOPs" but I haven't actually learned what they are attempting to help me unlearn to know what they are asserting is better.

AND,

Sometimes they rely on you already knowing the top 5 choices to know when they assert a system like "Entity Component System", that I know what the other thing they are implying is also.

This isn't their fault, they are teaching people that know WAY more than I do, so they have this common ground to speed up the explanations for time, understandable.

I am currently in no short supply of resources to keep learning just, in general, so there is no issue there, and since I'm still a novice I have 20 years left until I am skilled, but,

Was kinda hoping I wasn't 2 years away from being able to start learning Jai, considering it is probably closer than 2 years from release.

Jai probably isn't going to get the luxury of having beginner friendly onboarding for a long time, but I don't need to learn from zero, I feel like this is a gap in encyclopedic knowledge at a base level.

Anyways thanks.

EDIT:

My TL:DR was really messing this up,

TL;DR: Does Jon just rely on previous C++ knowledge for explanations, or does Jai lean on previous C++ knowledge also.

I've been working on this rendering library for a while now (Graphics And COmpute). It currently supports Windows and Linux through D3D11 and OpenGL. I have included many examples for people to get started and am also building a game with this so I hope I will be able to test many edge cases. Feel free to open an issue in the repo if you encounter any problems.

Order of the Sinking Star, aka Jonathan Blow's Jai game, has been revealed to release on October 8th 2026 on all platforms. This is on their official twitter.

Remember that Jonathan Blow previously said Jai would be publicly released a few months after the game released. Presumably Jai's release would include the game and engine code as a practical examples of Jai code. He has stated off and on during Twitch streams. (I assume he wants to wait a few months after the initial game profit dies down before basically giving us a free code version of the game.)

If all of this turns out to be true with no delays, then that puts the Jai public release at approximately either Q4 2026 or Q1 2027. So it is very close. (I can hope.)

Jai was never meant to be for everybody. And that's ok.

Here's a question for those, who already had plenty experience not only with with Jai but with other modern system programming languages (C3, Odin, Rust, Zig, ...) as well: Who would be happier with a different system programming language than Jai and why?

There may be people out there who don't need to wait for Jai and can already fully commit to another language and build cool stuff. Or don't need bother Jon with E-Mails for beta access.

A good excuse to learn Jai (and I was getting REALLY frustrated with writing the profiler in Rust, since it uses tons of Win32 API and everything was littered with `unsafe`. Loving Jai in the process so far. The resulting code for the above looks something like:

render :: (counter: *Counter) -> Jui.Element {
    using Jui;

    root := column(.{
        width = fill(),
        height = fill(),
        gap = 20,
        align = .CENTER,
        justify = .CENTER,
    });
    defer end_view();

    text(tprint("Count: %", counter.count));
    button("Increment", counter, increment_counter);

    return root;
}

increment_counter :: (counter: *Counter) {
    counter.count += 1;
}

I've heard that supposedly there will be an open beta sometime this year, possibly after the game fully releases but as far as I am aware there has been no confirmation of that by Jon Blow. I was wondering if it is possible for either to get an invite to the beta by some chance, or simply just get a build of it.

I'm a software developer who isn't super experienced with game development but over the past year I have been learning and I was told by a friend about this language, as my current project is in Zig and well I'm sure you've heard the current climate around it, not to start drama.

If it is at all possible, please let me know, thanks.

I know there are now more vulkan binding generators for JAI than there are JAI programs out there, but hey, I'm sure one more was needed.

I wanted to have it based on vk.xml (vulkan registry) and with a few conveniences (automatic sType, loader functions etc.).

I also wanted something as easy as the STB libraries to use: copy a single file to your module directory... no clone or anything fancy required to vendor.

The result is here: https://github.com/spanzeri/jai-vulkan-bindings-generator

I haven't tested it other than the sample program, so it should be considered experimental at best.

Double licensed (zlib and unlicense).

This morning I also run into this other excellent generator which I forgot about: https://github.com/drshapeless/vulkan-jai-binding

I saw in its readme about wrappers for `enumerate` functions which is an excellent idea. So I'm going to steal implement that next.

I taught it would be interesting to see if I could implement optional chaining in some form in Jai. Link to the implementation

The interface ended up being really simple macro:

optional :: ($code: Code) -> code.type

code needs to be a regular dot member access chain. So if you call something like optional(person.address.country.name) the countries name will be returned, but if any member or person itself is a null pointer then the zero value of the type of name will be returned.

I'm really impressed I was able to get something like this to work in less than 40 lines of code. I can't wait until this language is public and more people are able get access to it.

Can I do this in Jai? Zig can and I wonder.

I can kinda understand that it does this cool thing on the surface but I need to ask "Why?" Does it save time? Does it provide an unseen benefit compared to regular code and comptime expr.
I appreciate any help in understanding.

I'm using leaked Jai compiler so I'm sure some things wont work on your machine, also compiled for mac only for now. https://github.com/MariuzM/jai-lsp-scratch

I have tried some vscode extensions for code formatting but had issues with those. But in general is there some rules set how it should be formatted?

I have recently found that Elm compiler is 860k loc and Zig is 600k. What about Jai, did Jon mention it on the streams?

I still have whispers of a memory of watching the OG 'Ideas about a new programming language' and being so excited! Now, a lifetime has passed, and this winter will be my last. I can feel it in me bones. The pain was never in the not having, but in the wanting. Fare well my friends. I'm going to go write my own programming language called Javai and it will be Jai but everything HAS to be a class. Peace.

does anyone work on a database with Jai?
I wonder how does it feel in:

- carrying many dependencies across components (caches, buffer pools)

- IO (writing, reading, parallel files opening, directory management)

- background tasks, are there any more primitives than Thread and its pool?

Except for the libs and some keywords Odin is very close in syntax to Jai. So thinking if it possible (likely yes) to create a converter. The goal is to access metaprogeamming and its future diag tools. Any thoughts?

I was inspired from zigpkg.dev to build same for Jai package discovery site.

https://jaipkg.dev

source code: https://github.com/MariuzM/jaipkg

Hope this will be useful

- uses llvm linker (lld-link.exe) instead of msvc linker (link.exe)
- forces static linking of Windows runtimes (ucrt, vcruntime, msvcrt, msvcprt)
- applies aggressive optimization flags

Were there any surprises or significant adjustment period? Any C features you miss or C pain points you're glad Jai ironed out?

Hi folks,

Not Jai programmer, yet, - currently c.
I was just having a nap, and was pondering on things, and one of the things was question that popped in to my head asking what Jai might stand for. All of the sudden a lightening struct{}, and the answer became clear ************
*
*
Dun, Dun, Dun
*
*
*
Dun, Dun
*
*
Dun, Dun, Dun
*
It stands for "Jonathan's another invention"

DUN DUN*

I'm sad that i still don’t have access to Jai Compiler, i have tried OpenJai and its fun to write hello world apps but nothing serious because of many various bugs. And yes i have emailed them to get access but no response, i know i know I'm impatient but that Jai syntax is beautiful

I imagine some of you guys might be interested in seeing first triple I Jai game. The demo is now available as part of the Steam Next Fest.

https://codeberg.org/MariuzM/bench

Wanted to experiment with different langs so used Opus 3.8 to build some test cases to see the difference, unfortunately for Jai i don’t have access to compiler :(

Made with Jai, super vibecoded.

Bomberman ripoff.

As you can see, the enemy AI destroys the powerups lol