The demoscene never ceases to amaze. Back in the mid-80s, people wouldn’t just hack software to remove the copy restrictions, but would go the extra mile and add some fun artwork and greetz. Over the ensuing decade the artform broke away from the cracks entirely, and the elite hackers were making electronic music with amazing accompanying graphics to simply show off.
Looked at from today, some of the demos are amazing given that they were done on such primitive hardware, but those were the cutting edge home computers at the time. I don’t know what today’s equivalent is, with CGI-powered blockbusters running in mainstream cinemas, the state of the art in graphics has moved on quite a bit. But the state of the old art doesn’t rest either. I’ve just seen the most amazing demo on a ZX Spectrum.
Simply put, this demo does things in 2022 on a computer from 1982 that were literally impossible at the time. Not because the hardware was different – this is using retro gear after all – but because the state of our communal knowledge has changed so dramatically over the last 40 years. What makes 2020s demos more amazing than their 1990s equivalents is that we’ve learned, discovered, and shared enough new tricks with each other that we can do what was previously impossible. Not because of silicon tech, but because of the wetware. (And maybe I shouldn’t underestimate the impact of today’s coding environments and other tooling.)
I love the old demoscene, probably for nostalgia reasons, but I love the new demoscene because it shows us how far we’ve come. That, and it’s almost like reverse time-travel, taking today’s knowledge and pushing it back into gear of the past.
This article is part of the Hackaday.com newsletter, delivered every seven days for each of the last 200+ weeks. It also includes our favorite articles from the last seven days that you can see on the web version of the newsletter.
Want this type of article to hit your inbox every Friday morning? You should sign up!
The community of Hackaday readers is diverse and talented, and supplies us with plenty of motivation, feedback, knowledge, and of course cool stuff to show you. There are many interest streams within it, but it’s safe to say that we’re more directed towards the hardware scene here. One of those parallel streams which has much overlap is the demoscene, that area in which programming, art, and music come together and push computer hardware to the limit of its abilities in pursuit of the most eye-catching works. I took a road trip with a friend to Outline, a small demo party held on a farm in the eastern Netherlands, to take a look at the world of demos up-close as a hardware-focused outsider.
Like A Hacker Camp, But The Music’s Better
A still from Thrive, a 256 byte demo for the TIC-80 fantasy console.
If I wanted to sum up the flavour of Outline, I’d describe it as very similar to a small hacker camp, but with better music and partying. The hackerspaces are replaced by demo groups and awesome graphics take the place of robots and electronics, but the vibe of people with a passionate interest in the low-level understanding of technology is exactly the same. Even some of the same faces make an appearance. On the benches sit modern high-spec PCs alongside classic consoles and microcomputers, on the projector screen are live coding shaders or some of the most recognisable demos past and present, and in the air is an eclectic mix of live-DJ EDM and chiptunes.
As an outsider at a first demoscene event it’s difficult to appreciate the work from a comparative perspective, while like most of us I’m familiar with quite a few demos that have become popular I’m not well-equipped enough to talk about the code and techniques behind them But I can run through the various sections of the competition, and since everything is online I can link to a few of them. The competition is split up into several sections, which are loosely for all-out technology-no-object demos, space-limited 256 byte and 128 byte demos, and old-school demos for retrocomputing hardware. Each is a test of the programmer’s skill in fitting the most into the least of resources, and for those who appreciate such things it’s the cleverness of the technique which produces the demo that’s as much a draw as the look of the thing. I don’t think I have ever exercised such mastery over any of the computers I have owned. So browse the entries, and marvel at their ingenuity. My personal aesthetic favourites were Thrive by [Agenda] for the TIC-80 fantasy console and It’s about time by [Guideline] for Windows, but you may have different tastes.
Don’t Forget The Hardware
Mine Storm 4D, on a lenticular holographic display.
Beyond the atmosphere and the demos themselves, there was a bit of hardware for the retrocomputer enthusiast. The Atari Falcon and Jaguar were neither destined to set the world on fire when they appeared, but there they were for those of us who drooled over them back in the day to lust for once more.
If the original hardware wasn’t enough then there was some newly minted retrocomputing hardware making a showing, with a couple of minimig Amiga FPGA boards showing Workbench. Star of the hardware show though went to Mine Storm 4D, a version of the classic Vectrex game Mine Storm running on a PC, for the Looking Glass Factory holographic portrait display. With my visual superpower I didn’t quite get a 3D effect, but I definitely got the holographic effect when moving my head.
Having never been to a demo party I didn’t know quite what to expect, but I can safely say I had a fantastic time, saw a lot of really cool stuff, and made some friends along the way. If you’ve never been to a demo party because it’s not quite your scene then all I can say is that you should give it a go. Every hardware hacker should go to a demo party!
Would it have been too obvious to call a game about soccer playing RC cars, Soc-Car? Well [Martin] thought so and opted to call his Nintendo GameCube homebrew game, Retro League GX. The game clearly takes inspiration from Rocket League developed by Psyonix, as it pits teams of cars on a pitch plus comes complete with boosts to boot. There are some impressive physics on display here, and according to Krista over at GBATemp everything is playable on original hardware. Though those without a GameCube can certainly get a match in via the Dolphin emulator.
There are a number of ways to boot homebrew on a Nintendo GameCube, however, the most essential piece of software would be Swiss. Swiss is a homebrew utility that interfaces with all the myriad of ways to load code onto a GameCube these days. Common ways loading homebrew include saving files onto an SD card then using a SDGecko device that plugs into the memory card ports, or a SD2SP2 device that plugs into one of the GameCube’s expansion ports located on the bottom of the console. Those who prefer ditching the disc drive entirely can load homebrew via a optical disc emulator device like the GC Loader.
Still on the roadmap Retro League GX are ports for 3DS, PSP, Wii, and Linux. LAN and Online multiplayer are in the works as well. So at least that way GameCube broadband adapter owners may get to branch out beyond Phantasy Star Online for once. Best of all, [Martin] stated that the code for Retro League GX will be open sourced sometime next year.
Never underestimate the ingenuity of the demoscene. The self-imposed limitations lead to incredible creativity, and, the range of devices they manage to get their demos running on never ceases to amaze us. But we never thought we’d see a C64 demo without one central component: the C64.
Full disclosure: [Matthias Kramm]’s demo, called “Freespin”, does need a C64 to get started. The venerable 6502-based computer runs a loader program on a 1541 disk drive. But from then on, it’s all floppy drive. And [Matthias] has laid bare all his tricks.
The video below shows the demo in full, including a heart-stopping on-camera cable mod. By adding a single 100 Ω resistor, [Matthias] turned the serial clock and data lines into a two-bit digital-to-analog converter, good enough to generate signals for both black and white pixels and the sync pulses needed for the display.
No demo would be complete without sound, and Freespin’s tunes come from controlling the drive’s stepper motor, like a one-voice Floppotron.
Watching nothing but a floppy drive run a cool demo is pretty amazing. Yes, we know there’s a full-fledged computer inside the floppy, but the bit-banging needed to make this work was still mighty impressive. It might be cool to see what you could do with multiple drives, but we understand the minimalistic aesthetic as well. And speaking of tiny little demos: the 256 bytes of [HellMood]’s “Memories” or [Linus Åkesson]’s “A Mind is Born” still leave us speechless.
It would be an understatement to say that the Commodore 64 demo scene is quite amazing. For those who are unaware, a ‘demo’ in this context is essentially a technological demonstration. Usually to show off particular effects or other (visual) properties that either push the limits of the platform on which it is being run, or use its hardware in a special fashion. In the case of [Linus Åkesson]’s A Mind Is Borndemo, the challenge was to do as much as possible in 256 bytes, while providing an audiovisual experience.
Although at first glance 256 bytes may sound like a lot to work with, this code has to generate the entire melody that is output via the Commodore 64’s SID audio chip, while simultaneously generating an attractive visual pattern. This is quite an undertaking, as the video capture of the result (included after the break) makes clear. The secret sauce here is to make use of the C64’s SID audio & VIC-II video chips.
Driven by a 60 Hz timer interrupt, the three voices of the SID are used to play the kick drum and bass, melody and drone respectively, creating the 64 total bars of the music using a linear-feedback shift register (LFSR). This means that the melody is in a sense randomly generated, but deterministically enough to sound pleasing to the human ear.
For the visual side, the C64 runs in Extended Character Mode, using fonts along with a background color to create interesting patterns using what is essentially a cellular automaton algorithm. While there are some visual glitches due overwriting of video data, and a race condition, these end up adding to the charm. The resulting audio track is pretty catchy too, and absolutely worthy of a listen.
The demo code for [XTronical]’s ESP32-based SD card music player is not even 40 lines long, though it will also require a few economical parts before it all works. Nevertheless, making a microcontroller play MP3s (and other formats) from an SD card is considerably simpler today than it was years ago.
Part of what makes this all work is I2S (Inter-IC Sound), a format for communicating PCM audio data between devices. Besides the ESP32, at the heart of it all is an SD card reader breakout board and the MAX98357A, which can be thought of as a combination I2S decoder and Class D amplifier. The ESP32 reads audio files from the SD card and uses an I2S audio library to send the I2S data stream to the MAX98357A (or two of them for stereo.) From there it is decoded automatically and audio gets pumped though attached speakers.
A few economical components, and only a handful of connections between them.
It’s amazing how much easier audio is to work with when one can take advantage of shuffling audio data around digitally, and the decoder handles multiple formats with an amplifier built in. You can see [XTronical]’s ESP32 player in action in the video embedded below.
In 1993, IBM PCs & clones were a significant but not dominant fraction of the home computer market. They were saddled with the stigma of boring business machines. Lacking Apple Macintosh’s polish, unable to match Apple II’s software library, and missing Commodore’s audio/visual capabilities. The Amiga was the default platform of choice for impressive demos, but some demoscene hackers saw the PC’s potential to blow some minds. [Future Crew] was such a team, and their Second Reality accomplished exactly that. People who remember and interested in a trip back in time should take [Fabien Sanglard]’s tour of Second Reality source code.
We recently covered another impressive PC demo executed in just 256 bytes, for which several commenters were thankful the author shared how it was done. Source for demos aren’t necessarily released: the primary objective being to put on a show, and some authors want to keep a few tricks secret. [Future Crew] didn’t release source for Second Reality until 20th anniversary of its premiere, by which time it was difficult to run on a modern PC. Technically it is supported by DOSBox but rife with glitches, as Second Reality uses so many nonstandard tricks. The easiest way to revisit nostalgia is via video captures posted to YouTube (one embedded below the break.)
A PC from 1993 is primitive by modern standards. It was well before the age of GPUs. In fact before any floating point hardware was commonplace: Intel’s 80387 math co-processor was a separate add-on to the 80386 CPU. With the kind of hardware at our disposal today it can be hard to understand what a technical achievement Second Reality was. But PC users of the time understood, sharing it and dropping jaws well beyond the demoscene community. Its spread was as close to “going viral” as possible when “high speed data” was anything faster than 2400 baud.
Many members of [Future Crew] went on to make impact elsewhere in the industry, and their influence spread far and wide. But PC graphics wasn’t done blowing minds in 1993 just yet… December 10th of that year would see the public shareware release of a little thing called Doom.
Simply put, this demo does things in 2022 on a computer from 1982 that were literally impossible at the time. Not because the hardware was different – this is using retro gear after all – but because the state of our communal knowledge has changed so dramatically over the last 40 years. What makes 2020s demos more amazing than their 1990s equivalents is that we’ve learned, discovered, and shared enough new tricks with each other that we can do what was previously impossible. Not because of silicon tech, but because of the wetware. (And maybe I shouldn’t underestimate the impact of today’s coding environments and other tooling.)
