Applying Floyd-Steinberg dithering (with serpentine scan order) to constant grey images creates interesting artifacts. Inspired by a 2001 paper by Victor Ostromoukhov who brute forced optimal weights for each level based in a similar experiment. The paper: perso.liris.cnrs.fr/victor.ostro...

New article: Single-pass palette refinement and ordered dithering 30fps.net/pages/bayer-... It's a method that modifies the online k-means algorithm to produce an ordered dithering pattern as a side effect. The result is closer to pleasant glitch aesthetics than a proper dithering replacement.

The "popularity" color quantizer is one of the simplest: find the K most used unique colors in the image. That's the palette. I was surprised how well it works when K=256 and the image is reduced to 4-bits per channel before. Even transparencies look kinda OK.

I will not continue to work on this so I might just share the URL. I just wanted to pack everything about a palette onto one view: palettarium.color.pizza

Came across this handy matrix of accurate but integer-only bit depth conversion formulas: threadlocalmutex.com?p=48

A cool plot from "A Simple and Efficient Error-Diffusion Algorithm" by Victor Ostromoukhov, 2001. They show how the classic Floyd-Steinberg error diffusion can't always produce a pattern with the blue noise (no clumping) property. Paper: perso.liris.cnrs.fr/victor.ostro...

Always a delight to see science being done on a 2 MHz 6502. From "On the Statistical Analysis of Dirty Pictures" by Julian Besag, 1986.

Why not blend gradually between ordered dither (top) and error diffusion (bottom)? Such a cool idea. Example image by Viktor Massalogin github.com/bntre/dither...

I researched Google's squoosh.app image compression tool's palette code and it's a vendored copy of libimagequant, but what's more interesting is that the code also supports ZX Spectrum color limits! github.com/GoogleChrome...

New blog post: A Decade of Slug This talks about the evolution of the Slug font rendering algorithm, and it includes an exciting announcement: The patent has been dedicated to the public domain. terathon.com/blog/decade-...

I tried using an octree for color quantization with the help of a 1996 Dr Dobbs article: jacobfilipp.com/DrDobbs/arti... It was quite a hassle, doesn't work that well (at least my version), and isn't as fast as I expected. On the right: sklearn's bottom-up clustering for comparison.

more early counter strike vibes

The N64brew Game Jam #6 has come to an end, and we've had a total of 28 submissions this year! Our judge team is currently deliberating over each entry to decide which team will pick the charity to send the $3300+ donations we've received. While we wait, let's look through every entry! 🧵

The topic of raycasting on MSX has come up. A while ago I made a renderer for MSX 1 which looks like a raycaster (so-called backwards projection) but in fact it's a rasterizer (forward projection). This reduces the per-column cost significantly. Doom worked this way. www.youtube.com/watch?v=8l52...

All the work put in by the N64 homebrew and ROM hacking communities are starting to bear fruit :) In the past years there has been a steady improvement in hardware documentation, SDKs, emulators, Blender addons, and 3D graphics libraries (OpenGL and Tiny3D for libdragon, F3DEX3 for libultra).

A cool trick to clean up error diffusion dithering: if the per-pixel accumulated error goes over a certain threshold, dampen it by a factor of 0.8. This suppresses bright, sparse pixels. Found this in libimagequant's code.

I tried imitating GIMP's "reduced color bleed" addition to Floyd-Steinberg dithering and it works! Maximum error offset allowed for a pixel gets clamped with a tanh-like function, hiding individual high-contrast pixels in solid regions. The clamping function is shown in green in the attached plot.

My first Floyd-Steinberg dithering routine! Still looks a bit broken. I've understood dithering should be done in the linear color space of the display device but with big pixels maybe that's not the best idea. At least the first bird Really Pops. The third was the first 2x2 matrix test.

I discovered something interesting in the MSX2 version of Pac-Mania. The game has an isometric perspective just like the arcade original, but it first loads the background with an orthogonal perspective and then applies a shear effect to it in VRAM. The original simply loads pre-sheared tiles. #msx

Awesome writeup on the power of pre-splitting for producing high-quality BVHs: github.com/BoyBaykiller... One interesting quote: "You may notice PreSplitting improves performance but increases the SAH cost. SAH is not a perfect predictor of performance."

I'm starting to get attached to these fast & loose diagram sketches I'm doing for my book. But redrawing them as clean vector art allows easier editing so it's worth the trouble.

Here's a little project I've been working on: Liero64 - a port of the 1998 MS-DOS game for the Nintendo 64. Gameplay video: youtu.be/aemLngAjEi8 ROM: codeberg.org/pekkavaa/Lie...

screenshots of the startmap I built for qbj3 or Quake Brutalist Jam III some fancy bits in here will be in the coming update, like the paintings and plaques

A comparison of the Pillow library's Maximum Coverage color quantizer settings. A palette that works well for dithering may not look great on its own. Here the top result has garish colors but when it's used when dithering (second from top), it's actually quite OK.

Built a palette extractor that thinks like a curator, not a pixel counter. – Physics-based color repulsion – Auto-detects muted vs vibrant bias – Adaptive spacing to hit target count – OKLCh color space (perceptually uniform) Early Access: please break it! chipper-otter-d6c600.netlify.app

Some of you might know that I've been working on a book. Today I'm happy to announce Palette Programming: A Modern Guide to Color Quantization paletteprogramming.com It's a textbook on how to design palettes and represent images using them. Will be out this year. Code in Python & NumPy.

a couple 3D aabb tricks: gpfault.net/posts/aabb-t...

Ecstatica II (1997) Developed by Andrew Spencer Studios.

I've been reading up on k-means clustering again. I learned that scikit-learn's default "k-means++" init is actually "greedy": it does multiple attempts when randomly picking the next center to add. And the default value for the number of tries is based on an offhand remark in the original paper.

I tried to use premultiplied alpha on the Nintendo 64 but I don't think it's actually possible. The hw blending equation does an unfortunate rounding when mixing colors, adding some black even in fully transparent pixels. Left: Straight alpha, Right: My attempt at premultiplied alpha.

I was looking for how to make deleting files a tiny bit safer in shell scripts and found this subtly terrible StackOverflow answer. Consider the case where $SOMEPATH is empty and what does `cd` do then 🤠

I've been reading about color science for my book and I wanted to verify the claim that Oklab gives better linear gradients than the otherwise excellent "CAM16-UCS" color space. And yes, its gradient obviously too desaturated in this test. Oklab's ancestor "IPT" also works fine.

It's lovely when I see dedication to an experiment: keeping a CRT on for a month to avoid affecting its color reproduction. From Fritz Ebner's 1998 dissertation: repository.rit.edu/theses/2858/ The same hue matching experiment data was used by Björn Ottosson when creating the Oklab color space.

Here's an unexpectedly brilliant introduction to perceptual color spaces www.youtube.com/watch?v=nJlZ...

I recently translated my book manuscript (it's about palettes) to Typst and been pretty happy so far. Today instead of writing I procrastinated by moving code snippets' line numbers over the left margin to salvage three extra characters of horizontal space😃

The Wikipedia page on Color appearance models at en.wikipedia.org/wiki/Color_a... surprisingly good: to the point but still feels comprehensive. Includes a quick comparison of different perceptual color spaces.

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.