Among all the machines of the 8-bit home computer era which booted straight to a BASIC prompt, there were a very few that went their own way with another language. The Jupiter Ace springs immediately to mind, a diminutive Z80-based machine similar to Sinclair’s ZX81, which booted to FORTH.

The Ace wasn’t a commercial success, but what would have happened had it booted to a more accessible language? It’s a question [jordanhubbard] appears to be trying to answer, with an OS that boots to a Python interpreter.. The OS is Python, and everything on top of it uses the interpreter. Better still, it has a GUI mode.

The OS boots on an x86-64 platform or in QEMU, and appears to have been created using an LLM. There are two build options for the GUI version or the interpreter version. It provides a set of UNIX-like commands for interacting with the OS and disk, something which brings back memories of disk-based systems back in the BASIC days. We’re surprised to see no screenshots of the GUI in action though, an omission he’d do well to correct, we think.

It’s fair to say that in 2026 this is more a bit of fun than a serious OS contender, but maybe someone will run with it. It has competition too, not so long ago we featured a similar OS that runs a BASIC interpreter.

Nintendo has made many game consoles in its long history — one that famously overlaps that of the Ottoman Empire — but only one of them was ever Super. It’s that console, the Super Nintendo Entertainment System, that [Inkbox] has decided to delve deeply into as he crafts a game in assembly using all the hardware tricks he can.

Hardware tricks he’ll need, given he’s limited to the two 64 kB RAM banks and 3.58 MHz Ricoh 6502-based CPU. Even the 4 MB limit he sets for a historically-accurate homemade cartridge seems positively claustrophobic by modern standards. The game he’s after making is a top-down adventure game a la Zelda, and [Inkbox] gets right into the weeds explaining how the SNES works as he shows his work in this nearly hour long video. If you’re looking for a deep dive into the architecture, along with how it is meant to be used, you could certainly find worse sources. Everything from the different graphics modes to what registers handle sound are covered in this and the previous video in the series.

We can’t help but call out his dedication to open source — the SNES Sound Engine he has put up on GitHub looks like it could be a real asset to anyone else doing this kind of homebrew. The game itself is on itch.io and is pay-what-you-want.

[Inkbox] doesn’t just limit himself to the SNES’s 6502-esqe assembly — he’s done impressive work in x86 ASM, too.

The progression of the web browser from a tool for simple static information browsing into a do-everything computing environment has been inexorable, with package after package making the jump. Today it’s the turn of GNU Radio Companion, lowering the barrier to software defined radio considerably. It’s the work of [Marc Lichtman], who’s name you may recall if you have ever used pysdr.org.

Loading it up gives you a very familiar window if you’re used to GNU Radio Companion, and it comes with a set of example flowgraphs that cover a large range of applications. It supports a collection of software-defined radios (SDRs) including the well-known RTL-SDR, and if that’s not enough it can also use your sound card. There is even a set of recorded off-air captures to experiment with.

We’ve spent a while here playing with it, and it does everything we’re used to from the version outside the browser. The only thing we’re told it won’t do is work with a networked SDR, but that’s no deal breaker.

Thanks [Marcus Müller] for the tip.

Word processors and editors are a funny thing. It doesn’t really matter what’s “best,” whatever that means. If you have finger memory built up for one program, it’s painful to change. That’s why most of us don’t learn how to type on a Dvorak keyboard and why [George R. R. Martin] writes with WordStar. Many people of a certain age have a deep memory of WordStar. Now you can run it on a modern machine or even in your browser without a lot of trouble, thanks to [nampara-ai].

The idea is simple. Take a vintage copy of WordStar for MSDOS, wrap it with DOSBox, and package it up with some basic scripts for Linux, Mac, or Windows. In addition, there’s a WebAssembly version for the browser if you’re into that sort of thing.

On Linux, the wordstar.sh file grabs the current directory and sends it to launch.sh. This script makes sure everything is ready, builds a DOSBox config file from a template, and launches everything. The only problem is that it doesn’t correctly resolve symlinks if you want a link on your path. Luckily, that’s easy to fix:

#!/usr/bin/env bash
 # Run me to launch WordStar 4.0 on Linux:  ./wordstar.sh
