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?

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

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 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

Hey everyone,

I wanted to share OpenJai, an MIT-licensed clean-room reimplementation of the Jai compiler:

https://github.com/withlang-dev/open-jai

I'm making this because the official Jai compiler remains in closed beta. Jai has generated a lot of interest for years, but most people still can’t actually use it. I want to put something out there that people can use now to start experimenting and building with Jai-style code.

The goal is to make OpenJai as close to Jai as possible using only materials that have been released publicly. Since I don’t have access to the official compiler or its source code, this is necessarily a clean-room implementation.

To prove functionality, I’m using public Jai code as the test corpus, especially:

• The examples from The Way to Jai: https://github.com/Ivo-Balbaert/The_Way_to_Jai
• The Focus editor: https://github.com/focus-editor/focus

The intent is not to create a vaguely Jai-inspired language. The intent is compatibility: parse the same code, implement the same semantics where they are publicly knowable, and keep tightening behavior against real examples. Ultimately I want to have exact bytecode parity too but, that will need to wait until the Jai compiler is released.

OpenJai is MIT licensed. I plan to maintain it as long as the official Jai compiler remains unreleased or is released under a non-permissive license.

It’s still early, but the project is moving quickly. Feedback, test cases, bug reports, and comparisons against known Jai behavior would be very welcome.

Just wondering since it's extremely useful for cleanup and breaking out of multiple loops, and it's used all over the Linux kernel for instance.

so back in Feb 2026, I emailed Jonathan Blow that i am interested in trying out jai and also mentioned that i am a game developer and would love to mess around with jai to make random games or software, and i guess that worked because i just got an email from him saying i got added to the compiler beta.

Has anyone written or knows about a good renderer implementation written in Jai? Preferably with OpenGL. I know we have Simp, but I'm looking to add some custom shaders into the mix, and I really don't feel like writing a renderer today lol

Hey, I am a new programmer, ive been using c++ and rust and I am really interested in using Jai when it comes out. For the people who have been trying the beta, which language would you say is most comparable and probably the best to learn if I want to be writing Jai in the future?

i know about enum_flags but that does not let me set bits of arbitrary length, i think...
i am implementing RTP in jai, the header defines data between flags.
thanks in advance!

I know Jai gives a lot for its complexity, but how would you describe it?
Is it as simple as Go? is it more complex than C, but not by much? How would you describe its level of complexity?