Hey guys,

Just thought I'd share what I have been working on, and catching the AI Slipping up in an unscripted event.

So proud of the logic of all the cars dynamically adjusting to the event.

Still some work to do on the wakes, but the dynamic weather is doing its job. I recreated Monza in the editor in game, exact 5.9km somehow got it right. Won't be included in the game due to licensing, but free to remake any tracks of your choosing with the in game editor, can change the terrain height to recreate the right elevation.

Oh and for the Sim enthusiasts. we now have wheel and pedal support with force feedback.

The 16th International Conference on Artificial Intelligence in Music, Sound, Art and Design (EvoMusArt 2027) is accepting paper submissions.

When: 31 March – 2 April 2027
Where: Mainz, Germany
Paper Submission deadline: 1 November 2026

EvoMUSART focuses on AI and computational approaches to creativity, covering a broad range of topics, with a particular emphasis on research exploring how AI systems generate, support, evaluate, interpret, and collaborate in creative processes.

Accepted papers will be presented at the conference and published in a dedicated LNCS volume.

More information/submission details: https://www.evostar.org/2027/evomusart/

If you are working at the intersection of AI and creative practice, this may be relevant to your research. Please share with others who might be interested.

This one uses a bunch of inspirations from Madhubani, Bhil, Gond, Kolam and Warli, a bunch of Indian folk art styles. The code is a variation of my procgen poster generator.

Velocity Zero is a seeded anti-gravity racer: type a circuit code and the game builds the entire race from it. There are 32 zones — 23 land themes with flats, canyon, ridge or cliff landforms, four planetary routes (orbit descent, globe tour, moon run), and five fractal worlds (Mandelbulb, pyramid, Mandelbox, sponge, Kleinian). The same seed always yields the same zone, track shape, surfaces, hazards and rival field, so codes are shareable levels.


Circuits start as a warped control-point ring, then gain 11–17 features: roads, half-pipes, full pipes, heal/slow/hazard strips, jumps, corkscrews, tunnels and loops. Connectors morph profile types cleanly. Deck materials (solid, glass, hex, circuit, prism) and a D–S grade finish the layout; A and S tracks hide a long tunnel gauntlet.


You race three laps against 11 AI ships, each rolled from 46 hull archetypes (~20% hybrids) with procedural paint, parts and stats. Energy is both hull and boost fuel — stack dash pads up to 3× speed, grab items (mine, missile, seeker, meteor, boost, warp), and stay on the ribbon or reset after three seconds off-track. Career mode starts at 10k credits: climb classes D→S, unlock shop grades, build custom hulls after ten wins, and enter cups whose last two rounds are always a planet and a fractal.

https://youtu.be/tb87BA0JUR0?si=5gNlvCCuSIeZd-7T

Each battle is generated from a seed: a bocage hamlet, open ridge farmland, a highway junction or a market town, each with its own weather. One in ten seeds has a tank. Battles are seed specific, so you can share a link to an exact fight.

Under the hood: separate RNG streams per system, an event log with a hash, and replay checking, so any run can be reproduced exactly.

Try a seed here!

I've been building a Rust + Vulkan game engine (Vulkano + winit). This is the Lorenz attractor with 1,000,000 particles that all start inside a cube 0.000001 wide.

How it works:
- Every particle follows the real Lorenz equations (sigma = 10, rho = 28, beta = 8/3).
- Plain f32 positions don't work here. Particles start about 1e-8 apart, but near the attractor one f32 step is about 2e-6, so a million particles collapse into a handful of points. Instead the CPU integrates one reference path in f64, and a GPU shader integrates each particle's tiny offset from it with RK4 (h = 0.005), using the exact difference f(r + d) - f(r).
- Color comes from each particle's starting position, so you can watch neighbors get pulled onto opposite wings. The two circled at the end started side by side.
- There are no interactions between particles, so the cost grows linearly with the count.

It's not real time: live it runs at 9 FPS with 1M particles on an RTX 3060. Most of the frame goes to per-entity CPU work in the engine, which is what I'm optimizing next. The video was rendered offscreen at 4K, and the camera zoom is scripted to follow the spread.

Source: lorenz_butterfly.rs (src/examples/lorenz_butterfly.rs)

Run it: cargo run --release --features window --example lorenz_butterfly -- --side 100

Hi there, here is a side project in C#/Raylib to create some planets with my own renderer.

I use spherical (equirectangular) flat map of the surface made by one of my curated terrain distributions (3d Perlin noise). And finally a well-chosen palette of 10-16 handpicked colors with a mix of stochastic and dither rendering.
For each frame, the sprite pixels sample the corresponding part of the map, with a rotation on each frame to make it spin.
I really like the result of these retro chunky pixels !