Video Capture. The Hardware. The Software. The Story. The Parts. Other Resources.
Release: Deadline 2025, 1st place in wild compo.
Video Capture
Party Release
The Hardware: The Sorbus Computer with 32x32 LEDs Expansion
This is just a very short overview, as the Sorbus Computer has its own project page.
The hardware can be separated into four parts:
The Mainboard: the Sorbus Junior
The Sorbus Junior is the original design, which was three PCBs rolled into a single one. This is the core utilizing a 65C02, with only the 65SC02 instructions used for compatiblity. The whole rest of the mainboard is implemented using an RP2040 microcontroller. To…
Video Capture. The Hardware. The Software. The Story. The Parts. Other Resources.
Release: Deadline 2025, 1st place in wild compo.
Video Capture
Party Release
The Hardware: The Sorbus Computer with 32x32 LEDs Expansion
This is just a very short overview, as the Sorbus Computer has its own project page.
The hardware can be separated into four parts:
The Mainboard: the Sorbus Junior
The Sorbus Junior is the original design, which was three PCBs rolled into a single one. This is the core utilizing a 65C02, with only the 65SC02 instructions used for compatiblity. The whole rest of the mainboard is implemented using an RP2040 microcontroller. To save cost, instead of integrating the RP2040 directly onto the board, a cheap Chinese clone of the Raspberry Pi Pico is used. Compared to the original, this allows access to all 30 GPIO pins and also has a greater flash storage of 16MB. The PCB also has an expansion bus for addon cards. It is used for the soundboard and the driver board for the LEDs.
The Soundboard
The Sorbus soundboard also utilizes the RP2040 with the same Chinese clone board. However, since there also is an RP2040 driving the SIDKick Pico, some code was borrowed from there with permission. For the future, there are plans to support more than just the dual SID of the SIDKick pico, switchable during runtime.
The 32x32 LED Matrix
This is put together using four 16x16 WS2812 panels. The software is written in a very modular way, so replacing them with something else is also possible. Since the order of the LEDs is non-linear, more like a zig-zag pattern, a matrix for translating the data to the correct LED is required. Code for calculating my setup is included. If you need help creating one for your setup, contact me.
The Driver Board For The LEDs
The driver board for the LEDs is a repurposed board originally used to carry the chipset before the integration done with the Sorbus Junior. It sniffes on the bus to create a shadow memory, which then can be used “DMA-like” transfer the data to the LEDs. Not a full framebuffer needs to be transferred, transparancy is supported, so you can even have something that almost resembles a sprite.
The Software
- Download archive containing source and binary: 1kLEDsIsNoLimit.zip (Size: 117769; Date: 2025-10-06, 17:56 CEST)
- Source repository: https://git.h8u.de/Sorbus/1kLEDsIsNoLimit
The Story
When going to Evoke 2025, I went there with a idea: if I can code the Kefrens effect there, I’ll code a full demo for Deadline. On the first day, the goal was already reached, but it didn’t look that good. Too slow and other smaller things. But it got better and better during the time I was there. When I left, it was clear that there’s going to be a small demo showing off my Sorbus with the 32x32 LEDs. Little did I know, that it would be slightly bigger than anticipated. But what can be done from scratch in just seven weeks?
So I started writing “concept demos” as I called them: a single effect, not coded to the fullest, but enough to see if it works. And they added up. Still I was thinking that it might be just barely enough to fill three minutes.
When I was asking Skyrunner directly from the Evoke via email, if he could do the music for that demo, I asked him that I need some music that starts with “No Limit” and runs for like three minutes or so. I really didn’t know that I could gather up effects for an eight minutes demo. When he saw the first concept of the demo running that included all the parts (some were placeholders), well... he wasn’t happy with the extra work it meant for him. But I am very thankful that he picked up the challenge and came up with another awesome track, that really pushed this demo.
So, after those seven weeks the demo turned out way more than I expected, when I decided to go for it at the Evoke. It was a lot of pressure I put on myself, but seeing the result, it was totally worth it. But now I need to some stuff I neglected in those weeks, like doing the laundry.
The Parts
65(C)02 Greeting
My Atari 2600 VCS Demos typically start with an Atari logo coded in just about 128 bytes. For the LEDs I wanted to have something similar. Since the Sorbus for me also is about the transition from the MOS 6502 to the CMOS 65C02 family, it’s a nice way to state this in the intro. The “ping” sound is taken from EX-DOS & Disk Doctor C64 / VC1541.
The fun part in coding: The fun part here was to use all bits of a byte to make up the two images. It also contains an easter egg. If you’ve got a very rare CSG 65CE02 installed, then the “WDC” logo changes to “CSG”.
Re-Enacted Amiga Bootup
Since the demo should resemble Losso’s 1k Is No Limit, it was clear that it should also resemble the boot process. The Amiga Hand was also done for the 6502asm.com environment, but I decided to create my own. I think, it looks slightly better and also I didn’t need to find the original author and ask for permission.
The fun part in coding: Nothing fancy here, except that the workbench screen is created line by line to save up memory.
“1k Is No Limit” Reproduction
It was so very clear, that I wanted to use the “Lossoman” in this demo. It’s 16x16 pixels, and I’ve got 32x32, so there’s just enough space around the figure to make it work.
The fun part in coding: It was an interesting task to cramp as much status bits for the man in just one byte of memory. Still my 2600 soul trying to optimize where it’s not required on the Sorbus. Also it was interesting to have the man “reusable” for later parts.
Amiga Ball
When doing a demo that quotes the Amiga in so many ways it would be sacrilegious to leave this one out. I also wanted to have a transition from the Lossoman to the Amiga Ball instead of a break.
The fun part in coding: It was fun on so many levels: the ball is actually calclated. The first iteration had a precalced ball, but 2k of graphics felt way to much. The second iteration only had slightly more than 0.5k in total. Adding the shadow was also worth it, a couple of persons were like “Oh! With shadow” while watching.
Ballblazer
Once the idea of this demo manifested, I wrote a list of effects that I wanted to do. Ballblazer was one of them. I’m referring to the game for the Atari 7800 / Commodore 64 by Lucasfilm Games here. Once this was done, the question was: what to put on top? Since I didn’t have any title in any “no limit” demo, let’s start with that.
The fun part in coding: Well this was not that fun. I was looking for a mathematical description of foreshortening, and all I got was how to do it when drawing. So I came up with guessing some numbers and adjusting them until they looked plausable.
Mansplainer Volume 1
There were two things I wanted to mention: this wonderful quote from Ferris of Logicoma: “A man walks into some bars...”, which also led to adding a feature to the next part.
The fun part in coding: That was there first time I used the scroll routine during coding and already in an environment that’s not full width.
Kefrens Bars
These Kefrens Bars were coded on Evoke 2025 and led to the decision to build a full demo for Deadline 2025. The man walking into some bars were added rather late, just to make the quote from above work better. Also the second man was the first implementation. It was so “Benny Hill”-like funny, that I had to keep it in even after a better implementation.
The fun part in coding: From a programming standpoint the bars exactly implemented the way they appear and not like Kefrens bars are implemented traditionally: they are just bars placed on top of each other.
3D Stars
There were three effects I had a good idea on how to implement them right from the start, when I wanted to do that effect. One worked out better than expected, one worse than expected, and one exactly like expected. This is the one what worked exactly as expected.
Tunnel
This is the one that worked worse than expected. It’s also my third try on implementing a tunnel with these LEDs. While this is okay, the other two were sub-mediocre. I also had a nice chat afterwards: “I like the optical illusion with the color rings...” - “This is meant to be a tunnel.” - “Oops. ^^”
The fun part in coding: The image is just a quarter circle that gets mirrored to the other areas. During development I also wrote a mail to Peiselulli with the subject “SvOlli can’t do tunnel”. He explained to me that, Streetuff was the expert for tunnels. We miss him.
Greetings
Finally, I’ve got a chance to put some greetings again into a very nice light. (Pun intended.) These graphics take up almost half of the binary. Most of the images were painted by Titus of Rabenauge. Everyone gets the same time. The smaller images stay some extra time, the larger ones don’t pause.
The fun part in coding: Well this takes up almost half of the executable of the demo. “This Space For Rent” is a placeholder for forgotten greetings like TRBL, if there will be a post-party version this will be updated. Also “Attentionwhore” was painted by me. The “Pizza Table” are a couple of colleagues and retro enthusiasts who I meet for lunch typically once a week.
Mansplainer Volume 2
And here’s the other thing I wanted to explain: how one of the very first demos done for a home computer caused a traffic jam on 5th Avenue in New York in 1976. Don’t believe me? Look it up at wikipedia.
Kaleidoscope
This was very interesting for me. After hearing about that on the Vintage Computing Festival Berlin in 2024, I wanted to implement this. However, the version here differs in some key aspects. The Dazzler is 64x64 pixels, I only had 32x32 LEDs. The color palettes differ. And the implementation was in Intel 8080 assembler, not 6502. While there was a C/C++ re-implementation available on GitHub, that was also not that easy to port. At one point it clicked, and I also saw the perfect opportunity how to strip down the painting area by two in each direction.
The fun part in coding: Starting to analyse the original code and reimplementation, I wasn’t sure, if I could do this with the hardware at hand, but at one point that it’s just changing the number of shifts to get the correct image size. Also, the image gets mirrored in software (65C02). Originally I wanted to do this in hardware (on the RP2040), but the implementation in 65C02 was so simple and straight forward, I decided the “hardware support” was not needed anymore. Just like on the 2600: when you can do it in software, don’t do it in hardware.
Plasma
During implementation of the demos, I’m having burgers with a colleague for dinner at diner. There we were discussing how I originally wanted to take a few days off to work on the demo, but revoked my request due to a critical project at work. I was stating: “Something like the plasma, I can definatly do in a day... thinking about it, I can do it in a day even after work.” Two hours later he already got a video of the first version working.
The fun part in coding: While the algorithm stays the same, the parameters change a couple of times. Also, it’s interesting that this effect is one with a lot of variables.
Rotor
This is also a single evening job. I want to implement a rotor. It’s rather obvious how to do it. The first implementation looked rather plain, and I wasn’t sure if I wanted to use it at all. Then I started experimenting with changing the color during drawing a single line. Once it was implemented, it looked like that. Now there was something that was better than expected.
The fun part in coding: At that moment, I was like “hands off, you can only make it worse from here.” And I was right: a few days later, I was thinking about changing a detail and it looked still okay, but rather worse than better...
Credits
At one point I was thinking that the Lemmings might be a nice addition to the demo: they are small and very recognisable. The hardest part was getting the graphics. I pixeled them by hand taking a look at some enlarged version.
The fun part in coding: It was really awesome to see how the animation worked out. Most impressive was that by only using an offset of a single frame per Lemming that look nice walking, not marching in cadence.
Signature
This was my just playing around with the routines for compressing images used for creating the Amiga Ball. If implemented well, using them for rotating images is also possible. It was kept in, because it wasn’t done anywhere else.
The fun part in coding: Toying around with a routine already done and to see what else it could be used for was really some fun toying.
Guru
Of course an Amiga themed demo needs to end with a “guru”. It was not the only time that this was done during Deadline 2025.
The fun part in coding: Well that was rather easy to implement... at the start of the demo you can select if the demo should run looped or stay at the guru.