Read the original article here.

---

Understanding Open-Source Firmware: A Foundation for Building Computers from Scratch

Building a computer from scratch involves understanding every layer, from the physical silicon up to the operating system. One of the most fundamental, yet often overlooked, layers is firmware. This resource delves into open-source firmware, explaining what it is, why it's crucial, and how it fits into the intricate process of bringing hardware to life – a process essential for anyone exploring the "lost art" of low-level computing.

What is Firmware?

Before we discuss open-source firmware, let's define firmware itself.

Firmware: Low-level software permanently stored on a hardware device's non-volatile memory (like ROM, EEPROM, or Flash memory). It provides the essential instructions for the hardware to boot up, initialize its components, and perform basic input/output operations. Think of it as the device's initial "brain" or "startup instructions."

Unlike software installed on a hard drive, firmware is deeply embedded within the hardware chip itself. It's the very first code that runs when you power on a device. For a personal computer, this traditionally includes the BIOS (Basic Input/Output System) or, more recently, the UEFI (Unified Extensible Firmware Interface). However, firmware exists on countless devices: routers, keyboards, hard drives, graphics cards, microcontrollers, and much more.

The primary purpose of firmware is to prepare the hardware to a state where more complex software, like an operating system or application, can be loaded and executed. It handles tasks like:

• Initializing Hardware: Detecting and configuring essential components like the CPU, memory, storage controllers, and basic peripherals.
• Performing Self-Tests: Ensuring critical hardware components are functioning correctly (Power-On Self-Test or POST).
• Providing Basic Interfaces: Offering fundamental routines for reading from disks, writing to the screen (in simple text mode), or handling keyboard input before a full operating system takes over.
• Bootstrapping: Finding and loading the next stage of the boot process, which is typically a bootloader residing on a storage device.

Proprietary vs. Open-Source Firmware

Firmware can be broadly categorized based on its licensing and accessibility:

Proprietary Firmware: Firmware whose source code is kept secret by the manufacturer or vendor. Users receive only the compiled, executable version (binary blob) and have no access to the underlying code. It is published under restrictive licenses or End-User License Agreements (EULAs).

Open-Source Firmware: Firmware whose source code is publicly available under an open-source license. This allows anyone to view, study, modify, and distribute the code, provided they adhere to the terms of the specific license.

The vast majority of consumer electronics, including personal computers, traditionally ship with proprietary firmware. This is often seen as a necessity by manufacturers to protect intellectual property, control the user experience, and ensure compatibility only with specific, tested hardware configurations. However, this approach creates a "black box" at the most fundamental level of the system.

Open-source firmware offers an alternative, driven by principles of transparency, user control, and community collaboration.

Why Open-Source Firmware is Important for Building from Scratch

For someone interested in the "lost art" of building computers from scratch, understanding and potentially using open-source firmware is invaluable for several reasons:

1. Transparency and Deep Understanding: Proprietary firmware is opaque. You can't see how the hardware is being initialized or what checks are being performed. Open-source firmware lifts this veil, allowing you to study the code and understand the low-level interactions between software and hardware. This is critical for truly understanding how a computer starts up.
2. Control and Customization: With open-source firmware, you have the power to modify the boot process. You can strip out unnecessary features, add support for custom or legacy hardware, optimize boot times, change default settings, or even embed diagnostic tools directly into the boot process. This level of control is impossible with proprietary solutions.
3. Debugging Low-Level Issues: When building or working with custom, vintage, or non-standard hardware, encountering issues at the very first stage of boot is common. Debugging proprietary firmware is extremely difficult or impossible without vendor tools (which are rarely available). With open-source firmware, you can add debugging output, modify initialization sequences, and gain insights into exactly where the boot process fails.
4. Support for Niche or Older Hardware: Manufacturers often drop support for older hardware or never provide firmware for niche use cases. Open-source firmware projects can breathe new life into such hardware by providing modern, functional firmware. This is particularly relevant if your "from scratch" project involves older components.
5. Security and Trust: A "black box" can potentially hide vulnerabilities, backdoors, or unwanted features. Open-source firmware, subject to community review, offers the potential for greater security and trustworthiness through transparency, although the security of any project depends on the activity and diligence of its community.
6. Education: Working with open-source firmware development provides unparalleled insight into computer architecture, hardware initialization, memory management, and the intricacies of the boot process. It's a hands-on masterclass in how computers fundamentally work.

Firmware's Place in the Boot Process

To appreciate the role of firmware, consider the typical boot sequence of a computer:

1. Power On: The CPU receives power and starts executing code from a fixed location, which points to the beginning of the firmware code (usually located in SPI flash memory on the motherboard).
2. Firmware Execution: The firmware takes over.
   • It performs the Power-On Self-Test (POST), checking essential hardware like the CPU, RAM, and graphics card.
   • It initializes core hardware components (memory controllers, PCIe buses, USB controllers, etc.).
   • It enumerates and configures detected devices.
   • It presents a basic interface (like a setup utility/BIOS setup screen).
   • It finds a bootable device according to a configured boot order.
3. Bootloader: The firmware loads a small program called a bootloader from the selected storage device (e.g., GRUB, NTLDR, systemd-boot).
4. Operating System: The bootloader then loads the main operating system kernel into memory and hands control over to it.

