Btw I believe we have a mostly wrong framing of what could be done in Europe. Italy's Leonardo supercomputer datacenter alone plus Swiss National Supercomputing Centre has more than enough compute to train a very large LLM. It's not something impossible, also there is not magic recipe: it's just scaling, every smart team with the GPUs is doing it. People that fatally believe it is not something within reach are wrong.

What Europe should do right now: 1. Call all the European researchers working on AI and return them back with same salary (or they can stay but switch career). 2. Fill EU places having GPUs with money, and put those people there. 3. AI partnerships with China India.

Yes and no. If you combine high level nodes in a visual nodal tool to create behaviour you may not understand the details but you still create logic/behaviour. Better is to understand in depth but let’s not have a too narrow view on programming.

It’s not solved. For small apps where you don’t care what happens under the core in terms of performance, architecture etc it works indeed. For professional more complex projects you better stay in control if every single line (review it all).

New recording and replay feature added to Box2D. Uses determinism to exactly reproduce the simulation from your game. Debug your game with all details including ray casts and other queries. Deterministic rollback too. box2d.org/posts/2026/06/repl…

If you are doing something where technical quality matters, you need to be doing the architecture yourself and reviewing LLM code yourself. LLMs tend to slowly cripple the architecture with various hacks and then start copying those hacks. Human senior expert needs to design the architecture and verify that subtle issues don't cripple the architecture. Otherwise it's a slippery slope. Codebase will end up being a huge mess. LLM loops are nice for iterative profiling/optimization. Nothing beats measuring. LLMs have lots of false beliefs like humans do. The problem is that LLMs are super bad at optimizing GPU SIMD code. Not enough training data. Same for data access patterns (cache utilization). Idiomatic C in github is horrible for performance. Real-time systems/engines programming doesn't have as much training data. You have to hand-hold LLM quite a bit to get acceptable results. If the runs smoothly on your $5000 MacBook, that's not good. Needs to be 100x faster to scale to average mobile devices.

THAT is the weird choice. Unity could totally hire folks to work on its C# runtime and make it faster, and they don't. At this point I am obligated to plug my il2cpp improver kerntief.net/cpp2better.html but there is so much more that could be done if I had access to il2cpp itself.

We’ve released the official Blender add-on for ZOZO’s Contact Solver, our open-source physics solver developed at ZOZO, Inc. Blender users, please take a look! github.com/st-tech/ppf-conta…

👀 dgtlgrove.com/t/ui

Super slow indeed.

Are you looking for github.com/agavra/tuicr?

David Fowler is my spirit animal.

This Netflix 2026 perspective on Java's GC is impressive. They say that the full adoption of low-latency GC via ZGC initially raised concerns about CPU resource consumption, but as a result of the rollout, it brought dramatic improvements across the entire system. A similar GC adoption is urgently needed in .NET as well. I want the runtime team to focus on and invest in Satori GC. youtube.com/watch?v=ucJTPda_…

A lot of small personal solutions is going to be the first big difference. larger projects still challenging

I have 100x more half finished side projects as I had before

I think @antirez ds4.c is important! I wrote down my thoughts on why I built pi-ds4 and why we need to focus our local model efforts stronger than we do currently. lucumr.pocoo.org/2026/5/8/lo…

One thing game devs should learn is ABS: Always Be Shipping. I learned that working with @notch As Mojang grew and new coders joined the team, there were complaints about old code/shortcuts/“bad” technical decisions. My response was usually: without those decisions, none of us would be here. There probably wouldn’t even be a Minecraft if everything had been done the “correct” way from the start. Games are explorative. You build, test, cut, rewrite, hack things together, and keep moving. A shipped imperfect system beats a perfect system that never makes it into players’ hands. I’ve never worked on a game where you didn’t have to go back and touch old code/systems later anyway.

I've built a full LLM inference engine in C#/.NET 10. From scratch. Not a wrapper - native GGUF loading, BPE tokenizer, attention, KV-cache, SIMD-vectorized CPU kernels, CUDA GPU backend, OpenAI-compatible API. Solo dev, ~2 months, AI-assisted (not vibe-coded!). First preview is out. Check it out for mode details at kokosa.dev/blog/2026/dotllm/ and dotllm.dev/

DBG: redknightlois.github.io/dbg/ GPU DBG: redknightlois.github.io/dbg/… Source: github.com/redknightlois/dbg