Naturally, Regenerator 2000 is built with full support for the 6502 instruction set, including undocumented op-codes as well. It’s able to automatically create labels and comments and can be paired with the VICE C64 emulator for live debugging. You can do all the usual debug stuff like inspecting registers, stepping through code, and setting breakpoints and watchpoints when you’re trying to figure out how something works. It can even show you sprites, bitmaps, and character sets right in the main window.
The modern web browser is now far more than a thing for rendering web pages, it’s a multi-faceted environment that can provide a home for almost any application you could imagine. But why should JavaScript or Wasm have all the fun? CSS is Turing complete now, right? Why not, as [Lyra Rebane] has done, write an 8086 emulator in pure CSS?
The web page at the link above may contain an 8086, but missing MMU aside, don’t expect it to run Linux just yet. Instead it has limited resources, just enough to run a demo program. It needs a Chrome-adjacent browser because it uses some CSS functions not available in for example Firefox, but we’ll forgive it that oddity. Its clock is provided by a small piece of JavaScript not because CSS can’t provide one, but because the JS version is more stable.
On one hand this is of little practical use, but to dismiss it as such is to entirely miss the point. It’s in the fine spirit of experimentation, and we love it. Perhaps a better way to look at it is to see what could be done more efficiently with the same idea. A 1970s CISC microprocessor might not be the best choice, but would for example a minimalist and optimized RISC design be more capable? We’re looking forward to where others take this thread.
It’s not the first unexpected computing environment we’ve found, who could forget the DOOM calculator!
[Danny Spencer] has a brilliant graphical demo that, like all great demos, flexes a deep understanding of the underlying system: a real-time 3D shader on the Game Boy Color.
If you’re not familiar with shaders, they were originally mathematical lighting models (hence the name) and are an integral part of the modern 3D graphics pipeline. One no longer draws pixels directly to a screen to represent objects. Instead, 3D object data is sent to the Graphics Processing Unit (GPU) which handles the drawing. Shaders are what control things like an object’s lighting, textures, and more.
Implementing even a basic real-time shader in software on a Game Boy Color is pretty wild. Not only is it a pixels-and-sprites (and not 3D graphics) kind of system, but the Game Boy’s SM83 CPU doesn’t even have a multiply instruction, nor does it support floats. As [Danny] puts it: given that the entire mathematical foundation of his shader rests on multiplying non-integer numbers, he had to get creative. That makes his demo a very round peg in an extremely square hole.
In the case of [Danny]’s demo, the user can manipulate the position of, and lighting around, a classic Utah teapot in real time. He explains the workflow and shows how the process can be applied to other objects. The ROM is available on GitHub and there’s a video, embedded below.
You may or may not know, but printf is a Turing-complete language, once you exploit all the strange and wonderful format characters in it (especially %n). But who has time to write code as printf modifiers? Now, thanks to [sebsite], you can at least write in a slightly higher level assembly language and compile to printf. Practical? No. Cool? Undeniably.
As an example, the page shows fizzbuzz written in the assembler:
alias i, fizz, buzz
->fizz ([i] + 1) % 3 == 0
->buzz ([i] + 1) % 5 == 0
->i [i] + 1
->exit [i] == 100
[i] if !![i] & ![fizz] & ![buzz]
"Fizz" if [fizz]
"Buzz" if [buzz]
"\n" if [i]
The alias keyword defines constants and, owing to default values, sets i to zero, fizz to one, and buzz to 2. The “arrow” statements store a result into a variable (so the first assignment sets the resulting value into fizz).
During the Cold War, the specter of a nuclear “dead man’s switch” was central to the concept of Mutually Assured Destruction (MAD). In the event that one side was annihilated by the other, an automated system would be triggered to deliver a revenge strike that would ultimately destroy the attacker. It was the ultimate defense, as your enemy will never attack if they know doing so will inevitably lead to their own destruction.
The same idea has occasionally been employed by whistleblowers and journalists as well. Should the individual fail to check in regularly, a series of predetermined events will be set into motion. Again, the idea is defensive in nature. If somebody is in possession of information so damning that they could be abducted or even killed to keep it quiet, making arrangements to have that information be released to the public in the event anything should happen to them is a great way to stay safe.
A nuclear dead man’s switch is a key plot point in Dr. Strangelove.
But what about for the average person? In the past, there was no need for most people to think about something as elaborate as a dead man’s switch. But we live in interesting times, to say the least. In an information society such as ours, whistleblowers have never been more common, and the Internet has significantly blurred the definition of what it means to be a journalist.
For those living under a repressive regime or in a war zone, simply posting to social media can provide the outside world with an unfiltered look at what’s actually happening on the ground. A teenager with a cell phone has the potential to reach a wider audience than the legacy media — a powerful, but dangerous, proposition.
Even if you’re not in the middle of political upheaval, there are still reasons you might want to have previously secret information made available in the event of your death or incapacitation. Perhaps you’d like to send your loved ones a final personal message, or make sure the passwords for all your accounts get in the hands of whoever will be handling your estate.
Of course, one could argue that could be accomplished with little more than a notebook hidden in your sock drawer. But this is Hackaday, and over-engineering is the name of the game. So do you have a dead man’s switch? How is it implemented? Or is the whole idea just a bit too out there for you?
Ever wanted to know how engineers made their calculations before digital calculators were on every workbench? [Richard Carpenter] and [Robert Wolf] have just the thing—a sliderule simulator that can teach you how to do a whole bunch of complex calculations the old fashioned way!
The simulator is a digital recreation of the Hemmi/Post 1460 Versalog slide rule. This was a particularly capable tool that was sold from 1951 to 1975 and is widely regarded as one of the best slide rules ever made. It can do all kinds of useful calculations for you just by sliding the scales and the cursor appropriately, from square roots to trigonometry to exponents and even multi-stage multiplication and divisions.
You can try the simulator yourself in a full-screen window here. It’s written in JavaScript and runs entirely in the browser. If you’ve never used a slide rule before, you might be lost as you drag the center slide and cursor around. Fear not, though. The simulator actually shows you how to use it. You can tap in an equation, and the simulator will both spit out a list of instructions to perform the calculation and animate it on the slide rule itself. There are even a list of “lessons” and “tests” that will teach you how to use the device and see if you’ve got the techniques down pat. It’s the sort of educational tool that would have been a great boon to budding engineers in the mid-20th century. With that said, most of them managed to figure it out with the paper manuals on their own, anyway.
When World of Warcraft was launched in 2004, it became somewhat of a juggernaut in the MMORPG space. Millions of players continue to login every month. [Kelsi Davis] is one such player, but she doesn’t always log in with the regular client anymore. That’s because she put together WoWee—an open-source alternative of her very own.
WoWee is an acronym—World of Warcraft Engine Experiment. Coded in native C++, it’s a homebrewed client that uses a custom OpenGL renderer to display the game world. [Kelsi] notes that it’s strictly an “educational/research” project, built without using any official Blizzard assets, data or code. Instead, it grabs some client data from a legally-obtained install to operate and loads certain assets this way.
It’s currently compatible with the vanilla game as well as The Burning Crusade and Wrath of the Lich King expansions. It should be highlighted how much work this project has already involved—with [Kelsi] needing to recreate various functional minutae in the game, from character creation screens to weather systems and skyboxes. There’s still a lot to do, as well, like adding 3D audio support and making it more interoperable with the quest system.
It’s rare that any MMO gets an open-source client, even less so while the original game is still being actively supported by the developers. Still, we do see some creative hacks in this space.