In this sequence, the firmware is the critical first step. It's the foundation upon which the entire software stack is built. Without functional firmware, the computer is inert silicon and plastic.

Major Open-Source Firmware Projects

While the Wikipedia list is brief, several key open-source firmware projects are highly relevant, especially in the context of personal computers and embedded systems:

• coreboot:

  coreboot: A project aiming to replace proprietary BIOS/UEFI firmware on traditional computers. It's designed for extremely fast booting by performing a minimal amount of hardware initialization, then typically handing off control to a "payload" (like SeaBIOS or a Linux kernel). coreboot is a cornerstone of open-source firmware for PCs and laptops. Its goal is speed and transparency. It moves much of the hardware initialization complexity (like memory training) into loadable modules, and its core is much smaller than typical proprietary firmware. It supports a range of motherboards, though compatibility is determined board-by-board.

• Libreboot:

  Libreboot: A distribution of coreboot that strictly adheres to the Free Software Foundation's guidelines. It removes proprietary "binary blobs" (pre-compiled, closed-source code often required by coreboot for specific hardware initialization, like memory controllers or CPU microcode updates). Libreboot is ideal for users seeking maximum freedom and transparency, avoiding any closed-source components in the boot process. This strictness means it supports fewer motherboards than coreboot, as many modern chipsets require blobs for basic initialization.

• SeaBIOS:

  SeaBIOS: An open-source implementation of a 16-bit x86 BIOS. It is often used as a "payload" by coreboot, providing the traditional BIOS interface and compatibility features (like interrupt handlers) needed to boot older operating systems or bootloaders that expect a standard BIOS environment. While coreboot focuses on initialization speed and minimalism, SeaBIOS provides the compatibility layer. When coreboot finishes initializing hardware, it can launch SeaBIOS, which then proceeds with finding and loading a bootloader as a traditional BIOS would.

• LinuxBoot:

  LinuxBoot: A firmware approach that replaces traditional firmware payloads (like UEFI or SeaBIOS) with a Linux kernel. The initial firmware (often a slimmed-down coreboot) initializes just enough hardware to load and run a small, customized Linux kernel. This kernel then handles further hardware initialization, finds the main operating system, and boots it using standard Linux drivers and tools. LinuxBoot leverages the vast hardware support already present in the Linux kernel. This can potentially speed up boot times and allows for much more powerful debugging and management tools to be available very early in the boot process. It's gaining traction in server environments.

• U-Boot:

  Das U-Boot: A primary bootloader and firmware for embedded systems (often based on ARM, PowerPC, MIPS, etc., though also supports x86). It provides a command-line interface to load kernels from various storage media (NAND, SD card, network) and supports networking, USB, and other peripherals. If your "from scratch" project involves designing or working with single-board computers or custom embedded hardware (like a custom router, set-top box, or microcontroller project), U-Boot is a highly relevant open-source firmware project.

Other Examples from the Source: The list provided in the source also includes examples showing the breadth of open-source firmware beyond the main system boot:

• OpenWrt and DD-WRT: Replacement firmware for Wi-Fi routers, providing advanced networking features and customization.
• Marlin: Firmware specifically for 3D printers, running on microcontrollers (often Arduino-based boards), controlling motors, heaters, and sensors.
• Rockbox: Replacement firmware for various digital audio players, adding features and supporting more audio formats.
• QMK: Open-source firmware for keyboards, allowing deep customization of key mappings, layers, and RGB lighting.
• PinePhone LTE modem firmware: Firmware for a specific piece of hardware (a cellular modem), highlighting that even individual components can have open-source firmware options.

These examples illustrate that "firmware" isn't limited to the main motherboard BIOS/UEFI; it's the essential low-level code for almost any piece of hardware.

Challenges and Considerations

While open-source firmware offers significant advantages for the enthusiast building from scratch, it's not without challenges:

• Hardware Specificity: Firmware is inherently tied to the exact hardware revision. Porting or configuring open-source firmware for a specific motherboard or device requires deep knowledge of that hardware's datasheets and initialization sequences.
• Complexity: The code is low-level, dealing directly with hardware registers, memory timings, and power states. Development requires significant expertise in computer architecture and often assembly language or C.
• Building and Flashing: Compiling and installing (flashing) open-source firmware onto the hardware can be a complex, multi-step process. Incorrect flashing can "brick" a device, rendering it unusable.
• Binary Blobs: As mentioned with Libreboot, achieving truly 100% open-source firmware can be difficult or impossible on modern hardware due to manufacturers providing necessary initialization code only as proprietary binary blobs. coreboot often requires these.

Conclusion

In the context of "The Lost Art of Building a Computer from Scratch," understanding and engaging with open-source firmware is not just an option; it's a gateway to the deepest levels of hardware control and comprehension. While proprietary firmware remains the standard in commercial products, open-source alternatives like coreboot, Libreboot, SeaBIOS, and LinuxBoot empower enthusiasts to peel back the layers, gain full control over the boot process, customize their hardware's behavior, and truly understand how a computer comes to life from the moment power is applied. It's a challenging but rewarding path for those seeking mastery over their machines.