Enhancing the Boot Experience: Raspberry Pi Introduces Custom Splash Screens for SPI/I2C Displays

The aesthetic appeal of modern maker projects has undergone a radical transformation. With the rise of the "cyberdeck" movement—a subculture dedicated to building custom, portable, and often retro-futuristic computing devices—enthusiasts are increasingly turning to compact SPI and I2C displays to serve as the primary visual interface for their Raspberry Pi projects. However, the technical challenge of displaying a custom logo or status message during the "dark" seconds of the boot process has historically been a hurdle for developers.

To address this, the Raspberry Pi engineering team has introduced a sophisticated new firmware extension that allows for early-stage display configuration. By leveraging a specialized "little language" and an interpreter embedded directly into the bootloader, users can now render custom splash screens almost immediately after power-on.

The Genesis: Solving the "Dark Boot" Problem

Earlier this year, the spotlight fell on the M5Stack Cardputer Zero, a tiny, CM0-based handheld computer that captured the imagination of the maker community. One of the primary design goals for M5Stack was to present a branded splash screen the moment the device was powered.

Achieving this, however, proved to be an arduous task. Traditionally, waiting for the Linux kernel to initialize and reach a state where it could address a display meant a significant delay—often several seconds of a blank screen. The only alternative was to force the device to run U-Boot as an additional, complex boot step, which added unnecessary overhead and complexity to the startup sequence.

Recognizing the need for a more streamlined solution, the Raspberry Pi team collaborated with summer intern Thomas Griffiths. The mission was clear: develop a firmware extension capable of configuring SPI and I2C-based displays early in the boot sequence. This would allow the device to pull up a splash screen within seconds, significantly enhancing the perceived responsiveness of custom handhelds like the Cardputer Zero and the Hackberry Pi.

Chronology of Development

The development cycle for this feature was marked by a shift in philosophy regarding how the bootloader handles peripheral initialization.

1. Initial Prototyping: The team began by analyzing the existing Linux drivers for SPI/I2C panels. They found that while these drivers were robust, they were far too heavy to be ported into the pre-kernel boot environment.
2. The "Little Language" Concept: Drawing inspiration from Noralf Trønnes’s mipi-dbi language—a standard for layout and syntax in Linux display drivers—the team began crafting a minimalist, domain-specific language (DSL).
3. Interpreter Implementation: The team designed a lightweight interpreter that could reside within the bootloader binary. This interpreter would read a compiled script containing the necessary initialization sequences for specific hardware.
4. Integration and Testing: Throughout the summer, the team tested the implementation against various panels, including the ST7789 display controller, ensuring that the bootloader could execute these scripts before the operating system even began to load.
5. Beta Release: As of late 2024, the feature has transitioned into the Raspberry Pi firmware beta, allowing early adopters to integrate custom visuals into their boot sequences.

The Technical Architecture: A New "Little Language"

At the heart of this update is a specialized language that allows for the precise control of SPI and I2C buses. While the syntax is heavily influenced by existing mipi-dbi standards, the Raspberry Pi team took several liberties to optimize the architecture for the bootloader environment.

Syntax and Flexibility

The language is designed to be highly declarative. Users define their bus parameters—such as Clock Polarity (CPOL), Clock Phase (CPHA), Chip Select (CS) pins, and frequency—and then issue a series of commands to the display’s internal registers.

Because the data is statically compiled into the binary, the system avoids the need for heavy filesystem access during the most critical, early seconds of the boot process. This "dump" methodology allows for incredible versatility; the system is not limited to mere image displays. By treating the SPI interface as a generic bit-banging tool, developers have managed to control everything from seven-segment LED displays to even, in experimental cases, receipt printers.

Example: Driving a Seven-Segment Display

The following script illustrates how the language is used to initialize an LED driver and display the word "HELLO":

# Define the SPI bus interface
define mled spi [copi 10] [cipo 9] [sclk 11] [cs 8] [freq 1000000]

# Initialize the display controller registers
mled 0x0c 0x00
mled 0x09 0x00
mled 0x0b 0x07
mled 0x0a 0x08
mled 0x0f 0x00

# Write characters to the display registers
mled 0x01 0x00
mled 0x02 0x00
mled 0x03 0x7e # H
mled 0x04 0x0e # E
mled 0x05 0x0e # L
mled 0x06 0x4f # L
mled 0x07 0x37 # O
mled 0x08 0x00

# Final command to activate the display
mled 0x0c 0x01

Supporting Data and Flexibility

The power of this implementation lies in its abstraction. By allowing users to define arbitrary SPI transactions, the team has essentially provided a "universal" tool for pre-kernel hardware interaction. During the testing phase, the engineering team demonstrated the capability of oversampling SPI to bit-bang UART protocols. This proved that the bootloader could be used to send commands to external peripherals—such as a thermal receipt printer—long before the OS is ready to handle input/output.

This flexibility is crucial for the modern maker. Whether it is a professional medical device requiring a static logo or a hobbyist project that prints a status report on a receipt printer upon power-up, the bootloader now serves as a canvas for the developer’s imagination.

Official Guidance and Beta Access

For users eager to experiment with this feature, the Raspberry Pi Foundation has provided a structured path for integration. As this remains a beta feature, it is not enabled by default in the stable production firmware.

Steps to Enable:

1. System Update: Ensure the OS is up to date by running sudo apt update and sudo apt full-upgrade. It is highly recommended to start with a fresh image of the latest Raspberry Pi OS.
2. Accessing Beta: Execute sudo raspi-config, navigate to the "Advanced Settings" menu, and select "Beta Access" to pull down the latest firmware binaries.
3. Compiling Splash Files: Utilize the splashasm utility located in the raspberrypi/utils GitHub repository. This tool converts configuration scripts into the necessary binary format.
4. Linking: Once the binary is placed in the boot firmware folder, a reference must be added to the config.txt file to instruct the bootloader to execute the script.

Detailed documentation is maintained within the splashasm folder of the official utils repository, providing a roadmap for those looking to create their own custom startup routines.

Implications for the Maker Community

The release of this firmware extension is more than just a convenience feature; it represents a fundamental change in how the community views the "boot sequence." By reducing the barrier to entry for custom hardware initialization, Raspberry Pi is encouraging a higher standard of finish for DIY devices.

Industrial Design and Professionalism

For the hobbyist, a custom splash screen provides a sense of professional polish, transforming a "bare metal" prototype into a coherent, branded product. For small businesses and industrial designers using the Raspberry Pi Compute Module in bespoke enclosures, this feature provides a low-latency way to communicate system status, error states, or corporate branding without the need for complex, resource-heavy software stacks.

Future Outlook

As the cyberdeck trend continues to grow, we can expect to see an explosion of creative boot-time visuals. The Raspberry Pi Foundation’s decision to open this functionality to the community demonstrates a continued commitment to providing the tools necessary for creative exploration.

By shrinking the "dark time" at the start of the boot process, developers can now ensure that their devices feel alive and responsive from the very first microsecond. As the community begins to explore the limits of the splashasm language—likely pushing into complex animations and interactive boot menus—the line between a simple development board and a fully realized consumer electronic device continues to blur.

With this update, Raspberry Pi once again confirms that its focus remains not just on the performance of the silicon, but on the empowerment of the people who use it to build the future of computing.