Well, Hell: The Iris Math Doesn't Work
Pixels appearing on screen is not the same thing as an architecture that scales to real high-resolution video editing. I found that out the hard way, and I was irritated about it for the rest of the night.
I want to get something out of the way before I write the rest of this entry: I was irritated. Not "disappointed, but it's all part of the process" irritated. Actually irritated. The kind where you stare at a terminal for longer than is useful because some part of you is hoping the numbers will change if you just keep looking at them.
Here's what happened. Early display work — the stuff that eventually got the working name Nu-Iris — got to the point where pixels were showing up on screen. Real pixels, from real framebuffer writes, through the pipeline I'd built. And for about a day, that felt like a genuine win.
Pixels appearing is not the same thing as "this works"
Then I actually sat down and did the math on what the intended display path would need to sustain for the kind of high-resolution video editing this whole project was supposed to be aimed at — remember, this traces back to the Video Toaster, to DigiPaint, to real media work, not just "can we draw a window."
I was irritated. The math showed the intended display path would not scale to the kind of high-resolution video editing being targeted.
I want to be careful here about a promise I made to myself for this journal: I'm not going to invent specific numbers I can't actually stand behind just to make this section feel more dramatic or more technical. The honest version is this: the bandwidth and resource-scaling pressure of real high-resolution video work, run through the assumptions the early display architecture had baked in, did not close. Not "tight, but workable." Did not close. The gap wasn't a rounding error I could optimize away with a better inner loop — it was structural, baked into decisions I'd made early about how the pipeline moved data around.
What assumptions were actually being tested
The core assumption under the microscope was something like: if the basic framebuffer path works for getting pixels on screen at all, then scaling it up to real editing workloads is a matter of degree, not a matter of kind. That assumption is exactly the kind of thing that feels true right up until you actually run the numbers, and then it very much does not feel true anymore.
"Pixels appeared" answers the question "does this pipeline function at all." It does not answer the question "does this work for a real high-resolution media workstation," and those are genuinely different questions wearing the same demo. I'd let the first one quietly stand in for the second one for longer than I should have, mostly because the first one felt so good to finally see working.
Why the architecture had to be reconsidered
Once the math didn't close, there wasn't a patch available — I couldn't just tune the existing pipeline harder. The scaling problem was upstream of any individual optimization I could make downstream. That meant going back to the display and media architecture itself, which is a genuinely bad feeling a few months into a project, when you've already convinced yourself the hard part was behind you.
This is also, in hindsight, the same lesson DigiPaint's painting engine had already handed me a few entries back, and I hadn't fully absorbed it yet: the hard constraint in real-time media work is almost never the math you're doing to a single pixel, it's how much data you're moving and how often. I'd read that lesson. I hadn't yet felt it in my own broken numbers. Now I had.
I'd stared at it long enough for one night. I think we had enchiladas. The enchiladas worked, which at that particular moment felt like it should count for something.
What came out of this, eventually, was a much more serious conversation about isolation, resource ownership, and — the thing that actually ties directly to the next entry — why a modern version of this machine needed real service boundaries and real fault isolation from the ground up, not bolted on after the fact once something like this went wrong in production instead of on my own desk.
Originally published on The Weekend Report: https://theweekendersproject.com/report/well-hell-the-iris-math-doesnt-work