Von Neumann's elephant: > With four parameters I can fit an elephant, and with five I can make him wiggle his trunk. Extrapolate to 2026 and with 1 trillion parameters you can effectively answer any question in the world and solve almost any problem.

Claude Opus 4.6 made a big change in how the "thinking" is configured and controlled, and a lot of people are seeing it being really greedy with tokens across the board, some times filling the entire context (and making it impossible to use on a Pro sub) with very few prompts.

I made a map of 3.4 million Bluesky users - see if you can find yourself! bluesky-map.theo.io I've seen some similar projects, but IMO this seems to better capture some of the fine-grained detail

A colleague sent me this: www.youtube.com/watch?v=8jVo... No further comments needed, it's **very** good. I've seen some of his videos in the past, but I missed this one. Glad I saw it.

Working on documenting frustum grids, rebuilding it piece by piece with Claude based on an earlier version that unfortunately got mangled by overly aggressive self-review: gist.github.com/vassvik/1ed6... Still quite a bit missing, but getting there

One example that I explored today: Spherically distorted Frustum Grids gist.github.com/vassvik/6a14... In the end it requires a bit of effort to get the documents sufficiently fully fleshed, but you can ask it to review itself, to various degrees of thoroughness, which works quite nicely.

Spent about a week with Claude Code (Opus 4.5) now. Still sort of skeptical of any tangible benefits to its coding capabilities for any of the production work I do, but I have found some things that seem to work really nicely: Exploration, testing and analysis.

Short conclusion of this Weekend project using Claude Code: It currently feels like it's going to be more like this for the majority of people for at least the nearest future, butchering the lovely graphic from @mjwhansen.com:

Played around a bit more with it today. Most of yesterday's wow factor is gone, and it's been almost a uniquely frustrating experience. Almost everything I tell it gets done wrong, and it keeps fumbling, and the lack of visual debugging is really frustrating

Spent some time today finally trying Claude Code (Opus 4.5). Tried to task it to make a simple 2D Stable Fluids implementation from scratch, which it truly fumbled no matter what suggestions I made to improve it. There should be lots of examples in its training data, so that was a but disappointing

Current progress on my Bitonic sort obsession, compared against GPUSorting's OneSweep implementation (github.com/b0nes164/GPU...) as a reference 32-bit keys only. Tried to pick the best tuning parameters for the OneSweep reference to steelman the comparison On my Blackwell Pro 5000 Mobile laptop

I just released my video about the engine (and game) I've been working on. The engine is based on dynamic SDFs, and the video describes how it works and what it makes possible. Link in the reply! This is my first YouTube video and it took forever - please repost!

Introduction. Since 2014 I've been using Excel to create math art. Post-processing in Krita.

Found an interesting paper with an unexpected twist www.semanticscholar.org/paper/On-the...

"Welcome to the CUDA Core Compute Libraries (CCCL) where our mission is to make CUDA more delightful." I've never been more upset than trying (and failing) to get one of the CUB examples to build Massive failure of a trillion dollar company simply where it's a pain and a chore to use their thing

Have recently been obsessed with (again) optimizing my "low-mid size" bitonic GPU sorter even more than it was. The current state summerized in the images below for a 7900 XTX for the red team and a 4090 for the green team. For once the former handedly beats the latter across the board!

Nobody: Me: I'm very proud of this 1µs optimization, it was definitely worth it to spend a day on it.

-- JOB SEARCH POST/RT APPRECIATED -- Hello everyone! I am available for work (full time position/internship) anywhere in the world with priority going to the EU, starting June 2026. 🧵

Ever seen one of these, and wondered *why* they work? 🧵 This is a so-called Bitonic sorting network, and the illustrations show the two common ways to implement them. From an implementation point of view the two methods are effectively the same, so which one you pick just comes down to preference.

Manually writing simple svg files for making illustrations turns out to be surprisingly simple and neat. Getting motivated to do a full deep dive into Bitonic sorting networks and how to use them well on the GPU now. Maybe it'll happen over the christmas holidays.

test

It's roughly 4 years since I started to work on the 3D sparse fluid solver for what will ultimately become EmberGen 2.0. A quick look at the current performance state of the solver. A previous retrospective thread from a couple years ago on that other place: x.com/vassvik/stat...

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

