One programming language "lane" that's still wide open is an native AOT compiled language with a high-performance, tracing, generational, moving GC. Imagine something like C# or C++ but safe and in which malloc is 5 CPU insns so you don't have to worry about allocating all the time.

These days most of my attempts to improve Bevy's 3D performance fail. This might seem disappointing, but actually in my experience this is a *good* thing! It indicates that the low-hanging fruit is largely gone and Bevy's 3D is getting increasingly close to optimal.

Doing mass edits to 3D scenes in glTF format from the command line using Nushell (since glTF is just JSON) is amazing.

I read a bunch of folks saying "I tried Nushell and went back to Bash" and I'm like, how on earth. I do so much simple data manipulation and automation in Nushell that going back to having to use sed/awk, or reaching for Python and writing 3× the code, feels miserable. Do others just… not do that?

After working with it for a couple of days, I can fairly confidently say Swift is such a beautiful disaster of a language, and I mean that in the nicest way possible

Can't believe it's 2026 and we're having to disable GPU occlusion culling on flagship Google phones due to driver bugs. Pretty ridiculous. github.com/bevyengine/b...

Vim digraphs are the most convenient general purpose IME I've seen. I wish they worked in all apps!

Bevy 0.19 is releasing soon, which means it's time for a blog post! jms55.github.io/posts/2026-0...

This mess is a stress test of Bevy 0.19 with 2,000,000 instances of 100,000 separate meshes. Runs at 60 FPS on my laptop. Each of the 2M mesh instances is a separate entity. There's no special "instanced mesh" component needed; the GPU driven rendering does all the batching automatically.

A graphical frontend to Nushell in which you can drag in commands to create pipelines might be, like, the ideal form of visual programming. It might even be not terrible on a phone for “I need to format this data real quick” throwaway stuff.

Been a while since I had a good old fashioned LL vs. LR vs. PEG debate (LR is the best, don't @ me)

Gone too long without saying this so to reiterate yet again: • Reference counting does not prevent GC pauses; you can deallocate a lot of objects at once • It is possible to write RC that cleans up cycles and as a user you should demand this • Most tracing GCs are bad and you should demand better

Maybe it's just me, but it feels like, more than any project I've worked on, the Discourse around Bevy is disproportionately just incorrect. Not sure if it's because: * Bevy moves so fast (aside from the editor); * Bevy is relatively niche; * Gamedev attracts a lot of confidently incorrect people

Often times when people say "oh, there's room for X and Y to coexist", that's just wishful thinking and either X or Y ends up totally displacing the other in the end. But regarding Go and Rust, that's actually ended up being true! Definitely a nice outcome.

Really excited about the performance benefits coming in Bevy for mega-worlds. With all my patches we're starting to be able to render millions of mesh instance entities with hundreds of thousands in view with just a handful of drawcalls.

🧵 I've been experimenting with caching the best lights in world space to improve NEE sampling. Inspired by ReGIR, MegaLights, and www.yiningkarlli.com/projects/cac....

hacked and adapted Bevy's existing atmosphere support in last night, re-enabled lighting, and made a few more tweaks. enjoy some sunsets #bevy

philpax@philpax.me · 6mo ago

extended weekend project: a completely standalone first-person Google Earth viewer with physics #bevy yes, you really can go anywhere

In my GPU clustering branch, which is making its way through review, Bevy 0.19 can render ~8,000 visible lights (of 100k total) at about 200 FPS on my laptop 4070. This also adds the infrastructure for particle systems to emit lights entirely from GPU without any CPU involvement at all.

I'm taking no position on the technical merits of Godot here, but I will say that this is the exact kind of thing people used to say about GCC right up until it and LLVM killed all the other compilers because they couldn't keep up.

Landed light probe falloff and blending in Bevy 0.19: github.com/bevyengine/b... Along with parallax correction, I think that's the last of the features that are needed to make light probes really usable. Still would be nice to have in-engine baking, of course.

Implement gradual falloff and blending for light probes. by pcwalton · Pull Request #22610 · bevyengine/bevy

Currently, if a fragment overlaps multiple reflection probes and/or irradiance volumes, Bevy arbitrarily chooses one to provide diffuse and/or specular light. This is unsightly. The standard approa...

github.com

TIL about Autoconf quadrigraphs and I'm screaming

My fork of Bevy Hanabi, Hanabi-Batched, has been updated to support 0.18 and has many more improvements, such as lookup textures, PBR particles, and GPU mergesort for ribbons: github.com/pcwalton/bev... If you're looking for a way to use Hanabi on 0.18, feel free to grab it!

GitHub - pcwalton/bevy_hanabi: A fork of Bevy Hanabi, the GPU-driven VFX system for Bevy, with improved performance and functionality

A fork of Bevy Hanabi, the GPU-driven VFX system for Bevy, with improved performance and functionality - pcwalton/bevy_hanabi

github.com

Bevy 0.18 is out! My main contribution to this one was portals and mirrors: github.com/bevyengine/b...

Implement the infrastructure needed to support portals and mirrors. by pcwalton · Pull Request #13797 · bevyengine/bevy

Implement the infrastructure needed to support portals and mirrors. Bevy currently supports multiple cameras and rendering to off-screen render targets, so one might naïvely think that the engine h...

github.com

Bevy@bevy.org · 7mo ago

Bevy 0.18 is out now! It features Atmosphere Occlusion and PBR Shading, Generalized Atmospheric Scattering Media, Solari features, PBR Fixes, Font Variations, Automatic Directional Navigation, Fullscreen Materials, Cargo Feature Collections, Camera Controllers, and more! bevy.org/news/bevy-0-...

Strangest issue I've encountered in the wild when fuzzing: `vaddps xmm0,xmm0,xmm1` and `vaddps xmm0,xmm1,xmm0` are *not* the same on x86 when it comes to which NaN payload it chooses. But LLVM will reorder the arguments anyway! Lesson learned: always canonicalize your NaNs when fuzzing.

16 different versions of glam in my Bevy project. The ecosystem *might* want to improve this a bit :)

I dusted off an old patch and landed the infrastructure for portals and mirrors in Bevy for 0.18: github.com/bevyengine/bevy/pull/13797 This builds the Lengyel oblique clip plane technique into the engine, which is the fastest way to do the clipping necessary for mirrors to work.

Landed normal maps, metallic/roughness maps, and emissive maps for clustered decals in Bevy 0.18: github.com/bevyengine/b... They compose with other decals and whatever maps are on the base material, if any. Additionally, in a custom shader you can use these textures for whatever you want.

After nine years of development, meshoptimizer has reached its first major version, 1.0! This release focuses on improvements in clusterization and simplification as well as stabilization. Here's a release announcement with more details on past, present and future; please RT! meshoptimizer.org/v1

"Analyzing the Performance of WebAssembly vs. Native Code" places a lot of the blame for the worse performance of wasm on register spills, esp. with JS engines' reserved registers. Sounds like APX could actually help by bumping the register count from 16 to 32? ar5iv.labs.arxiv.org/html/1901.09...

Not So Fast: Analyzing the Performance of WebAssembly vs. Native Code

All major web browsers now support WebAssembly, a low-level bytecode intended to serve as a compilation target for code written in languages like C and C++. A key goal of WebAssembly is performance pa...

ar5iv.labs.arxiv.org

Seriously considering putting a bounty on x86-64 support for copy.sh/v86: github.com/copy/v86/iss... A proper modern JITting emulator on the Web platform (including non-jailbroken iOS) would be amazing! I'm amazed how fast the jitcode can be, even with softmmu.