Unreleased Amiga Hardware Plays MP3s

The MP3 file type has been around for so long, and is supported by essentially all modern media software and hardware, that it might be surprising to some to learn that it’s actually a proprietary format. Developed in the late 80s and early 90s, it rose to prominence during the Napster/Limewire era of the early 00s and became the de facto standard for digital music, but not all computers in these eras could play this filetype. This includes the Amigas of the early 90s, with one rare exception: this unreleased successor to the A3000 with a DSP chip, which now also has the software to play back these digital tunes.

The AA3000, developed as a prototype by Commodore, was never released to the general public. Unlike the original A3000 this one would have included a digital signal processing chip from AT&T called the DSP3210 which would have greatly enhanced its audio capabilities. A few prototype boards did make it out into the hands of the public, and the retrocomputing scene has used them to develop replicas of these rare machines. [Wrangler] used one to then develop the software needed for the MPEG layer 2 and 3 decoder using this extra hardware, since the original Amiga 3000 was not powerful enough on its own to play these files back.

If you want to follow along with the community still developing for this platform there’s a form post with some more detail for this specific build (although you may need to translate from German). [Wrangler] additionally points out that there are some limitations with this implementation as well, so you likely won’t get Winamp-level performance with this system, but for the Amiga fans out there it’s an excellent expansion of this computer’s capabilities nonetheless.

Thanks to [Andy] for the tip!

Continue reading “Unreleased Amiga Hardware Plays MP3s”

Reverse Engineering LEGO Island

While LEGO themed video games have become something of a staple, in 1997 they were something of an odity. LEGO Island became the first LEGO video game released outside of Japan in 1997 and become something of a hit with over one million copies sold. The game was beloved among fans and set the stage for more LEGO video games to come. In an effort of love, [MattKC] put together a team to reverse engineer the game.

The team set out with the intent to create a near perfect recreation of the codebase, relying on custom made tools to run byte checks on the rewrite compilation and the original binary. While the project is functionally complete, [MattKC] believes it is impossible to get a byte accurate codebase. This is because of what the team called “compiler entropy.” Strange behaviors exists inside of Microsoft’s Visual C++ compiler of the era, and small changes in the code have seemingly random effects to unrelated parts of the binary. To mitigate this issue would likely require either partially reverse engineering Visual C++ or brute forcing the code, both of which would take a large amount of effort and time for no real benefit.

Continue reading “Reverse Engineering LEGO Island”

Now KDE Users Will Get Easy Virtual Machine Management, Too

If you work with virtual machines, perhaps to spin up a clean OS install for testing, historically you have either bitten the bullet and used one of the commercial options, or spent time getting your hands dirty with something open source. Over recent years that has changed, with the arrival of open source graphical applications for effortless VM usage. We’ve used GNOME Boxes here to make our lives a lot easier.  Now KDE are also joining the party with Karton, a project which will deliver what looks very similar to Boxes in the KDE desktop.

The news comes in a post from Derek Lin, and shows us what work has already been done as well as a roadmap for future work. At the moment it’s in no way production ready and it only works with QEMU, but it can generate new VMs, run them, and capture their screens to a desktop window. Having no wish to join in any Linux desktop holy wars we look forward to seeing this piece of software progress, as it’s a Google Summer Of Code project we hope there will be plenty more to see shortly.

Still using the commercial option? You can move to open source too!

The Mouse Language, Running On Arduino

Although plenty of us have our preferred language for coding, whether it’s C for its hardware access, Python for its usability, or Fortran for its mathematic prowess, not every language is specifically built for problem solving of a particular nature. Some are built as thought experiments or challenges, like Whitespace or Chicken but aren’t used for serious programming. There are a few languages that fit in the gray area between these regions, and one example of this is MOUSE, which can now be run on an Arduino.

Although MOUSE was originally meant to be a minimalist language for computers of the late 70s and early 80s with limited memory (even for the era), its syntax looks more like a more modern esoteric language, and indeed it arguably would take a Python developer a bit of time to get used to it in a similar way. It’s stack-based, for a start, and also uses Reverse Polish Notation for performing operations. The major difference though is that programs process single letters at a time, with each letter corresponding to a specific instruction. There have been some changes in the computing world since the 80s, though, so [Ivan]’s version of MOUSE includes a few changes that make it slightly different than the original language, but in the end he fits an interpreter, a line editor, graphics primitives, and peripheral drivers into just 2 KB of SRAM and 32 KB Flash so it can run on an ATmega328P.

There are some other features here as well, including support for PS/2 devices, video output, and the ability to save programs to the internal EEPROM. It’s an impressive setup for a language that doesn’t get much attention at all, but certainly one that threads the needle between usefulness and interesting in its own right. Of course if a language where “Hello world” is human-readable is not esoteric enough, there are others that may offer more of a challenge.


Image Credit: Maxbrothers2020

MCP Blender Addon Lets AI Take The Wheel And Wield The Tools

Want to give an AI the ability to do stuff in Blender? The BlenderMCP addon does exactly that, connecting open-source 3D modeling software Blender to Anthropic’s Claude AI via MCP (Model Context Protocol), which means Claude can directly use Blender and its tools in a meaningful way.