Final version for the 2D Morton decode functions. Fairly happy with the structure in general. A 64-bit version should be easy enough to produce, by just using the 32-bit version twice and combining the results.

I can't really recall the last time I actually read a paper/article for the sake of learning something, or for staying up to date, and I can barely muster the motivatation to skim new research papers even on topics I genuinely like. Anything that isn't explicitly "mine" is really hard to focus on

I've settled on using a simple utility that wraps D3D's SetStablePowerState to stabilize GPU clock rate when profiling using in-app timers. This simple program does the trick: github.com/milkru/gpu_c... This should even work when profiling, e.g., WebGPU apps in browser! [cont]

Some random Morton Code tricks: If you've worked with Morton codes you've probably seen something like the this GLSL code to decode a Morton code, which end up at roughly 27 integer operations to generate the equivalent 2D position. Code transcribed from fgiesen.wordpress.com/2009/12/13/d...

New laptop arrived. Curse of awful laptops broken?

New blog post! Behind the scenes of some of the techniques involved in making our last PC demo 💫 gboisse.github.io/posts/this-i...

I feel like I need to split up my blackboard scribbles/notes for #half-edge into multiple files bc it's quite a lot to deal with an 8000x14000 px document lol

Ray marching is a common approach to GPU-accelerated volume rendering, but gives biased transmittance estimates. My new #SIGGRAPHAsia paper (+code) proposes an amazingly simple formula to eliminate this bias almost completely without using more samples. momentsingraphics.de/SiggraphAsia...

Finished documenting work on optimized wireframe rendering: precision, clipping & math details for stable, performant edges in OpenGL. Includes an analysis of NVIDIA’s wireframe paper & fixes its issues. fauder.github.io/posts/2025/1... #GraphicsProgramming #Rendering #OpenGL #ShaderDev #GameDev

How do ye vote?

Combustion tests with the new ground, 640M active voxels

Spent some time trying to do conservative culling of geometry for distance function evaluation. Turns out I ended up reinventing something like GJK (which I really have no clue about or experience with) with exact bounds.

Fixed a bug and tried beefing up the voxel count: 1.275B active voxels, 3072x3136x1312 bounding box. Realtime capture in the viewport on 4090. The projection struggles a bit on this scale, so I brute forced it a bit, so it's a bit slower than it has to be. FMG to initialize should help a lot here.

Finally adding ground collisions

Extended my topology libs to work on non-Euclidean domains (spherical, toroidal, etc.) by turning mesh edges into geodesics. Below: Bridson's Poisson disk sampling across different domains. #indiedev #gamedev #computergraphics #computationalgeometry #topology

Some progress on the VAT export in #illugen. Complex mesh animations can be imported in game engines ... (made with an internal build) #VFXFriday #realtimevfx #vfx

Some tests I did with hacking in mixbox (github.com/scrtwpns/mix...) support today Left: RGB blending Right: Mixbox blending Interestingly I there's a lot to take from this for smoke scattering, which generally has an absorption component, so subtractive color mixing makes sense I think?

Singly linked lists? Doubly linked lists? On the GPU? I use 27-way linked lists on the GPU, and it's good and highly appropriate!

🤔🫣🫠

Tickets are up! graphicsprogrammingconference.com/tickets/

Frustum Grids Primer Part 2: This time instead of having a fixed depth-slice count (which is common for games for a variety of reasons) we'll instead focus on trying to maintain a uniform and non-elongated froxel shapes, which results a variable slice count www.desmos.com/geometry/yl5...

Working on a small primer on frustum grids. The most common approach is to distribute the depth-slices in an "exponential" manner between a near and far plane, which is probably more appropriately named "geometric" since it relies on a geometric progression. www.desmos.com/geometry/qd1...

I had a student who did my university raytracing course in Odin, now they've sent me an image made by their raytracer and I'm dying

Today I was reminded of a cool fact that at first glance looks decidedly bizarre. Midpoint quadrature — split your interval into n equal subintervals, add up the (smooth!) integrand evaluated at the midpoints and multiply by the width of a subinterval — is of course only second order accurate, 🧵

Random @desmos.com doodle on frustum side-plane inside-out testing: www.desmos.com/geometry/8l6... Uses direct references to objects in the viewport (which are visually disambiguated using colors), and dynamically coloring the test point based on whether it's inside or outside the frustum

Post-Siggraph inspiration: Working out the math of frustum grids is fun