JaiPrimer VS StructArrays.jl

The first and most important step is having a language without statements and only expressions.

But, as Jai needs a `return` in functions, it already failed the trivial test.

https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md

Thanks, and yes, I didn't think about closures.

Talking about closures, I also don't know why Jai needs explicit capture lists. In C++ and Rust I understand the need for them, because you have various ways to pass them into the lambda, but Jai doesn't seem to care, at least in the examples at https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md....

Jonathan Blow & co will probably be busy enough trying to release Braid: Anniversary Edition this year (it will be Braid's 15th anniversary this August), and this will push the release of untitled-Sokoban-game until 2024 or later. Note also that the sokoban game is intended to promote the new programming language he is creating (https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md), so that might slow development / delay the release of the game beyond what would be expected for a normal videogame. (Ie, it's not just the sokoban game that needs to be ready for release, but also perhaps other features of the new language.)

There's quite a lot of information, just not very accessible.

https://www.twitch.tv/j_blow/videos?filter=archives&sort=tim... : this is jai's author livestreaming language development, most up-to-date

https://www.youtube.com/playlist?list=PLmV5I2fxaiCKfxMBrNsU1... : a cureated subset of twitch videos, possibly outdated info

https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md : a summary of jai based on the above curated videos, possibly outdated

The Jai language is the main competitor to C++ I feel. The compile times are insanely short, which is what slows you down the most when actually developing a game in C++ Unreal.

There has been a lot of hype about the Jai programming language (for game development), but another language that has been heavily influenced by it and has a lot of similar syntax and concepts is Odin. Here is a blow by blow comparison, Jai vs Odin.

This reminded me of Jai, the language by Jon Blow. In the Primer here: https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md, the section on Data-oriented design is relevant. Note that the bottom of the OP article mentions explicitly the games industry as caring about this; relevant given Blow's background.

Look for "Data oriented design" or "Structs of arrays".

Here's a talk on the former by Mike Acton: https://www.youtube.com/watch?v=rX0ItVEVjHc

On the latter, there's Jai, a new programming language for games (WIP, unpublished) by Jonathan Blow, who has been very public in documenting the process creating it, and which is centered around such concepts. There is some unofficial documentation of the ideas on SoA vs AoS and how the language can help switching between the two, e.g. here: https://pixeldroid.com/jailang/overview/Features/SOA/#/overv... and here: https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md...

Isn't that still the very thing that is done in various game engine entity component systems? Interestingly Jai language has out of box syntactic support for handling structs of arrays vs arrays of structs https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md#data-oriented-structures

I can't recommend any particular project that implements something in cuda, but I'd check out the StructArrays.jl[0] project.

One of julia's strengths is it's macro and type system. StructArrays.jl uses them to create a SoA struct out of a AoS. This is a killer feature that generally requires some form of code generation in C/C++.

Even if you're just doing something on the cpu, it should set you up to be both simd & gpu friendly. They have a guide on how to swap out the underlying array storage from cpu to gpu memory

fwiw, cuda is a "Tier 1" supported architecture[1], where "Tier 1" is defined as

> Tier 1: Julia is guaranteed to build from source and pass all tests on these platforms when built with the default options. Official binaries are always available and CI is run on every commit to ensure support is actively maintained.

[0] https://github.com/JuliaArrays/StructArrays.jl

[1] https://julialang.org/downloads/#supported_platforms

Julia has a package that provides incredibility easy to use SoA. https://github.com/JuliaArrays/StructArrays.jl Julia's metaprogramming and multiple dispatch mean that it can use user structs fully transparently. Everything just works.

You can use https://github.com/JuliaArrays/StructArrays.jl It's a decent choice when you need ease of manipulation and type stability.