Fuzix OS 0.4: A Modular Operating System for Retro and Small Systems

The Fuzix operating system, designed for small and retro computer systems, has reached version 0.4 with notable improvements to its core architecture and expanded platform support. This release represents a significant evolution in the project's approach to creating a Unix-like environment for resource-constrained systems.

Core Improvements in Fuzix 0.4

The most significant change in this release is the complete reworking of the networking layer to be more modular. This redesign allows the networking stack to potentially run in a separate address space from the kernel on 8-bit machines, a crucial enhancement for systems with limited memory. The modular approach provides better isolation and could enable more sophisticated networking capabilities on platforms that previously couldn't support them.

Executable formats have undergone substantial changes in this release. The 8080, 8085, and Z80 binary formats are now properly unified, allowing 8085 and Z80 processors to run 8080 binaries directly. Similarly, the 68HC11 and 6803 formats have been aligned so that the 68HC11 can execute 6803 binaries. For 32-bit systems, the project has moved from a modified Linux binflt format to a.out with extensions for handling relocation maps, providing a more stable foundation for future development.

The build process has been simplified with the addition of a "make diskimage" target that automates the creation of bootable system images. While the toolchains remain challenging due to their obscurity and frequent breaking changes, the system build process is now more accessible to developers who don't need to understand the intricate details of merging system components.

Processor Support Ecosystem

Fuzix 0.4 supports an impressive array of processors, ranging from classic 8-bit designs to modern microcontrollers:

6303/6803: Supported by the CC68 compiler chain, derived from cc65 and specifically designed for Fuzix. Currently targets the RCbus 6803/6303 processor card. The port lacks floating point support, but the underlying soft float routines could be added by a motivated developer.

6502/65C02/65C816: Supported by cc65 (v2.18 or later). Due to compiler limitations, floating point is not supported. The 65C816 is treated as an enhanced 65C02 due to the lack of an open-source 65C816 compiler. This port targets RCbus 65C02/65C816 cards and the PZ1.

6809: Uses gcc 6809 and lwtools, supporting classic systems like Dragon, Tandy COCO, Thomson, and RCbus machines. Some users may need to use older lwtools versions (e.g., 4.13) to avoid segmentation faults.

68HC11: The final generation of the 6800 processor line, this port uses gcc with a different ABI than the 6800/6803. It can run 6800 and 6803 binaries but not 6303 code. Currently targets the Mini11 SBC and RCbus 68HC11 card.

68000: This port has become more stable with a sensible binary format. It supports processors up to 68EC020 and includes an additional memory model for systems with limited resources. It's now possible to run Fuzix on a 128K system without relying on fast disks.

8080/8085: The 8080 port uses a new Fuzix C compiler that may still have bugs. The 8085 port now uses the full instruction set (including undocumented features) and shows several times better performance than the pure 8080 build. Floating point support is still pending.

ARM: Supports ARM M0 (Raspberry Pi Pico) and ARM M4 (DK-TM4C129X and EK-TM4C129X) targets.

Z80/Z180/64180/Z84C1X: Supported using a fork of SDCC 3.8. The newer SDCC versions have changed calling conventions, preventing an upgrade at this time.

Platform Landscape and Naming Changes

The Fuzix project has undergone some organizational changes with the N8VEM project rebranding as 'Retrobrew' at the request of its founder. The 0.4 release completes the transition from N8VEM naming. There's now a clear distinction between RC2014 (the product line) and RCbus (the bus standard), which has been extended beyond its original concept.

Several systems have been dropped for this release due to lack of available testers:

• Pentagon
• Pentagon 1024
• Scorpion

The project maintains an impressive list of supported systems, including:

• 2063 (John Winan's Z80 Retro system)
• Ampro Littleboard (classic Z80 CP/M board)
• Amstrad NC100/NC200 (portable word processors)
• Various Dragon and COCO systems
• MSX systems
• Nascom II/III with CP/M
• Raspberry Pi Pico
• Sinclair ZX Spectrum (multiple variants)
• TRS-80 systems
• And many more specialized retro platforms

Building and Development Experience

While the build process has improved, it still presents challenges. The make environment remains problematic, requiring "make clean" when switching processors and "make kclean" when modifying kernel configuration options or switching targets. Many make rules have been merged, which should make dependency management more tractable in future versions.

The project acknowledges that toolchains are a persistent pain point. Many are obscure, and those that aren't tend to break regularly, forcing the use of specific versions. This creates a moving target for developers trying to build and port Fuzix to new platforms.

Future Directions

Several processor ports are in various stages of development:

• 6800 (work in progress)
• 8086/8088/80C188/80C186 (basic sketches for future ports)
• ESP32 (experimental)
• RiscV 32 (toolchain testing)
• TMS9995 (compiler debugging)
• Z280 (work in progress)

The project's GitHub repository contains source code, licenses, and install images for version 0.4 targets. Each platform has detailed README files in the Kernel/platform-* directories with specific build instructions.

Fuzix represents an ambitious effort to bring Unix-like functionality to the smallest and most resource-constrained systems. The 0.4 release demonstrates significant progress in making the system more modular, easier to build, and compatible with a wider range of retro computing platforms. As the retro computing community continues to grow, projects like Fuzix play an important role in preserving and extending the capabilities of classic hardware.

For those interested in exploring Fuzix further, the GitHub repository contains all the source code, documentation, and build instructions needed to get started with this fascinating operating system.