MCP is a framework for allowing AI systems like LLMs (Large Language Models) to exchange information in a way that makes it easier to interface with other systems. We’ve seen LLMs tied experimentally into other software (such as with enabling more natural conversations with NPCs) but without a framework like MCP, such exchanges are bespoke and effectively stateless. MCP becomes very useful for letting LLMs use software tools and perform work that involves an iterative approach, better preserving the history and context of the task at hand.

Unlike the beach scene above which used 3D assets, this scene was created from scratch with the help of a reference image.

Using MCP also provides some standardization, which means that while the BlenderMCP project integrates with Claude (or alternately the Cursor AI editor) it could — with the right configuration — be pointed at a suitable locally-hosted LLM instead. It wouldn’t be as capable as the commercial offerings, but it would be entirely private.

Embedded below are three videos that really show what this tool can do. In the first, watch it create a beach scene using assets from a public 3D asset library. In the second, it creates a scene from scratch using a reference image (a ‘low-poly cabin in the woods’), followed by turning that same scene into a 3D environment on a web page, navigable in any web browser.

Back in 2022 we saw Blender connected to an image generator to texture objects, but this is considerably more capable. It’s a fascinating combination, and if you’re thinking of trying it out just make sure you’re aware it relies on allowing arbitrary Python code to be run in Blender, which is powerful but should be deployed with caution.

Continue reading “MCP Blender Addon Lets AI Take The Wheel And Wield The Tools”

Animated Widgets On Apple Devices Via A Neat Backdoor

If you’ve ever looked at widgets on your iPhone, you’ve probably noticed they’re largely static, save for a few first-party apps. By and large, third party developers are not supposed to be able to animate them. However, [Bryce Bostwick] found a workaround.

You might be confused as to the idea of animated widgets, but it’s quite simple. For example, think of a clock app with a widget in which the hands always display the current time, or a calendar app with an icon that shows the current date. Apple’s own apps have long been able to do this, but the functionality has mostly been locked out for third parties.

One way to get around this limitation is by using a timer feature baked into the widget functionality. The timer tool is one of the few ways that third-party apps are allowed to do animation. By running a timer with a custom font, you can display various graphical elements instead of numbers counting down to create a hacky animation that updates every second.

However, there are even more advanced techniques that can get you faster, smoother animations. [Bryce] breaks down the private techniques used to rotate the clock hands on Apple’s own widget, and how to use those tools for your own purposes. It takes some sneaky Xcode tricks and a bit of math to make it fully flexible for doing arbitrary animations, but it works surprisingly well.

Will this backdoor last ? Well, Apple is always updating and changing iOS and its associated software, so don’t expect it to work forever.

Continue reading “Animated Widgets On Apple Devices Via A Neat Backdoor”

Simulating High-Side Bootstrap Circuits With LTSpice

LTSpice is a tool that every electronics nerd should have at least a basic knowledge of. Those of us who work professionally in the analog and power worlds rely heavily on the validity of our simulations. It’s one of the basic skills taught at college, and essential to truly understand how a circuit behaves. [Mano] has quite a collection of videos about the tool, and here is a great video explanation of how a bootstrap circuit works, enabling a high-side driver to work in the context of driving a simple buck converter. However, before understanding what a bootstrap is, we need to talk a little theory.

Bootstrap circuits are very common when NMOS (or NPN) devices are used on the high side of a switching circuit, such as a half-bridge (and by extension, a full bridge) used to drive a motor or pump current into a power supply.

A simple half-bridge driving illustrates the high-side NMOS driving problem.

From a simplistic viewpoint, due to the apparent symmetry, you’d want to have an NMOS device at the bottom and expect a PMOS device to be at the top. However, PMOS and PNP devices are weaker, rarer and more expensive than NMOS, which is all down to the device physics; simply put, the hole mobility in silicon and most other semiconductors is much lower than the electron mobility, which results in much less current. Hence, NMOS and NPN are predominant in power circuits.

As some will be aware, to drive a high-side switching transistor, such as an NPN bipolar or an NMOS device, the source end will not be at ground, but will be tied to the switching node, which for a power supply is the output voltage. You need a way to drive the gate voltage in excess of the source or emitter end by at least the threshold voltage. This is necessary to get the device to fully turn on, to give the lowest resistance, and to cause the least power dissipation. But how do you get from the logic-level PWM control waveform to what the gate needs to switch correctly?

The answer is to use a so-called bootstrap capacitor. The idea is simple enough: during one half of the driving waveform, the capacitor is charged to some fixed voltage with respect to ground, since one end of the capacitor will be grounded periodically. On the other half cycle, the previously grounded end, jumps up to the output voltage (the source end of the high side transistor) which boosts the other side of the capacitor in excess of the source (because it got charged already) providing a temporary high-voltage floating supply than can be used to drive the high-side gate, and reliably switch on the transistor. [Mano] explains it much better in a practical scenario in the video below, but now you get the why and how of the technique.

We see videos about LTSpice quite a bit, like this excellent YouTube resource by [FesZ] for starters.

Continue reading “Simulating High-Side Bootstrap Circuits With LTSpice”