“Near the zero point” — unstructured stream rambling about my excitement for N64 (M64) programming, demoscene & retro dev, LLMs / vibecoding, modern programming culture, and where useful / interesting work lies

Probably of interest:

"the enemy of art is the absence of limitations" --Orson Welles

Regarding the M64/N64, we have `rsp` support as part of rexcode now in Odin: Meaning you could just make your own tooling for the system really simply. Make your own language/disassambler/debugger/etc trivially.

Absolutely. We've known "for a while" that having more code isn't in itself a good thing. But it's probably time to to go further and more explicit and say "it's actually a bad thing". That's the only backpressure that keeps things sane. Less State -> Less bugs and mental load Less Lines -> More understanding and velocity Less Cycles -> More room to do interesting/big things

You're echoing a lot of my own thoughts here. This is why I've started this project to build a game for a specific hardware platform that I have to fully comprehend. Really drives home that you are programming a computer, not talking to a magic genie.

Surely anyone who understands anything about efficiency should know that the goal is to do as much as possible by going the shortest distance from the zero point. I think LLMs killed that notion.

Man it's so sad nothing ever ships to Serbia. Getting M64 would be so nice

I was ranting about LLMs the other day and my wife said we needed to get back to the days of the 4k demo.

I don't if what I am saying if 100% correct but the industry seems to always go behind new things without giving it much tough OOP microservices..... AI and LLMs feels the same to me. I am pretty sure 10-20 years from now LLMs will not be perceived the same way they are now.

These days, I find myself unimpressed with features and programs that need so much code and memory to do what are conceptually simple things. I'm more impressed by programs that use surprisingly little of those things for how much they do. Those are the interesting programs.

Not sure if you've already seen this either but this is pretty cool with how much he's able to fit in 64 KB. Procgen has become amazing with tools compared to what they had to do with .kkrieger. Imagine exporting Substance in a procedural manner.

Look, I love the innovation that has happened on the old consoles. Kaze Emanuar has done amazing things, for instance with Mario 64, but that console is 30 years old. It's awesome, and I encourage it, but to expect it from competitive, capitalist businesses is unreasonable.

Demoscene and retrodev, last stance of resist! :)

Have to mention @KazeEmanuar's work.

This made me think of how 0 and 1 are one "space" away from each other (like, if we're counting), but between them are an infinite number of irrational numbers, each of which are tiny infinities of their own. Great point, Ryan.

This is so awesome. I am really looking forward to your blog post on this topic. The demoscene was a huge inspiration for me. I still remember seeing Second Reality for the first time like it was yesterday.

sort of feels like everyone is focused on telescopes when there's whole worlds under the microscope still to be explored

I appreciate the lisp call out. Abstraction space also has an analogous zero point. Better abstractions lead to fewer abstractions and less code as a side effect.

Real good shit. You pulled an idea to the front of my mind. We should still be making new games for old-school consoles.

What if we have a new 8/16/32-bit console/handheld? Right now it’s 64-bit all over the place. But if we have other consoles even with a tiny market share like 0.1%, that would be great. We do have the tech for small teams to push out non-emulation consoles.

I was fortunate enough to develop games for the Nintendo DS at one point and work on some unreleased prototypes. Direct access to video memory addresses was a joy.

This snippet expresses a feeling I have for a long time so well! A solution isn't the best or done when you can't add something new anymore, but instead when you can't take away anything anymore. So, when you can't get closer to the zero-point.

Ah, this is a nice mathematical description/reasoning for the "less code is better" idea, great analogy! Waiting for the day the LLMs start optimizing the distance to the zero-point 😄

This is such a great way to put it, very inspiring

I haven’t had the time to watch the video, but what I have been thinking in these months is: aspiring people should be very picky about what kind of job they get, especially the first one. One gets into the wrong hole and it takes 10x to climb out.

One of the big reasons why these whole LLMs for code gen has been bothering me. There's definitely smaller subset of useful or interesting programs than everything under the sun.

I'm so glad to have stumbled on Handmade Hero way back when. Before, I was not having a great time in Unity and never felt like I really knew what was going on and was just gluing stuff on top of other stuff to *kind of* make it work. Yeah it'd be so nice to remove even more layers of complexity and have more direct control of the hardware :)

We recently updated our Getting Started in N64 development wiki page, feel free to check it out y'all

The interesting part of the space is *what you find interesting*. Building enormous fractals is as much fun as banging bits, maybe more. I've never been more addicted to programming in my life.

I remember being obsessed with PC 64K demos many years ago. But demoscene people seemed to be rather secretive about their methods (and my terrible english then did not help me back then). Honestly kind of made me want to revisit that stuff now.

I thought about this same issue of the zero point, I described it in terms of generic/abstraction because often times when people try to make complex programs they end up creating a dsl which is a function with infinite inputs and outputs.

The reason we get further away from the zero-point and push towards more instead of less is because humans believe if they add more to themselves they’ll get closer to comprehending the transcendent, when instead they need to subtract from their preconceptions.

I like your ideas here. I’m working on my own FPGA console and GPU right now. In my limited shaders I start with programs and then find for performance reasons which things to bake into the hardware. You need a process to find out what can help you make smarter faster programs.

Seems to follow that in the infinite program space to a first approximation all programs are uninteresting/broken/both. And the highest chance of utility and correctness is found near the zero point.