DIR="$(realpath "$0")"
DIR="$(dirname $DIR)"
cd "$DIR"
DIR="$(pwd)"

#DIR="$(cd "$(realpath "$(dirname "$0"))" && pwd)"
"$DIR/native/lib/launch.sh"

Practical? No. Irreplaceable? Not really. You could run WordStar under RunCPM or set up DOSBox yourself. You can even find a sort of modern version to run, if you prefer. But for just a quick way to get it running easily, it is hard to beat. If you want to play with the web version, it is easy to navigate to the web subdirectory and run Python:

python3 -m http.server 5309

Then you can point your browser to http://localhost:5309, and you are in business. Or, get a flavor for it from [TigerClawTV]’s walk-through video below.

After just a little over 25 years of the Haiku project trying to keep the BeOS spirit alive, the team has now released Beta 6. The spicy details of what is now all better can naturally be found in the detailed release notes. Part of the size of these release notes is due to the previous beta release being two years ago, though nightly builds have kept Haiku users appeased in the meantime.

The headline features that are new compared to the previous release include the ability to run the Firefox browser and derivatives, QEMU hardware virtualization using the NetBSD Virtual Machine Monitor (NVMM), improved POSIX and hardware compatibility, as well as many bug fixes. Unfortunately 64-bit ARM support still has to wait a bit longer.

Naturally, such a joyful new release wouldn’t go unnoticed by [Action Retro], who decided to celebrate by installing this new release on a stack of old laptops that he bought for a dollar each. With system requirements starting at a Pentium II with 256 MB of RAM, it’s very zippy to install and boot on. As [Action Retro] noticed, a fresh install on a random 2000s Asus laptop both WiFi and audio worked out of the box.

Wrestling through his e-waste pile of laptops, the functional laptops provided a pretty good experience, making these at least an excellent target for a fresh Haiku install as a daily driver.

We looked at Beta 5 and the nightlies back in 2024, with recently attempts being made to port Nvidia GPU drivers to Haiku, with good results.

A perennial in the esoteric operating system space is ReactOS, a project with its roots in the 1990s which is doing a pretty good job of creating an open source clone of 32-bit Windows. They have a new version out, and it’s acquired some useful features.

Top of the list is a new graphical installer, removing the need for separate live and install ISOs, followed by improvements in video bug fixes and high definition audio drivers and subsystems. There’s a headless server install too, in which the GUI is suppressed. Perhaps most interesting, they are working on version syncing the open-source projects such as WINE on which they rely, meaning with luck that any improvements there will show up in ReactOS.

A while back we took a look at using ReactOS as a daily, and found it to be quirks aside, as usable as you’rd expect a Windows XP clone to be. Given that there are plenty of pieces of hardware and software around that still need an early-2000s era Windows to run, this remains an OS to keep an eye on.

When it comes to building real-world flying vehicles, testing can be arduous and expensive. You have to find somewhere to fly, then you have to contend with environmental conditions and the possibility of damaging your craft if things go wrong. Simulation is a great solution to this, allowing testing without so much risk. To that end, [AlexanderRex] whipped up a platform for testing UAVs from the comfort of your computer desk.

PteroSim is intended as a comprehensive test bench for simulating autonomous aerial vehicles. It can run PX4, ArduPilot, and Betaflight binaries right in the simulator. The autopilot code is given simulated sensor data, and in turn responds with actuator commands, just as it would in a real craft. The simulator runs the flight dynamics using JSBSim, and the resulting scene is rendered in Unreal Engine 5.

If you’ve ever wanted to quickly road test different autopilot settings without heading out to the field or risking hardware, this is a great way to do so. It’s hard to beat the speed of iteration that is possible when testing on the computer on your desk. We’ve featured similar work before, too.

The Cheap Yellow Display (CYD) is a board carrying a slightly older ESP32 variant, a display with a resistive touchscreen, an SD card, and not much else. It’s often used for straightforward microcontroller applications that need a user interface, but that’s not the limit of its possibilities. [Alun Morris] has a CYD on which you can brows an entire offline Wikipedia.

The trick is to take the offline Wikipedia builds from the Kiwix project, and process them further into a custom format suited for a browser firmware on the ESP32. A modern SD card can hold so much data that a full Wikipedia is well within its abilities even with images included.

