New World ROM
New World ROM is a firmware architecture implemented in certain Macintosh computers, beginning with the iMac in 1998, that replaces the traditional Macintosh Toolbox ROM on the logic board with a modular bootROM and a Mac OS ROM image loaded into write-protected RAM (known as ROM-in-RAM) from the startup volume.[1] This design, part of the broader NewWorld Architecture, incorporates Open Firmware—a standardized boot environment based on the IEEE 1275 specification—to handle hardware initialization, device configuration, and the transition to the operating system.[1] The NewWorld Architecture marked a significant evolution from earlier "Old World" Macintosh systems, which relied on monolithic ROM chips containing hardcoded addresses, NuBus interfaces, and resource-based drivers like 'DRVR' types.[1] In contrast, New World ROM systems employ a PCI bus for expansion, the Name Registry for dynamic hardware naming and addressing, and native PowerPC drivers in formats such as 'ndrv' and CFM, loaded via the Driver Loader Library during boot.[1] The bootROM itself includes hardware-specific code for power-on self-test (POST), runtime abstraction services (RTAS), and an Open Firmware Forth interpreter, while FCode scripts in PCI expansion ROMs enable autoconfiguration of peripherals like SCSI controllers and Ethernet adapters.[1] This architecture facilitated greater flexibility in system startup, including user-selectable boot volumes through the Startup Disk control panel and support for interrupt handling via an Interrupt Source Tree (IST), which abstracts secondary interrupts for improved portability and reduced latency.[1] Non-volatile RAM (NVRAM) is partitioned according to the Common Hardware Reference Platform (CHRP) standard, allocating space for Mac OS parameters, Apple-specific PRAM, and Open Firmware variables.[1] Applicable to models like the iMac G3, Power Macintosh G3 (Blue & White), and subsequent PowerPC-based systems until the transition to Intel processors, New World ROM enhanced compatibility with PCI hardware and paved the way for advanced features such as hardware cursor support and dynamic display timing managed by the Display Manager.[1]History
Development and Origins
The Macintosh's use of ROM for system software began with the original 128K model in 1984, where read-only memory was chosen over RAM due to its lower cost and the limitations of contemporary storage media like floppy disks. This approach embedded the operating system and Toolbox routines directly into hardware, providing fast initialization but tying software closely to specific machines. As Apple transitioned to PowerPC processors in the mid-1990s, the ROM architecture evolved to address growing complexity and the need for broader compatibility. In 1995, Apple collaborated with IBM and Motorola under the AIM alliance to develop the Common Hardware Reference Platform (CHRP), a standardized architecture for PowerPC-based systems aimed at enabling operating system portability across vendors.[2] This effort built on the PowerPC Reference Platform and incorporated the IEEE 1275-1994 Open Firmware specification, which provided a hardware-abstracted boot environment using Forth-based scripting for device configuration and initialization.[3] CHRP's design emphasized modularity, drawing from IBM's RISC systems and Apple's Macintosh heritage to reduce porting efforts for operating systems like Mac OS, AIX, and Windows NT.[2] The motivations for New World ROM stemmed from CHRP's principles: achieving operating system independence by separating boot firmware from platform-specific code, lowering hardware costs through smaller onboard ROM (shifting the bulk of the 4MB Toolbox image to mass storage), and facilitating future architectural shifts beyond PowerPC.[2] Internally at Apple in the late 1990s, engineers like Paul Resch led the redesign, deciding to split the traditional monolithic ROM into a minimal hardware-specific Boot ROM and a loadable Toolbox ROM image, informed by CHRP's Run-Time Abstraction Services (RTAS).[4] This modular approach, refined through revisions by Wayne Flansburg and contributions from Mark Baumwell and Dave Radcliffe, marked a pivotal internal shift toward standards-compliant firmware.[4]Introduction and Initial Models
The New World ROM made its official debut in 1998 alongside Apple's first iMac, the Bondi Blue model, which was unveiled on May 6 and began shipping on August 15. This all-in-one consumer desktop marked a significant shift in Apple's hardware strategy, replacing the traditional onboard Macintosh Toolbox ROM with a more modular boot ROM approach that loaded essential firmware from the boot drive. The iMac's adoption of New World ROM facilitated compatibility with emerging standards like USB, while eliminating legacy ports such as SCSI to streamline the design, though it retained ADB for peripherals.[5] Following the iMac, subsequent early adopters of New World ROM included the Power Macintosh G3 Blue and White tower, introduced on January 5, 1999; various iMac G3 slot-loading variants produced from 1999 to 2002; and the Power Mac G4 series, which debuted in August 1999. These models extended the New World architecture across Apple's desktop lineup, supporting higher clock speeds and expanded memory configurations. The Blue and White G3, for instance, featured a distinctive translucent case design and served as a professional counterpart to the consumer-oriented iMac.[6] The introduction of New World ROM with the iMac initiated Apple's full transition away from Old World ROM production, which concluded by late 1998 as the last Beige Power Mac G3 models were phased out. From 1999 onward, all new Power Mac desktops and iMacs exclusively utilized New World ROM, aligning with Apple's push toward standardized PCI architecture. In marketing announcements, Apple emphasized the iMac's simplified hardware—such as its integrated components and lack of unnecessary ports—alongside the boot flexibility provided by Open Firmware, which allowed for device-independent startup and easier OS installations. This boot process, powered by Open Firmware, enabled greater interoperability without relying on fixed ROM mappings.[7]Technical Architecture
Core Components
The core components of New World ROM in Apple Macintosh systems, introduced starting with the iMac and Power Macintosh G3 models, consist of a hardware-specific Boot ROM and a file-based Toolbox ROM Image, forming a hybrid firmware architecture that separates low-level initialization from Macintosh-specific routines. This design eliminates the need for a large monolithic ROM on the logic board, instead leveraging mass storage for flexible loading and RAM for execution, which optimizes memory usage and supports evolving hardware.[1] The Boot ROM, typically 1 MB in size,[8] implements a hardware-specific version of Open Firmware (version 3.0 and later, compliant with IEEE 1275-1994) that executes the initial power-on self-test (POST), generates diagnostic signals such as the boot beep, and constructs the device tree to describe the system's hardware configuration. It includes essential, OS-independent code for motherboard devices, such as 'ndrv' and 'nlib' drivers, enabling basic hardware probing and initialization before loading additional components. This ROM resides directly on the logic board and adheres to the IEEE 1275-1994 standard for boot firmware, ensuring portability across processor architectures.[1] Complementing the Boot ROM is the Toolbox ROM Image, a 4 MB compressed file stored on mass storage within the System Folder, which is decompressed and loaded into read-only RAM during startup. Less than 3 MB of this image is actively used for Macintosh-specific APIs, drivers, and boot-time routines—including the USB Manager for handling hubs, keyboards, and mice—freeing over 1 MB of RAM for the operating system. This file-based approach allows for updates without hardware changes and provides access to the Macintosh Toolbox for high-level services like graphics and PRAM management, though drivers must avoid calling these at interrupt levels due to execution constraints.[1][4] Open Firmware in New World ROM features enhancements over prior implementations, including a complete device tree stored in the Name Registry for hierarchical hardware representation and property management, Forth-based scripting for customizable boot control (e.g., via the "bootinfo" file), and plug-and-play drivers that support PCI configuration ROMs for bootable expansion cards. These elements ensure dynamic device autoconfiguration and compliance with IEEE 1275, facilitating seamless integration of peripherals without fixed ROM mappings. The overall hybrid structure—combining the fixed Boot ROM firmware with the loadable Toolbox ROM Image—enables efficient resource allocation and forward compatibility in PowerPC-based systems.[1]Boot Process
The boot process of New World ROM-equipped Macintosh computers begins with the Power-On Self-Test (POST), a hardware initialization phase executed by the boot ROM upon power-up. This includes running preliminary diagnostics such as ROM checksum verification, processor checks, interrupt controller startup, clock configuration, memory controller initialization, NVRAM access, RAM sizing, and L2 cache enabling, culminating in a boot chime to signal readiness.[1] Following POST, Open Firmware activates, probing the I/O buses (including PCI) to detect and enumerate hardware components. It then populates the device tree, a hierarchical Forth-based data structure in RAM that describes the system's hardware configuration, including nodes for built-in ASICs and expansion cards, to facilitate subsequent resource allocation and driver loading.[1] Open Firmware next consults NVRAM environment variables—such asauto-boot?, boot-device, and boot-file—to determine the boot behavior, defaulting to the primary startup volume if unchanged. It loads the "bootinfo" file, a type 'tbxi' resource located in the blessed System Folder on the boot device (typically an HFS or HFS+ volume), which contains an embedded Forth boot script.[9] This script executes to load and run the Trampoline code, a bridge routine that terminates the Open Firmware environment, gathers critical system information (e.g., device tree details and interrupt mappings), rearranges memory layout to free space, and prepares the Interrupt Source Tree for handover.[1]
The Trampoline code then loads the Toolbox ROM Image from the bootinfo file into RAM, write-protecting approximately 3 MB of its 4 MB contents to serve as the runtime Macintosh Toolbox. This image, which provides core system services, the 68k emulator, and boot-time drivers, is decompressed and initialized via the image's HardwareInit routine. Control is subsequently transferred to the Macintosh boot loader, such as for Mac OS 8.5 or later, which scans the Extensions folder for additional drivers, initializes the file system, and completes OS startup from the specified System Folder.[1]
For diagnostics or custom booting, users can interrupt the automatic process by pressing Command-Option-O-F during the boot chime, invoking the Open Firmware command-line interface (ok prompt). From here, commands like mac-boot resume normal booting, boot [device-path] specify alternate volumes or networks, or setenv modifies NVRAM variables for persistent changes, enabling troubleshooting of hardware detection or boot failures.[1]
Comparison to Old World ROM
Architectural Differences
One of the primary architectural shifts in New World ROM compared to Old World ROM is the relocation of the Macintosh Toolbox from the ROM to a file-based "ToolBox ROM Image" loaded from mass storage during boot.[10] This change eliminates the one-to-one mapping between ROM addresses and RAM, requiring low-level code, such as drivers, to use APIs like LogicalToPhysical for address translation when accessing memory-mapped hardware or preparing I/O buffers.[10] Interrupt handling in New World ROM departs from the direct vector-based approach of Old World ROM, instead utilizing the Open Firmware Name Registry to dynamically wire interrupts.[10] Similarly, hardware I/O addresses are abstracted through Open Firmware, with the Name Registry providing device-specific addresses rather than relying on fixed mappings.[10] This abstraction layer aligns with IEEE 1275 Open Firmware standards, enabling greater portability across hardware configurations.[10] The transition from the Apple Desktop Bus (ADB) to USB represents another key difference, with New World ROM incorporating a software compatibility layer within the ToolBox ROM Image to support legacy ADB peripherals such as keyboards and mice.[10] Overall, New World ROM emphasizes modularity by fixing the Boot ROM size at 1 MB for hardware-specific initialization code, while the Toolbox operates dynamically in RAM as part of a 4 MB allocation (with less than 3 MB typically used), facilitating easier updates and reclaiming over 1 MB of RAM for other purposes.[10]Hardware and Software Implications
The adoption of New World ROM architecture led to significant simplifications in hardware design, particularly on logic boards, by eliminating the need for large ROM chips that housed the Macintosh Toolbox in previous systems. Instead, the Boot ROM on the logic board contained only essential hardware-specific code, such as Power-On Self-Test (POST), Open Firmware, and basic drivers, while the bulk of the Toolbox routines were provided via a ROM image file loaded from mass storage into RAM (known as ROM-in-RAM).[1][10] This reduced the physical footprint and cost of ROM components, with the Boot ROM being a compact single chip, freeing up board space for other integrations.[1] The architecture enhanced support for expansion technologies like PCI and AGP through Open Firmware's device tree management, which dynamically configured up to four PCI buses via peer bridges and supported 33 MHz (or 66 MHz on G3 systems) operations with 32-byte cache line bursts.[1] PCI cards could participate in the boot process using FCode drivers stored in their expansion ROMs, enabling seamless hardware enumeration per IEEE 1275 standards.[1] However, the mandatory shift to USB for primary input peripherals, such as keyboards and mice, replaced the older Apple Desktop Bus (ADB), requiring users to adopt USB-compatible devices or adapters, as not all legacy ADB peripherals were fully emulated.[10] The USB Manager, integrated into the Toolbox ROM image, handled hubs and standard input devices, but ADB emulation via software was limited to basic keyboard and mouse functions.[1][10] On the software side, developers were required to leverage Open Firmware APIs and the Name Registry for low-level hardware access, as direct manipulation of ROM contents was no longer feasible due to the file-based ROM image.[1][10] This shift promoted modular development, with drivers using the Driver Services Library (DSL) and routines likeRegistryEntrySearch for device management, ensuring compatibility across boot and runtime environments.[1] Configuration updates, such as Open Firmware variables, became simpler through NVRAM modifications in an 8 KB partition (including 2048 bytes for Open Firmware variables) following CHRP specifications, enabling persistence without hardware reflashing; the ROM image file could be updated via software replacement on disk.[1][10]
Backward compatibility for Old World software was maintained via the built-in Toolbox ROM image, which emulated legacy routines in RAM, allowing most applications to run without modification under the principle of "It's just a Mac!"[10] However, limitations arose in handling real-time interrupts, as the Open Firmware-mediated device tree provided improved interrupt handling with reduced latency compared to direct ROM access in prior architectures.[1]
Performance trade-offs included a minor boot delay from loading and decompressing the ~4 MB ROM image file (with under 3 MB actually used, returning over 1 MB to system RAM), but this was offset by the modular design's efficiency gains, such as reduced interrupt latency and increased available memory for applications.[1][10]