I'd seen this before on HN, and thought about it many times after, but couldn't remember the name, so couldn't find it :( I'm glad to see it again.
Personally I see this as a great work of art, perhaps in a way that some people consider great classical pieces of music. Here's a comment from the linked page that poetically reflects that sentiment:
This demo is not just technically impressive but I found also evocative of thought and emotion. This isn't just a programming triumph, but an artistic one.
The program itself, at 256 bytes, is little more than a "seed" from which the demo (and the Mind) blossoms from. It's so small that the actual execution in memory takes up more space, and watching it play out on YouTube takes up orders of magnitude more; how many dozens of gigabytes were transmitted by all the people who've watched videos of this demo?
But what about what we actually see and hear? The visuals start off as Sierpinski triangles, symbolic of both the endless, seemingly-chaotic nature of fractals as well as their order. As the song plays, the fractals become morphed into other shapes. Lines, sharp corners, and occasionally blobs show up, evoking in me images of wrinkles in brains or circuit patterns. The melody is randomly generated but backed by a simple, steady bass rhythm, a similar marriage of chaos and order. The song's climax (at 1:42 in the video) impresses upon me a march of progress as the Mind finally takes shape, formed from random matter and energy and into an entity. We observe the formation of the Mind from the ether not just visually and aurally, but also in the form of the 256-byte seed expanding into the demo flower, eventually taking shape as the C64's home screen.
That's my favorite aspect of this demo; I really like the music. Like it legit works as a standalone track, I could totally imagine hearing it at a club. There's a lot of very impressive technical demos whose aesthetics are, well, specific to the demoscene. This is something more.
100%. For me, the music / soundtrack / audio is 80% of this demo. And to think that the audio is programmed in < 256 bytes (maybe half of that?) is mind-blowing.
I always visit things like this because it keeps me humble. There are some giants roaming around doing stuff like this, quietly and humbly, but they're out there.
another nice example of why the Demoscene is a great example of digital culture/art and is being submitted to UNESCO in a number of countries to be on lists of world cultural heritage (successfully already in Finland, soon Germany I think)
I love procedural composition. I got my MFA in the early 90's in electronic music and there used to be WAY more of this happening in the 60's, 70's and especially in the 80's (with MAX on Macs) than today.
Clever that he exploited artefacts of the DSP to create the drum sounds. That's kind of how old cheap CASIO keyboards work, by filtering glitches. Sweeping tight filter on you DSP is a trick modern electronic music uses to create a sense of variety in a repeating line. The melody generation is similar to how a Sample-and-hold waveforms create "melody" out of a random feed forward.
I remember when Nibble magazine used to have a 2-liner contest at the end of every issue for who go do the most with 2 lines of Applesoft Basic. Beagle Brothers even released a disk of 1-liners, which were really impressive.
Anyone interested in VMs, domain specific languages, and Interactive Fiction will also probably be thoroughly impressed by what he's produced in that domain too (Dialog and Å-machibe). Oh, and he programmed some of the Teenage Engineering Pocket Operators 8-bit themed synths. And have you seen the chiptune organ mod?
He is not on GitHub/Twitch/itch (much), and self-hosts his blog. I think he likes it under the radar. I hope he's well compensated because he has the skills to become a super villain if need be.
Watching on YouTube and suffering through the compression artifacts made me think that the code has reached near absolute compression ratio of the resulting audio/video.
Kind of astounding to think that the 720p50 video from YouTube is millions if not billions of times larger than the code that produced it and is still incredibly lossy.
(Re: compression, if we're being technical then the C64 machine instructions that the code calls would need to be included in the total. I think?)
There are almost NO moving parts in this video - where a group of pixels could be predictably shifted on the screen between frames with minimal changes - and the frequency that color and intensity are changing means that nearly every other optimization (aside from color-space compression) is thrown out.
It is an impressive display of how much video compression optimization is dependent on the fundamentals of the things we are recording/producing in the real world.
Looks like Linus Å moved on from Axis (the IP camera manufacturer now owned by Canon) to Teenage Engineering, job-wise. Probably a good move in terms of having more fun at work.
Reminds me of the old Beagle Brothers one-liners published in their ads, though this is much more impressive, given the size. (https://en.wikipedia.org/wiki/Beagle_Bros)
> ex-Apple II programmer I love that old box. But wow the C64
heh, I've been going in the opposite direction. No interrupts on the apple II?! gulp. I guess ppl added a MOS 6526 to their Apple IIes, but none exists in my IIc.
Makes you think what kinds of things we may find in the space of 256-byte programs. Is there a convincing chatbot there somewhere (sans language training)? Perhaps something conscious?
z_n+1 = z_n^2 + c <- fewer than 256 bytes, yet it can be used to produce a beautiful endlessly complex image.
To me it almost feels as if God or whoever has intentionally hidden it, in the way everything works I mean, so that we could one day find it. Once we have invented complex numbers for example..
What other secrets are out there? Or rather in here?
There is probably a 256-byte program that simulates a universe in which a superhuman intelligence evolves. Of course the memory and runtime requirements of that program would be prohibitive, and the superhuman intelligence would not know any human language, because there are more than 2048 bits of entropy in the basic vocabulary of any language (even Toki Pona, I would guess).
> There is probably a 256-byte program that simulates a universe in which a superhuman intelligence evolves
I can even write it :)
x = 0
while (true):
eval(int_to_code(x))
x += 1
of course the runtime will be probably quite long
EDIT: I forgot about the stop problem. But that's easy - stop the eval when memory repeats.
x = 0
prevStates = None
while (true):
state = x
prevStates = set()
while(not state in prevStates):
prevStates += state
state = eval_1_step(int_to_code(state))
x += 1
int_to_code and eval_1_step should be part of the language
What really blows my mind is that this basically makes the multiverse (everything that could happen - happens in some other universe).
This makes me wonder if, in the same way we've been technically-erroneously been hyperfocusing on CPU speed and quantity of memory in system-measuring contests and benchmarks, we've developed a fixation for how little RAM or CPU we can use while doing something interesting. I don't see the same sorts of fights developing around how much disk space we use or what the specs of all the systems we used for preprocessing are.
Demos are supposed to be about conquering limitations, right? Inspiring creativity and all that? Well, why can't we add those sorts of constraints in, then? Aren't we smart enough? :P
We might even build consciousness one day if we're honest about how much total resources we're using. That way we would actually have to reason about all the bits (no more "GPUs are really *that complicated* that what you're describing is impossible") and there would be no more black boxes.
Anthropomorphizing evolution a little, I'd bet the department that works on crafting serious intelligence into bees and jumping spider into milliwatt (or perhaps order 10² μW) brains would look respectfully at this kind of demo-scene wizardry.
It is plausible that there could be an initially 256-byte program that is self-expanding, as in, it generates more code as it runs, gradually increasing the complexity of whatever it's doing.
You could have something generating a sequence, say PI to infinite digits, and then 'executing' instructions based on those digits. You'd have to design the 'language' very carefully so that any errors or nonsensical series of instructions were ignored or recovered from. Some way of avoiding infinite loops. Hmmmm. It's probably not possible to guarantee that it wouldn't get stuck in a loop eventually (which would mean complexity would no longer increase).
My bet is on this being impossible to continue indefinitely due to the halting problem implying that it would fall into a loop eventually.
What were your thoughts/opinion on the explanation in the technical details of the "How it Works" section?
Since you referenced the visuals, and the "How it Works" section details that they were secondary/dictated by the audio...what prompted you to focus on the visuals?
Just interested in your thoughts since presumably you read the technical details in the "How it Works" section.
In order to appreciate it, it is necessary to understand the difficulty of implementing something like that on an 8-bit computer from the 80s with 256 bytes of code, which is really impressive by itself. It doesn't hurt its ability to impress that the creation shows a great, coherent artistic vision, which results in an enticing, enjoyable, meaningful viewing experience - which of course is only accessible to people with the required type and amount of sensitivity.
I looked at it for a bit and thought "Those graphics are incredible for 256 bytes" only after watching it for a while did I realise it had audio as well!
Download the 256 byte demo: https://hd0.linusakesson.net/files/a_mind_is_born.prg
Go to the emulator: https://c64emulator.111mb.de/index.php?site=pp_javascript&la...
Scroll down to "drop file", turn off autoload, upload the demo , turn on sound and fullscreen, then click the "load" button.