Retrotechtacular: Computer-Generate Video 1968 Style!

November 8, 2024 by Al Williams 11 Comments

[Classic Microcomputers] read in a book that there was a computer-generated film made in the late 1960s, and he knew he had to watch it. He found it and shared it along with some technical information in the video below.

Modern audiences are unlikely to be wowed by the film — Permutations — that looks like an electronic spirograph. But for 1968, this was about as high tech as you could get. The computer used was an IBM mainframe which would have cost a fortune either to buy or to rent the hours it would take to make this short film. Now, of course, you could easily replicate it on even your oldest PC. In fact, we are surprised we haven’t seen any recreations in the demoscene.

Continue reading “Retrotechtacular: Computer-Generate Video 1968 Style!” →

A Demo Party On A Chip

July 28, 2024 by Jenny List 5 Comments

The demoscene has provided our community with its artistic outlet since the first computers which could handle graphics, and has stayed at the forefront of technology all the way. For all that though, there’s a frontier it hasn’t yet entirely conquered, which exists in the realm of silicon. To address this cones the ever awesome Tiny Tapeout, who are bringing their ASIC-for-the-masses scheme to the world of demos with an ASIC demo competition.

With a closing date of 6th of September, all accepted entrants get a free Tiny Tapeout tile for their entry. Entries are limited to two tiles or less. with VGA and audio outputs via a specified PMOD pinout. There are a variety of categories including the expected best sound and best graphics, but among them we’re most interested by the mixed signal one that includes analogue circuitry.

Tiny Tapeout has been a particularly exciting project over the last couple of years, truly breaking new ground for the hardware hacker world. Since they’ve just recently been able to start doing some analog design on the chips, we’re excited to see what people come up with for this competition, and we hope it will provide significant advancement to the art. In the best tradition of the demo scene, they’ve even made an intro for the competition, which you can see below the break.

Want to know what all the fuss is about? Start here!

Continue reading “A Demo Party On A Chip” →

Bus Sniffing The Model 5150 For Better Emulation

October 3, 2023 by Dan Maloney 6 Comments

At the risk of stating the obvious, a PC is more than just its processor. And if you want to accurately emulate what’s going on inside the CPU, you’d do well to pay attention to the rest of the machine, as [GloriousCow] shows us by bus-sniffing the original IBM Model 5150.

A little background is perhaps in order. Earlier this year, [GloriousCow] revealed MartyPC, the cycle-accurate 8088 emulator written entirely in Rust. A cycle-accurate emulation of the original IBM PC is perhaps a bit overkill, unless of course you need to run something like Area 5150, a demo that stretches what’s possible with the original PC architecture but is notoriously finicky about what hardware it runs on.

Getting Area 5150 running on an emulator wasn’t enough for [GloriousCow], though, so a deep dive into exactly what’s happening on the bus of an original IBM Model 5150 was in order. After toying with and wisely dismissing several homebrew logic analyzer solutions, a DSLogic U3Pro32 logic analyzer was drafted into the project.

Fitting the probes for the 32-channel instrument could have been a problem except for the rarely populated socket for the 8087 floating-point coprocessor on the motherboard. A custom adapter gave access to most of the interesting lines, including address and data buses, while a few more signals, like the CGA sync lines, were tapped directly off the video card.

Capturing one second of operation yielded a whopping 1.48 GB CSV file, but a little massaging with Python trimmed the file considerably. That’s when the real fun began, strangely enough in Excel, which [GloriousCow] used as an ad hoc but quite effective visualization tool, thanks to the clever use of custom formatting. We especially like the column that shows low-to-high transitions as a square wave — going down the column, sure, but still really useful.

The whole thing is a powerful toolkit for exploring the action on the bus during the execution of Area 5150, only part of which [GloriousCow] has undertaken as yet. We’ll be eagerly awaiting the next steps on this one — maybe it’ll even help get the demo running as well as 8088MPH on a modded Book8088.

Book8088 Slows Down To Join The Demoscene

September 12, 2023 by Dan Maloney 9 Comments

As obsolete as the original IBM Model 5150 PC may appear, it’s pretty much the proverbial giant’s shoulders upon which we all stand today. That makes the machine worth celebrating, so much so that we now have machines like the Book8088, a diminutive clamshell-style machine made from period-correct PC chips; sort of a “netbook that never was.”

But the Book8088 only approximates the original specs of the IBM PC, making some clever hardware hacks necessary to run some of the more specialized software that has since been developed to really stretch the limits of the architecture. [GloriousCow]’s first steps were to replace the Book8088’s CPU, an NEC V20, with an actual 8088, and the display controller with a CGA-accurate Motorola MC6845. Neither of these quite did the trick, though, at least not on the demanding 8088MPH demo, which makes assumptions about CPU speed based on the quirky DRAM refresh scheme used in the original IBM PC.

