via the magic of laion_clap embeddings and umap, my live coding thingy has a sample browser at last!

What if Doom's "colormap" was computed in Oklab instead of RGB? A short article about it on my site: 30fps.net/pages/doom-o...

Silent Hill 4 uses interesting volumetric light / light glare approximation. Instead of drawing sprites at each light source, full-screen subdivided plane with procedural vertex colors is rendered and blended with game frame. #gamedev

Relatable😑 From: doomwiki.org/wiki/Carmack... The line in question: github.com/linguica/dmu...

A new article: Why CIELAB doesn’t improve median cut It's a common misconception that CIELAB will instantly improve palettes produced by the median cut algorithm. Unfortunately it's not that simple. 📜 30fps.net/pages/median... It gets pretty technical but I added some context to the intro.

Wow I didn't know Python has cute chained comparisons: "e.g., x < y <= z is equivalent to x < y and y <= z, except that y is evaluated only once (but in both cases z is not evaluated at all when x < y is found to be false)." docs.python.org/3/reference/...

A fun look into Source 2's precomputed visibility from a mapper's perspective: www.youtube.com/watch?v=XLT2... It's not a BSP anymore but an octree whose nodes get grouped into clusters. Spoiler: Visleaks can still happen😀

A cool collection of monitor and sensor filter subpixel patterns geometrian.com/resources/su...

New article on my site: Better sRGB to greyscale conversion The commonly used greyscale formula is slightly off when computed in gamma space but can it be fixed? 📜 30fps.net/pages/better...

My new visualization for color quantization algorithm execution, though still unfinished. Attached is the result for a simple 12-color median cut. Each box contains a subset of image colors with the X-axis as a chosen sort axis; Y is PCA for plotting. See how e.g. box 3 has unwanted greens in it.

New blog post! In "Billions of triangles in minutes" we'll walk through hierarchical cluster level of detail generation of, well, billions of triangles in minutes. Reposts welcome! zeux.io/2025/09/30/b...

I wrote a simple box collision resolution code today and made the classic mistake of not checking if box_a != box_b before testing for overlap. This was the bug that made me post my first programming question online 20 years ago or so! I was unaware of the <> Basic "not equals" operator at the time.

Tried to be clever with some NumPy array partitioning code and exchange two values with the "x[i], x[j] = x[j], x[i]" idiom. Nope: got to use "x[[i,j]] = x[[j, i]]" instead, see stackoverflow.com/a/47951813

A neat little paper from 2006 "A Median Cut Algorithm for Light Probe Sampling" where an environment map is compressed to a set of point lights using the median cut algorithm. Seems like a precursor to another 2007 paper where others cast the task as density estimation.

Got my flight sim taking keyboard input and using that to drive the aerodynamic control surfaces. One step closer to take-off! #gamedev #flightsim #physics 🛩️

N64brew user @boxingbruin.bsky.social continues to showcase more work that they've done for their Pickle64 project, their action-RPG platformer hybrid with dark souls-like boss fights.

There's a classic color transfer technique from 2001: convert source and target image to a decorrelated color space (Oklab works fine), make target's mean and stddev match the source, convert back to RGB. Using a palette image as a target is no problem :) Paper: home.cis.rit.edu/~cnspci/refe...

A short article on mapping pixel colors to the PICO-8 palette in the CAM16-UCS color space. Surprisingly, it didn't do much better than Oklab, which is derived from CAM16. 📜 30fps.net/pages/percep...

Got familiar with NumPy's structured arrays today. It's basically an Array Of Structs, where fields can of course be different types. Could be useful with binary files, but I used it to organize code. Adding a "record array" allows a nice `colors.r` access syntax. numpy.org/doc/stable/u...

Some fun with shader-based debug drawing: here I'm drawing an arrow for each path taken in the path tracer, starting with the pixel under the mouse cursor.

I finally added alpha support to VariQuant. It took a lot of head-scratching to make it work with both RGB and L*a*b*😅 I premultiply the alpha and handle it like the other color channels. For RGBA color distance I'm using Kornel Lesiński's clever formula: stackoverflow.com/a/8796867

Gamma correction seems to be one of those things where the more you read the less you know. Is it really true that the NTSC standard assumes a CRT gamma of 2.5 but encoding is done with 1/2.2 instead to add a little contrast boost? From Charles Poynton's 2002 article at poynton.ca/notes/colour...

I've been improving my "VariQuant" color quantization tool. It now supports more color spaces, locally optimal cuts that guarantee the next color cluster split is the one that gives greatest decrease in error, luminance weight scaling, HyAB distance, A/B toggle, and palettes can be saved as PNGs :)

meshoptimizer v0.25 is out! Featuring new simplification function that optimizes positions and attributes for appearance, experimental permissive mode to simplify faceted regions with selective seam preservation, regularization option for improved tessellation quality and deformation, multiple ...

I was studying the "XYB" color space today. It uses a cube root for gamma correction but instead of a linear "toe" like in sRGB, there's a bias in the inputs that gets subtracted afterwards. Should be simpler to compute. I was surprised how the curve doesn't reach 1.0 at the end!

