I've written my first blog about the register allocator in my compiler backend rat - you can read it here https://hexrat.cc/pages/blog/2026_10_07, any feedback is appreciated :)

I've just rewritten my original linear scan register allocator for my toy compiler rat. The new one is a custom-ish mix between a binpacking allocator and a linscan allocator. The original was about 1500LoC, and the one is only about 600 LoC, with slightly better perf, and its easier to understand :D. I'm thinking about writing a blog post about it as well, Current bench results (-O1):

Hey - I've been working on rat - my (gotta be like 4th :D) attempt at a Sea of Nodes compiler backend, this time I've also written a somewhat working c99 frontend for it (tested via gcc-torture, c-testsuite, and other test suites). I currently support -00 and -O1 opt levels, with -O1 being marginally slower than gcc -O1 on my benchmarks, but there is still a lot to do. The compiler itself is also decently fast, being about 8x faster than gcc from my testing, but again, I'd like to improve this further. You can check it out below :)

https://github.com/hexratcc/rat

Added support for basic collision pixels and non-square simulation boundaries

got some free time on my hands today, so I decided to make a lil' 2d fluid sim, and see just how fast I can make it - started out at 70fps, now I'm at ~2000fps, hopefully I can push it further

I've been writing a two-pass x64 assembler, which supports pretty much all x64 instructions, including various extensions.

It also supports simple things like labels (including out-of-order definitions), memory defines and reserves, and some other keywords.

https://github.com/Goubermouche/baremetal

I've Implemented the famous terminal donut sample in my custom compiled language written in LLVM. I've also implemented a simple AST visualizer.

I've been playing around with my little C-style toy language written in LLVM, and I just got to the part when I can actually get something simple working - here's a simple Mandelbrot fractal 😄 .

Finished my little GPU-based DFSPH toy
https://cdn.discordapp.com/attachments/782208694770597888/1083086840673861716/0234-0403.mp4

Started revamping my old SDF generator, today I finished making a fairly robust implementation of a CPU mesh-to-SDF converter, tomorrow I'll remake it on the GPU to hopefully speed up the generation quite a bit. (below is a sampled SDF of a simple torus)

Finished implementing a viscosity model into my simple fluid sim, right now it's pretty slowly (only running on the CPU), but I'll reimplement the entire thing in CUDA in a couple days (hopefully).

I can go to sleep at last.

Apologies for the horrible video quality from before, I'm still learning to use OBS 😄 .

I added a volume sampler to my basic GPU fluid sim. ⁓125fps on my GT 1030

Added volume sampling to my basic GPU fluid sim. ~128k particles @95fps on my GT 1030.

Finally got around to improving my fluid sim. I've recreated my older code in CUDA and created a basic engine for it. I've also drastically improved performance: previously I was getting around 45 FPS with 10k particles. Now I can simulate 64k particles at 250 FPS - and if I push it I can simulate 1m particles at 15 FPS on my poor GT 1030.

first pass on my basic realtime fluid simulator made with OpenCL, currently working on improving performance (right now I start dropping frames at ≈10 000 particles on my gt 1030). I'm hoping to get to atleast 80 000 particles at 60 FPS in my upcoming reworks

my implementation of A* pathfinding with weights (blue and brown tiles are water and mud respectively), the path gets updated if there is an obstruction in the way. Everything is running on a separate thread.

simple belt marching system