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!
While low-contrast, blue-on-slightly-less-blue 16-character by 2-line LCDs are extremely popular, they really are made specifically for alphanumeric use. They do an admirable job of displaying a few characters, but they don’t exactly spring to mind as a display for non-character purposes. But displaying video on a 16×2 LCD is possible, as long as you’re willing to stretch the definition of “video” a bit and use some imagination while watching.
Normally, a 16×2 display can only display a single character in each spot, chosen from a fixed character set. But [arduinocelantano] was able to leverage the eight custom character slots the display allows to build up images from arbitrary 5×8 pixel bitmaps. After using ffmpeg to scale the original video to a viewport of eight characters, a Python program was used to turn every frame of the scaled video into code to generate the custom bitmaps for each chunk of the viewport. Even with the low refresh rate of the display and the shrunken frame size, the result is a recognizable video, helped no doubt by the choice of the shadow-puppet Bad Apple!! video. Check it out after the break to see how it looks.
We saw a similar rendering of the same video on LCD a while back; that effort was amazing in that it was an EEPROM-only implementation, along with a somewhat bigger LCD with better contrast. That project served as inspiration for [arduinocelantano]’s build here, which in some ways we think looks a bit better — perhaps it’s the inverted pixels. Either way, hats off to both builders for pushing past the normal constraints and teaching us something interesting.
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!
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.
Writing a command line program that needs a little more pizzaz? Ncurses just not colorful or high res enough? Or maybe you want to bring the demo scene to the command line. Notcurses has your back. The demo is great, and looks like it can push out enough detail to pull off silliness like pushing an SNES game’s output straight to the console. What might be the most impressive element of the library is that while it can blit high res graphics through a terminal emulator with graphical support, it will also work on the basic Linux console, with no graphical system installed, by using some very old tricks. I know what you’re wondering: That’s all well and good, but can it run Doom? Yep. Come back after the break for a demo. Continue reading “Terminal Magic With Notcurses”→
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.
When we think demoscene, our first thought is typically of 80s computers, particularly the Commodore 64 and Amiga 500 which were widely regarded as the awesomest of their time. However, you can write a demo on any platform you wish, and [OxABADCAFE] has done just that – in PHP.
Pretty, no?
Going by PDE, standing for Pointless, Portable, or PHP Demo Engine, the code is available on GitHub for the curious. The code is set up for RGB ASCII terminal output, for a beautifully old-school aesthetic. Demo sequences can be programmed in JSON files, with the code executing a default in-built demo if none is provided.
There’s no audio yet, so you’ll have to cool your thumping chiptune jets until that’s available in a later release. With that said, we look forward to more development expanding what can be done with the engine – after all, there’s nothing more demoscene than pushing the limits. Video after the break.
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.)