We like this idea, because it takes the knowledge away from the center of the network to its edge. We expect to see it gaining a following among enthusiasts for offline living, because all that knowledge without a network can only be useful. If you recognize [Alun]’s work, it might be because of his ESP32 web browser.

If there’s one thing that’s guaranteed in the tech world it’s that nothing is guaranteed. From AOL, Netscape, Yahoo, and MySpace, every tech empire seems to eventually fall to ruin. One method to reliably maintain information or online experiences that are lost to whims of computer users and markets is to backup, preserve, and host that information on one’s own computers, and the Kiwix project aims to help make offline backups of favorite websites.

The open-source tool started as a way for users to make their own offline backups of Wikipedia but eventually expanded into having the ability to backup many other sites as well. Wiki-type sites are generally the easiest, but it can also create backups of other sites like StackExchange so that when the Internet goes down or the site vanishes from the world, the information is preserved for use. There are plenty of guides online for setting up Kiwix as well, with it running easily on most Linux systems with or without the help of Docker, as well as versions available for Windows, Android, and Apple platforms.

Although the Kiwix software hosts the website backups, creating the backups needs to be done with another tool called Zimit to create the .zim files Kiwix uses. The Kiwix organization also hosts pre-downloaded .zim files of common websites so each user is not independently crawling Wikipedia on their own, a task that could take months on limited consumer hardware. As for what hardware to ultimately host it on, we might recommend an armageddon-proof machine like this one.

Link shorteners have been a staple of the online world for over two decades now, but they’ve got some issues– for one thing, it’s totally non-transparent where the link actually goes, leaving you open to all sorts of shenanigans, of which RickRolling is probably the best case. For two, your traffic is going through an external service who may have their own nefarious intent. [PortalRunner] had an idea: don’t shorten the link, but compress it.

You see, a traditional URL shortener like tinyurl just generates a random code and associates that with your original link in its database. That’s fine, but you’re relying on a third party database. The alternative is to take the URL, encode it in some way, and apply some compression algorithm to the data. If the encoding and compression are open-source– which [Portal ]’s absolutely are— then you can check yourself before following the link, and/or self-host the whole thing for piece of mind. As a bonus [Portal]’s Ha.mr– that’s pronounced Hammer– also gives you a QR code optimized for easy scanning. QR codes have a specific alphanumeric character set built in, and it isn’t the full UTF-8– if you naively use random text, you’re in byte mode, which needs a lot more QR real estate. Or inverting that, the fewer bits it has to store, the easier a qr code is to scan at the same size. The text version of the compressed links can use UTF-8– including emoticons– but they don’t have to.

The whole project has a “why isn’t everyone doing it this way” vibe about it. We’d probably want to self-host this if we were using it seriously– [Portal] put this together on a lark and makes no promises it will be online forever–but again, this is open source, so we can. [Portal] is using normal compression algorithms here, but if you really want to squeeze text, use a neural net. 

We’ve heard of wave overhangs before. It is a new technique for printing horizontal overhangs with no supports. Building on some other techniques like arc overhangs. The idea is to teach the slicer not to try to draw overhangs in the middle of free space. Instead, when the slicer realizes there is a horizontal overhang, it tries to “grow” the overhang from the main part. You can see an overview in the video below.

For example, imagine printing a letter ‘T’ vertically. The stem of the T is no problem, but when you try to print the arms it will normally need support. But if you could just print the arms starting at the stem with slight overlapping, the arms could grow as they hang onto either the stem or the last overhang line.

That makes sense, but it only works for very simple cases. Arc overhangs can fill more complex cases, but suffer from little dimples at the center of each arc. The realization for wave overhangs is to replace the arcs with waves as you would see in a pond. The waves diffract around holes and corners.

Perfect? Not quite. They are still experimenting with settings, but there seems to be some increase in warping. If you want to experiment, you can download a fork of Orca and contribute your results to the community.

We looked at this technique earlier, but we haven’t seen much about it in practice yet. Let us know in the comments if you’ve tried it and how it worked for you. There are more details in the paper on the subject, or you can jump right to the software.