Godot may get approximate specular light from baked directional lightmaps, which is huge github.com/godotengine/...

It's pretty cool how if you have a small number of samples and know their type of distribution, the standard deviation is better estimated using their range rather than via population standard deviation.

I've been improving my experimental color quantization tool. It now supports separate palette design and pixel mapping color spaces with their own lightness weights. I added that palette visualization today and it's fun to play around the parameters and see it evolve.

I wrote earlier of a PCA approximation which worked surprisingly well. After some discussions, I now finally have a clear counter example where it fails. If the channels are uncorrelated, the result is an average that's clearly wrong. Updated the article: 30fps.net/pages/approx...

Apparently in Python's dataclasses any member not set via the constructor gets ignored in equality checks. Both asserts pass in the code included code snippet. I put this example to a gist of it so I can reference it in the future: gist.github.com/pekkavaa/4a1...

I'm trying to keep compile times under control in my N64 renderer, so I opted for writing a couple simple STL types (e.g. vector) myself. Since in C++17 the STL headers have gotten quite big, I had extracted only the necessary parts, such as std::forward, to make it work. But GLIBC is of course GPL!

I open sourced a little C library for GDB file access. It's meant for N64 homebrew running in an emulator: github.com/pekkavaa/gdb... The main contribution here is perhaps the hooking Python script that works in old and partially-installed versions of GDB without its bundled Python helper modules.

Interesting to see how in the original "The Irradiance Volume" paper from 1998 they stored irradiance per discrete direction instead of smooth spherical harmonics. Makes sense of course, it's basically a cubemap.

A neat 3D example of fitting an oriented bounding box using the approximate first principal component method I wrote about. Note that in the bottom left corner there's a toggle button for comparing between the exact PCA (red) its approximation (green).

A new article on my site: Approximate first principal component It describes simple trick to estimate the direction of most spread of a bunch of points without running a full PCA. Includes my Python re-implementation and plots of some quick tests. 30fps.net/pages/approx...

I wanted to try using some experimental color quantization algorithms for a real project (on the N64) so I started working on a little GUI tool. Interactive parameter editing is already fun with that single color count slider😀 And tk's "Professional Motif Look" keeps expectations at the right level.

Oklab seems to work well for mapping pixels to palette colors. To make the task more fun (and difficult), I picked the PICO-8 color palette. "CAM16-UCS" is the very accurate, baseline perceptual color space, Oklab is an optimized version of it, and HyAB is L*a*b* with 2x absolute difference in L.

"Hallucinations on the future of real-time rendering", High Performance Graphics 2025 keynote: c0de517e.com/023_hpg.htm

I read that Xiolin Wu's 1991 (Wu91) color quantization works as a k-means initializer. It's box splitting but with a split plane that minimizes predicted total squared error after the split. I compared it to Variance Cut (VC) that always splits at mean. They are close but there's a clear difference.

I love how the PICO-8 has a separate 16-color "hidden palette" you can access by poking some simulated memory location and setting the highest bit of 8-bit color index to 1😃

Now here's the fanciest illustration of the L*a*b* color space I've ever seen😀 Not sure if it's actually helpful but I love how the outlines make it pop. Found it from the technical brief "Understanding CIE *L*a*b Colour Space" by Kydex Thermoplastics.

New article on my site: HyAB k-means for color quantization In which I try to improve color clustering with a different distance function. It's a simple technique in the end but it's pretty hard to evaluate if it's an improvement or not! 30fps.net/pages/hyab-k... github.com/pekkavaa/HyA...

An example why linear RGB is not great for color distances, even though it's the right choice when averaging. Here's a 16-color palette image computed via k-means in both sRGB and linear space. In sRGB, dark colors effectively get a higher, approx. perceptual weight. The linear result is unusable.

Any idea how many GigaRays/sec can you get with this?

A nice rundown by @zhamul.bsky.social on how to export a 3D scene from Unity to a format that can run on the PlayStation: zhamul.itch.io/sauna/devlog... I also took a peek how PSXSplashEdit computes its paletted textures. It's k-means (good) but with a very simple init and only 10 iterations.

An interesting take on half-edges on the wiki of Geogram library by @brunolevy01.bsky.social github.com/BrunoLevy/ge... Basically, saving, loading, copying, adding attributes, parallelization, and rendering are easier with incidence arrays. Creation and deletion of elements gets harder.

This documentation page on Blender's internal mesh data structure is really good: developer.blender.org/docs/feature... It has very thoughtful comparisons to half-edges. I stumbled upon it when researching mesh libraries for Python that support N-Gons. Perhaps I'll try reimplementing BMesh myself.

i set it up for full RGB support. i still really like the monochrome, but this does help make the parallax more readable.

I compared my implementation of Iterative Online K-Means Clustering to the author's C code (Amber Abernathy) and learned that they (a) used a Sobol sequence for random sampling, and (b) assigned each pixel to closest color at the end. Result: No more noise :)