Gemini* and Gopher

• Personal/Opinions

  • No News Not Fit To Consume

    These are fair goals, but could be bent or twisted by an organization: the popular feeling echoed might be distrust or hate, sentiments raised for the death of others, and the defects exposed actually virtues in their own holy books. Help the poor, the downtrodden? God forbid! That there is woke.

• Technology and Free Software

  • tarocchi 23 and y handmade shadowplay

    i picked these two for january because they're both pale and calm, like the winter. the tarocchi is a bit brighter, with pops of pink and turquoise, so it's not all drab. the shadowplay is a bit more neutral in tone.

  • Starting Assembloids on the Alice Matra

    Assembloids for Alice 4K is one of those projects that makes immediate sense to me even if it is not the most practical thing in the world. The machine is small, the graphics are restrictive, the memory budget is tight, and that is precisely why it is attractive.

    The Alice is not a machine where one casually throws pixels around and cleans things up later. Every choice shows. Layout and data structures become essential. The way a tile is encoded matters. The whole project becomes an exercise in respecting the machine instead of trying to overpower it.

  • Internet/Gemini

    • Mastodon in the Terminal

      As I transitioned from a decently powerful x86-64 gaming machine to a RPi 3B+ to use as a daily driver, I lost some of my slacking habits. It's actually a good thing but sometimes I also wish I could post on Mastodon, typically. So I installed tut - a TUI mastodon client - and gave it a try.

• Programming

  • a voxel engine, part 2: making the math cheaper

    The reference version of this renderer is mathematically clean. It uses floating point, recomputes values per sample, and does not worry too much about where the time goes.

    That is a good place to start, but not a good place to stay.

    On constrained hardware, the question is not whether something works, but whether it works cheaply enough. And in this algorithm, the cost is dominated by one thing: stepping through the map and projecting heights for every column and every distance layer.

  • a voxel engine, part 3: reducing resolution on purpose

    This is the target platform.

    A small device with a 1-bit display and limited resolution. No grayscale, no soft transitions. Everything has to work within that.

    Instead of trying to approximate a higher resolution image, I reduce the problem to something that fits the display.

    The renderer already works column by column. From there it is a small step to operate on larger blocks instead of individual pixels. Effectively, the resolution is reduced by a factor of two in each direction.

  • a voxel engine, part 4: making depth visible

    The basic renderer does not store depth. It draws the terrain front to back and keeps track of the highest pixel per column. Everything behind that is skipped. For a heightmap, this is usually enough.

    The problem appears once the renderer is no longer strictly uniform. To stay fast, it advances in depth spans. Parts of the map are skipped, others sampled more densely. As a result, there is no strict relation between a screen position and a single world position anymore.

  • a voxel engine, part 5: water without simulation

    The terrain is not just land. It also contains water. Islands need coastlines, valleys suggest rivers, and once those are present, structures like dams become relevant.

    A full simulation would require additional data and a different update model. Instead, water is part of the existing map, defined by color. There is no separate structure and no global sea level.

  • a voxel engine, part 6: shaping memory access

    The renderer spends most of its time reading the map. Not computing, not drawing, but fetching data. On this platform, RAM access is slow enough that layout matters more than arithmetic.

    A simple 256×256 map already shows this. Access in one direction is much faster than in the other. Sequential reads follow the layout and stay in cache. The other direction effectively jumps with a stride of 256 bytes. The difference is large, close to a factor of two.