Knowing this, [GloriousCow] embarked on a bodge-fest aimed at convincing the demo that the slightly overclocked Book8088 was really just a 4.77-MHz machine with a CGA adapter. This involved cutting a trace on the DMA controller and reconnecting it to the machine’s ~~PIO~~ timer chip, with the help of a 74LS74 flip-flop, a chip that made an appearance in the 5150 but was omitted from the Book8088. Thankfully, the netbook has plenty of room for these mods, and with the addition of a little bit of assembly code, the netbook was able to convince 8088MPH that it was running on the correct hardware.

We thoroughly enjoyed this trip down the DMA/DRAM rabbit hole. The work isn’t finished yet, though — the throttled netbook still won’t run the Area 5150 demo yet. Given [GloriousCow]’s recent Rust-based cycle-accurate PC emulation, we feel pretty good that this will come to pass soon enough.

The Demoscene, Now An Irreplaceable Piece Of Cultural Heritage

July 11, 2023 by Jenny List 21 Comments

Break out your tuxedo or your evening gown, we’re going to take in some highbrow culture. A night at the opera perhaps, some Tchaikovsky from the symphony orchestra, or maybe a bit of Shakespeare? No, we’re going to a demo party, because the demoscene is the latest art form to be accepted as officially a part of the national cultural heritage of the Netherlands. This builds on successes adding the scene to the cultural heritage registers of Finland, Germany, and Poland, and should provide a boost to other bids in countries such as Switzerland and eventual UNESCO world acceptance.

It’s all very cool that one of our wider community’s art forms is at last being taken seriously rather than being dismissed by the establishment, because along with greater recognition comes other benefits. Sadly we don’t expect any cities to shell out for a demo auditorium next to the shiny new opera house any time soon, but we can see that it could be used to the benefit of for example a hackerspace chasing grants. meanwhile, feast your eyes on a bit of cultural heritage courtesy of the Dutch Centre For Intangible Cultural Heritage (Dutch language, English translation).

Not sure what the demo scene is? We’ve taken you to a demoparty before.

Header image: People Celebrating Evoke 2019 – Foto Darya Gulyamova

Hackaday Links: July 9, 2023

July 9, 2023 by Dan Maloney 8 Comments

Good news this week from Mars, where Ingenuity finally managed to check in with its controllers after a long silence. The plucky helicopter went silent just after nailing the landing on its 52nd flight back on April 26, and hasn’t been heard from since. Mission planners speculated that Ingenuity, which needs to link to the Perseverance rover to transmit its data, landed in a place where terrain features were blocking line-of-sight between the two. So they weren’t overly concerned about the blackout, but still, one likes to keep in touch with such an irreplaceable asset. The silence was broken last week when Perseverance finally made it to higher ground, allowing the helicopter to link up and dump the data from the last flight. The goal going forward is to keep Ingenuity moving ahead of the rover, acting as a scout for interesting places to explore, which makes it possible that we’ll see more comms blackouts. Ingenuity may be more than ten-fold over the number of flights that were planned, but that doesn’t mean it’s ready for retirement quite yet.

Continue reading “Hackaday Links: July 9, 2023” →

Generating Instead Of Storing Meshes

March 30, 2023 by Matthew Carlson 23 Comments

The 64kB is a category in the demoscene where the total executable size must be less than 65,536 bytes, and at that size, storing vertexes, edges, and normal maps is a waste of space. [Ctrl-Alt-Test] is a French Demoscene group that has been doing incredible animations for the last 13 years. They’ve written an excellent guide on how they’ve been procedurally generating the meshes in their demos.

It all starts with cubes. By stacking them, overlaying them, reusing them, and tiling them you can get better compression than raw vertexes. Revolution was the next trick, as it uses just a few points, plotting it via Catmul-Rom splines, and revolving around an axis. The numbers are pairs of 32-bit floats and before compression, a detailed pawn on a chess board can weigh in at just 40 bytes. Just these few techniques can take you surprisingly far (as seen in the picture above).

They later worked on deforming cubes and placing them into a semi-randomized column, which happened to look a lot like plants. This isn’t the first generated vegetation we’ve seen, and the demoscene technique focused more on getting the shape and setting the mood rather than being accurate.

Signed distance fields are another useful trick that allows you to generate a mesh by implementing a signed distance function and then running a marching cubes algorithm on it. In a nutshell, a signed distance function just returns the distance to the closest point on a surface from a given point. This means you can describe shapes with just a single mathematical equation. As you can imagine, this is a popular technique in the demoscene world because it is so space efficient in terms of code and data. [Ctrl-Alt-Test] even has a deep dive into one of their projects, Immersion, with a breakdown of where the space is allocated.

There are plenty of other tips and tricks here, such as generating textures and developing a C++ hot reload system for faster iteration. It’s just incredible that the executable that plays the whole video is smaller than just a JPEG screenshot of the video. It’s a reminder that the demoscene is still fascinating with new tricks and experiences even as the hardware stays the same. Continue reading “Generating Instead Of Storing Meshes” →