Editing Booting (section)

== History ==
[[File:Glen Beck and Betty Snyder program the ENIAC in building 328 at the Ballistic Research Laboratory.jpg|thumb|Switches and cables used to program [[ENIAC]] (1946)]]
There are many different methods available to load a short initial program into a computer. These methods reach from simple, physical input to removable media that can hold more complex programs.

=== Pre integrated-circuit-ROM examples ===
==== Early computers ====
Early computers in the 1940s and 1950s were one-of-a-kind engineering efforts that could take weeks to program, and program loading was one of many problems that had to be solved. An early computer, [[ENIAC]], had no program stored in memory but was set up for each problem by a configuration of interconnecting cables. Bootstrapping did not apply to ENIAC, whose hardware configuration was ready for solving problems as soon as power was applied.

The [[EDSAC]] system, the second stored-program computer to be built, used [[stepping switch]]es to transfer a fixed program into memory when its start button was pressed. The program stored on this device, which [[David Wheeler (computer scientist)|David Wheeler]] completed in late 1948, loaded further instructions from [[punched tape]] and then executed them.<ref>{{cite journal |author-first=Martin |author-last=Campbell-Kelly |author-link=Martin Campbell-Kelly |title=Programming the EDSAC |journal=IEEE Annals of the History of Computing |date=1980 |volume=2 |number=1 |pages=7–36 |doi=10.1109/mahc.1980.10009}}</ref><ref>{{cite book |author-last1=Wilkes |author-first1=Maurice V. |author-link1=Maurice Wilkes |author-last2=Wheeler |author-first2=David J. |author-link2=David Wheeler (computer scientist) |author-last3=Gill |author-first3=Stanley |author-link3=Stanley Gill |date=1951 |title=The Preparation of Programs for an Electronic Digital Computer |publisher=[[Addison-Wesley]] |url=https://books.google.com/books?id=HwkuAAAAIAAJ |access-date=2020-09-25 |archive-date=2023-02-20 |archive-url=https://web.archive.org/web/20230220131716/https://books.google.com/books?id=HwkuAAAAIAAJ |url-status=live}}</ref>

==== First commercial computers ====
The first programmable computers for commercial sale, such as the [[UNIVAC I]] and the [[IBM 701]]<ref>{{Cite journal |date=1953 |title=The System Design of the IBM Type 701 Computer |url=http://bitsavers.org/pdf/ibm/701/Buchholz_IBM_701_System_Design_Oct53.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/ibm/701/Buchholz_IBM_701_System_Design_Oct53.pdf |archive-date=2022-10-09 |url-status=live |author-last=Buchholz |author-first=Werner |author-link=Werner Buchholz |journal=Proceedings of the I.R.E. |volume=41 |issue=10 |page=1273}}</ref> included features to make their operation simpler. They typically included instructions that performed a complete input or output operation. The same hardware logic could be used to load the contents of a [[punch card]] (the most typical ones) or other input media, such as a [[magnetic drum]] or [[magnetic tape]], that contained a bootstrap program by pressing a single button. This booting concept was called a variety of names for [[IBM]] computers of the 1950s and early 1960s, but IBM used the term "Initial Program Load" with the [[IBM 7030 Stretch]]<ref name="stretch-ipl">{{cite book |title=Reference Manual 7030 Data Processing System |section=IBM 7619 Exchange |publisher=IBM |date=August 1961 |url=http://bitsavers.org/pdf/ibm/7030/22-6530-2_7030RefMan.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/ibm/7030/22-6530-2_7030RefMan.pdf |archive-date=2022-10-09 |url-status=live |id=A22-6530-2 |pages=125–127}}</ref> and later used it for their mainframe lines, starting with the [[System/360]] in 1964.

[[File:IBM1130CopyCard.agr.jpg|thumb|Initial program load punched card for the [[IBM 1130]] (1965)]]

The [[IBM 701]] computer (1952–1956) had a "Load" button that initiated reading of the first [[36-bit]] [[word (computer architecture)|word]] into [[computer memory|main memory]] from a punched card in a [[punched card reader|card reader]], a magnetic tape in a [[tape drive]], or a magnetic drum unit, depending on the position of the Load Selector switch. The left 18-bit half-word was then executed as an instruction, which usually read additional words into memory.<ref>{{cite book |title=Principles of Operation Type 701 And Associated Equipment |url=http://bitsavers.org/pdf/ibm/701/24-6042-1_701_PrincOps.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/ibm/701/24-6042-1_701_PrincOps.pdf |archive-date=2022-10-09 |url-status=live |publisher=IBM |date=1953 |page=26 |access-date=2012-11-09}}</ref><ref>{{cite book |title=From Gutenberg to the Internet |author=Jeremy M. Norman |date=2005 |page=436 |publisher=Norman |isbn=0-930405-87-0}}</ref> The loaded boot program was then executed, which, in turn, loaded a larger program from that medium into memory without further help from the human operator. The [[IBM 704]],<ref>{{cite book|url=http://bitsavers.org/pdf/ibm/704/24-6661-2_704_Manual_1955.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/ibm/704/24-6661-2_704_Manual_1955.pdf |archive-date=2022-10-09 |url-status=live|title=704 Electronic Data-Processing Machine Manual of Operation|pages=14–15|publisher=[[IBM]]}}</ref> [[IBM 7090]],<ref>{{cite book|url=http://bitsavers.org/pdf/ibm/7090/A22-6535_7090_operGde_Jan62.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/ibm/7090/A22-6535_7090_operGde_Jan62.pdf |archive-date=2022-10-09 |url-status=live|title=Operator's Guide for IBM 7090 Data Processing System|page=34|publisher=[[IBM]]}}</ref> and [[IBM 7094]]<ref>{{cite book|url=http://bitsavers.org/pdf/ibm/7094/GA22-6703-4_7094princOps.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/ibm/7094/GA22-6703-4_7094princOps.pdf |archive-date=2022-10-09 |url-status=live|title=IBM 7094 Principles of Operation|page=146|publisher=[[IBM]]}}</ref> had similar mechanisms, but with different load buttons for different devices.  The term "boot" has been used in this sense since at least 1958.<ref>{{cite book |title=Oxford English Dictionary |date=1939 |url=https://archive.org/details/in.ernet.dli.2015.228324 |publisher=[[Oxford University]]}}</ref>

[[File:IBM System3 model 10.jpg|thumb|IBM System/3 console from the 1970s. Program load selector switch is lower left; Program load switch is lower right.]]
Other IBM computers of that era had similar features. For example, the [[IBM 1401]] system (c. 1958) used a card reader to load a program from a punched card. The 80 characters stored in the punched card were read into memory locations 001 to 080, then the computer would branch to memory location 001 to read its first stored instruction. This instruction was always the same: move the information in these first 80 memory locations to an assembly area where the information in punched cards 2, 3, 4, and so on, could be combined to form the stored program. Once this information was moved to the assembly area, the machine would branch to an instruction in location 080 (read a card) and the next card would be read and its information processed.

Another example was the [[IBM 650]] (1953), a decimal machine, which had a group of ten 10-position switches on its operator panel which were addressable as a memory word (address 8000) and could be executed as an instruction. Thus setting the switches to 7004000400 and pressing the appropriate button would read the first card in the card reader into memory (op code 70), starting at address 400 and then jump to 400 to begin executing the program on that card.<ref>{{cite book |url=http://www.bitsavers.org/pdf/ibm/650/22-6060-2_650_OperMan.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.bitsavers.org/pdf/ibm/650/22-6060-2_650_OperMan.pdf |archive-date=2022-10-09 |url-status=live |title=650 magnetic drum data-processing machine manual of operation |publisher=IBM |date=1955 |pages=49, 53–54}}</ref>  The [[IBM 7040|IBM 7040 and 7044]] have a similar mechanism, in which the Load button causes the instruction set up in the entry keys on the front panel is executed, and the channel that instruction sets up is given a command to transfer data to memory starting at address 00100; when that transfer finishes, the CPU jumps to address 00101.<ref>{{cite book|url=http://bitsavers.org/pdf/ibm/7040/A22-6741-1_Operators_Guide_for_IBM_7040-7044_Systems.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/ibm/7040/A22-6741-1_Operators_Guide_for_IBM_7040-7044_Systems.pdf |archive-date=2022-10-09 |url-status=live|title=Operator's Guide for IBM 7040-7044 Systems|page=10|id=A22-6741-1|publisher=[[IBM]]}}</ref>

IBM's competitors also offered single button program load.
* The [[CDC 6600]] (c. 1964) had a ''dead start'' panel with 144 toggle switches; the dead start switch entered 12 12-bit words from the toggle switches to the memory of [[CDC 6000 series#Peripheral processors|''peripheral processor'']] (''PP'') 0 and initiated the load sequence by causing PP 0 to execute the code loaded into memory.<ref>{{cite book|url=http://bitsavers.org/pdf/cdc/cyber/cyber_70/60045000_6600_Computer_System_RefMan_Aug63.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/cdc/cyber/cyber_70/60045000_6600_Computer_System_RefMan_Aug63.pdf |archive-date=2022-10-09 |url-status=live|title=CONTROL DATA 6600 Computer System Reference Manual|page=53|edition=Second|date=August 1963|publisher=[[Control Data Corporation]]}}</ref> PP 0 loaded the necessary code into its own memory and then initialized the other PPs.
* The [[GE-600 series|GE 645]] (c. 1965) had a "SYSTEM BOOTLOAD" button that, when pressed, caused one of the I/O controllers to load a 64-word program into memory from a diode [[read-only memory]] and deliver an interrupt to cause that program to start running.<ref>{{cite book |url=http://bitsavers.org/pdf/ge/GE-645/LSB0468_GE-645_System_Manual_Jan1968.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/ge/GE-645/LSB0468_GE-645_System_Manual_Jan1968.pdf |archive-date=2022-10-09 |url-status=live |title=GE-645 System Manual |date=January 1968 |publisher=[[General Electric]] |access-date=October 30, 2019}}</ref>
* The first model of the [[PDP-10]] had a "READ IN" button that, when pressed, reset the processor and started an I/O operation on a device specified by switches on the control panel, reading in a 36-bit word giving a target address and count for subsequent word reads; when the read completed, the processor started executing the code read in by jumping to the last word read in.<ref>{{cite book |title=PDP-10 System Reference Manual, Part 1 |url=http://bitsavers.org/pdf/dec/pdp10/1970_PDP-10_Ref/1970PDP10Ref_Part1.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/pdp10/1970_PDP-10_Ref/1970PDP10Ref_Part1.pdf |archive-date=2022-10-09 |url-status=live |pages=2–72 |publisher=[[Digital Equipment Corporation]] |date=1969 |access-date=2012-11-09}}</ref>

A noteworthy variation of this is found on the [[Burroughs Corporation|Burroughs]] [[B1700]] where there is neither a [[boot ROM]] nor a hardwired IPL operation. Instead, after the system is reset it reads and executes microinstructions sequentially from a cassette tape drive mounted on the front panel; this sets up a boot loader in RAM which is then executed.<ref name="fff">{{cite book|url=http://bitsavers.org/pdf/burroughs/B1700/1057155_B1700SysRefMan11-73.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/burroughs/B1700/1057155_B1700SysRefMan11-73.pdf |archive-date=2022-10-09 |url-status=live|title=Burroughs B 1700 Systems Reference Manual|page=1{{hyp}}14|date=November 1973|publisher=[[Burroughs Corporation]]}}</ref> However, since this makes few assumptions about the system it can equally well be used to load diagnostic (Maintenance Test Routine) tapes which display an intelligible code on the [[front panel]] even in cases of gross CPU failure.<ref name="fff" />

==== IBM System/360 and successors ====
{{Anchor|IPL|Initial Program Load}}
In the [[IBM System/360]] and its successors, including the current [[z/Architecture]] machines, the boot process is known as [[IBM System/360 architecture#Initial Program Load|''Initial Program Load'']] (IPL).

IBM coined this term for the [[IBM 7030 Stretch|7030 (Stretch)]],<ref name="stretch-ipl"/> revived it for the design of the System/360, and continues to use it in those environments today.<ref name="zAPoP">{{cite book |url=http://publibz.boulder.ibm.com/epubs/pdf/a2278324.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://publibz.boulder.ibm.com/epubs/pdf/a2278324.pdf |archive-date=2022-10-09 |url-status=live |title=z/Architecture Principles of Operation |pages=Chapter 17 |publisher=[[IBM]] |date=September 2005 |access-date=2007-04-14}}</ref> In the System/360 processors, an IPL is initiated by the computer operator by selecting the three hexadecimal digit device address (CUU; C=I/O Channel address, UU=Control unit and Device address<ref group="nb">UU was often of the form Uu, U=Control unit address, u=Device address, but some control units attached only 8 devices; some attached more than 16. Indeed, the 3830 DASD controller offered 32-drive-addressing as an option.</ref>) followed by pressing the ''LOAD'' button. On the high end [[System/360]] models, most<ref group="nb">Excluding the 370/145 and 370/155, which used a 3210 or 3215 console typewriter.</ref> [[System/370]] and some later systems, the functions of the switches and the LOAD button are simulated using selectable areas on the screen of a graphics console, often<ref group="nb">Only the S/360 used the 2250; the [[360/85]], [[370/165]] and [[370/168]] used a keyboard/display device compatible with nothing else.</ref> an [[IBM 2250]]-like device or an [[IBM 3270]]-like device. For example, on the System/370 Model 158, the keyboard sequence 0-7-X (zero, seven and X, in that order) results in an IPL from the device address that was keyed into the input area. The [[Amdahl Corporation|Amdahl]] 470V/6 and related CPUs supported four hexadecimal digits on those CPUs which had the optional second channel unit installed, for a total of 32 channels. Later, IBM would also support more than 16 channels.

The IPL function in the System/360 and its successors prior to [[IBM Z]], and its compatibles such as Amdahl's, reads 24 bytes from an operator-specified device into main storage starting at real address zero. The second and third groups of eight bytes are treated as [[Channel Command Word]]s (CCWs) to continue loading the startup program (the first CCW is always simulated by the CPU and consists of a Read IPL command, {{Mono|02h}}, with command chaining and suppress incorrect length indication being enforced). When the I/O channel commands are complete, the first group of eight bytes is then loaded into the processor's [[Program Status Word]] (PSW) and the startup program begins execution at the location designated by that PSW.<ref name="zAPoP"/> The IPL device is usually a disk drive, hence the special significance of the {{Mono|02h}} read-type command, but exactly the same procedure is also used to IPL from other input-type devices, such as tape drives, or even card readers, in a device-independent manner, allowing, for example, the installation of an operating system on a brand-new computer from an OS initial distribution magnetic tape. For disk controllers, the {{Mono|02h}} command also causes the selected device to seek to cylinder {{Mono|0000h}}, head {{Mono|0000h}}, simulating a Seek cylinder and head command, {{Mono|07h}}, and to search for record {{Mono|01h}}, simulating a Search ID Equal command, {{Mono|31h}}; seeks and searches are not simulated by tape and card controllers, as for these device classes a Read IPL command is simply a sequential read command.

The disk, tape or card deck must contain a special program to load the actual operating system or standalone utility into main storage, and for this specific purpose "IPL Text" is placed on the disk by the stand-alone DASDI (Direct Access Storage Device Initialization) program or an equivalent program running under an operating system, e.g., ICKDSF, but IPL-able tapes and card decks are usually distributed with this "IPL Text" already present.

IBM introduced some evolutionary changes in the IPL process, changing some details for System/370 Extended Architecture (S/370-XA) and later, and adding a new type of IPL for z/Architecture.

==== Minicomputers ====
[[File:Digital pdp8-e2.jpg|thumb|PDP-8/E front panel showing the switches used to load the bootstrap program]]

[[Minicomputer]]s, starting with the [[Digital Equipment Corporation]] (DEC) [[PDP-5]] and [[PDP-8]] (1965) simplified design by using the CPU to assist input and output operations. This saved cost but made booting more complicated than pressing a single button. Minicomputers typically had some way to ''toggle in'' short programs by manipulating an array of switches on the [[front panel]]. Since the early minicomputers used [[magnetic-core memory]], which did not lose its information when power was off, these bootstrap loaders would remain in place unless they were erased. Erasure sometimes happened accidentally when a program bug caused a loop that overwrote all of memory.

Other minicomputers with such simple form of booting include Hewlett-Packard's [[HP 2100]] series (mid-1960s), the original [[Data General Nova]] (1969), and DEC's [[PDP-4]] (1962) and [[PDP-11]] (1970).

As the I/O operations needed to cause a read operation on a minicomputer I/O device were typically different for different device controllers, different bootstrap programs were needed for different devices.

DEC later added, in 1971, an optional [[diode matrix]] [[read-only memory]] for the PDP-11 that stored a bootstrap program of up to 32 words (64 bytes). It consisted of a printed circuit card, the M792, that plugged into the [[Unibus]] and held a 32 by 16 array of semiconductor diodes. With all 512 diodes in place, the memory contained all "one" bits; the card was programmed by cutting off each diode whose bit was to be "zero". DEC also sold versions of the card, the BM792-Yx series, pre-programmed for many standard input devices by simply omitting the unneeded diodes.<ref>{{cite book|url=http://www.bitsavers.org/www.computer.museum.uq.edu.au/pdf/DEC-11-HBMAA-E-D%20BM792%20Read-Only-Memory%20and%20MR11-DB%20Bootstrap%20Loader.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.bitsavers.org/www.computer.museum.uq.edu.au/pdf/DEC-11-HBMAA-E-D%20BM792%20Read-Only-Memory%20and%20MR11-DB%20Bootstrap%20Loader.pdf |archive-date=2022-10-09 |url-status=live|title=BM792 read-only-memory and MR11~DB bootstrap loader|date=January 1974|id=DEC-II-HBMAA-E-D|publisher=[[Digital Equipment Corporation]]}}</ref><ref>{{cite book |url=http://bitsavers.org/pdf/dec/pdp11/handbooks/PDP11_PeripheralsHbk_1976.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/pdp11/handbooks/PDP11_PeripheralsHbk_1976.pdf |archive-date=2022-10-09 |url-status=live |title=PDP-11 Peripherals Handbook |date=1976 |publisher=[[Digital Equipment Corporation]] |page=4{{hyp}}25}}</ref>

Following the older approach, the earlier [[PDP-1]] has a hardware loader, such that an operator need only push the "load" switch to instruct the [[paper tape]] reader to load a program directly into core memory. The [[PDP-7]],<ref>{{cite book|url=http://bitsavers.org/pdf/dec/pdp7/F-75_PDP-7userHbk_Jun65.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/pdp7/F-75_PDP-7userHbk_Jun65.pdf |archive-date=2022-10-09 |url-status=live|title=Programmed Data Processor-7 Users Handbook|page=143|publisher=[[Digital Equipment Corporation]]|date=1965}}</ref> [[PDP-9]],<ref>{{cite book|url=http://bitsavers.org/pdf/dec/pdp9/PDP-9_UsersManual.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/pdp9/PDP-9_UsersManual.pdf |archive-date=2022-10-09 |url-status=live|title=PDP-9 User Handbook|page=10{{hyp}}3|publisher=[[Digital Equipment Corporation]]|date=January 1968}}</ref> and [[PDP-15]]<ref>{{cite book|url=http://bitsavers.org/pdf/dec/pdp15/PDP15RefMan.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/pdp15/PDP15RefMan.pdf |archive-date=2022-10-09 |url-status=live|title=PDP-15 Systems Reference Manual|page=10{{hyp}}3|publisher=[[Digital Equipment Corporation]]|date=August 1969}}</ref> successors to the PDP-4 have an added Read-In button to read a program in from paper tape and jump to it. The Data General [[Data General Nova#SuperNOVA|Supernova]] used front panel switches to cause the computer to automatically load instructions into memory from a device specified by the front panel's data switches, and then jump to loaded code.<ref name="how-to-use-the-nova-computers">{{cite book |url=http://bitsavers.org/pdf/dg/DG_NM-5_How_To_Use_The_Nova_Computers_Apr1971.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dg/DG_NM-5_How_To_Use_The_Nova_Computers_Apr1971.pdf |archive-date=2022-10-09 |url-status=live |title=How To Use The Nova Computers |page=2{{hyp}}30 |publisher=[[Data General]] |date=April 1971}}</ref>

===== Early minicomputer boot loader examples =====
In a minicomputer with a paper tape reader, the first program to run in the boot process, the boot loader, would read into core memory either the second-stage boot loader (often called a ''Binary Loader'') that could read paper tape with [[checksum]] or the operating system from an outside storage medium. [[Pseudocode]] for the boot loader might be as simple as the following eight instructions:

# Set the P register to 9
# Check paper tape reader ready
# If not ready, jump to 2
# Read a byte from paper tape reader to accumulator
# Store accumulator to address in P register
# If end of tape, jump to 9
# Increment the P register
# Jump to 2

A related example is based on a loader for a Nicolet Instrument Corporation minicomputer of the 1970s, using the paper tape reader-punch unit on a [[Teletype Model 33]] ASR [[teleprinter]]. The bytes of its second-stage loader are read from paper tape in reverse order.

# Set the P register to 106
# Check paper tape reader ready
# If not ready, jump to 2
# Read a byte from paper tape reader to accumulator
# Store accumulator to address in P register
# Decrement the P register
# Jump to 2

The length of the second stage loader is such that the final byte overwrites location 7. After the instruction in location 6 executes, location 7 starts the second stage loader executing. The second stage loader then waits for the much longer tape containing the operating system to be placed in the tape reader. The difference between the boot loader and second stage loader is the addition of checking code to trap paper tape read errors, a frequent occurrence with relatively low-cost, "part-time-duty" hardware, such as the Teletype Model 33 ASR. (Friden Flexowriters were far more reliable, but also comparatively costly.)

==== Booting the first microcomputers ====
The earliest microcomputers, such as the [[Altair 8800]] (released first in 1975) and an even earlier, similar machine (based on the Intel 8008 CPU) had no bootstrapping hardware as such.<ref>{{Cite web |url=https://www.old-computers.com/museum/computer.asp?c=896&st=1 |title=Oldcomputers: Altair 8800b |access-date=10 December 2019 |archive-date=2020-01-03 |archive-url=https://web.archive.org/web/20200103181235/https://www.old-computers.com/museum/computer.asp?st=1&c=896 |url-status=live}}</ref> When powered-up, the CPU would see memory that would contain random data. The front panels of these machines carried toggle switches for entering addresses and data, one switch per bit of the computer memory word and address bus. Simple additions to the hardware permitted one memory location at a time to be loaded from those switches to store bootstrap code. Meanwhile, the CPU was kept from attempting to execute memory content. Once correctly loaded, the CPU was enabled to execute the bootstrapping code. This process, similar to that used for several earlier minicomputers, was tedious and had to be error-free.<ref>{{cite AV media |url=https://www.youtube.com/watch?v=5zbtNImG2NE |title=Altair 8800 loads 4K BASIC from paper tape |author-first=Glenn |author-last=Holmer |access-date=2016-05-02 |archive-date=2019-07-30 |archive-url=https://web.archive.org/web/20190730073047/https://www.youtube.com/watch?v=5zbtNImG2NE&gl=US&hl=en |url-status=live}}</ref>

=== Integrated circuit read-only memory era ===
[[File:Intel 2708 1KB EPROM.jpg|thumb|An Intel 2708 [[EPROM]] "chip" on a [[circuit board]]]]

The introduction of integrated circuit [[read-only memory]] (ROM), with its many variants, including [[Mask ROM|mask-programmed ROM]]s, [[programmable ROM]]s (PROM), [[erasable programmable ROM]]s (EPROM), and [[flash memory]], reduced the physical size and cost of ROM. This allowed [[firmware]] boot programs to be included as part of the computer.

====Minicomputers====
The Data General [[Data General Nova#1200 and 800|Nova 1200]] (1970) and [[Data General Nova#1200 and 800|Nova 800]] (1971) had a program load switch that, in combination with options that provided two ROM chips, loaded a program into main memory from those ROM chips and jumped to it.<ref name="how-to-use-the-nova-computers"/>  Digital Equipment Corporation introduced the integrated-circuit-ROM-based BM873 (1974),<ref>{{cite book |url=http://www.bitsavers.org/pdf/dec/unibus/DEC-11-H873A-B-D_BM873_Restart_Loader_Apr74.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.bitsavers.org/pdf/dec/unibus/DEC-11-H873A-B-D_BM873_Restart_Loader_Apr74.pdf |archive-date=2022-10-09 |url-status=live |title=BM873 restart/loader |date=April 1974 |id=DEC-11-H873A-B-D |publisher=[[Digital Equipment Corporation]]}}</ref> M9301 (1977),<ref>{{cite book |url=http://www.bitsavers.org/pdf/dec/unibus/EK-M9301-TM-001_M9301_Bootstrap_Terminator_Module_Maintenance_and_Operators_Manual_Jun77.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.bitsavers.org/pdf/dec/unibus/EK-M9301-TM-001_M9301_Bootstrap_Terminator_Module_Maintenance_and_Operators_Manual_Jun77.pdf |archive-date=2022-10-09 |url-status=live |title=M9301 bootstrap/terminator module maintenance and operator's manual |date=June 1977 |id=EK-M9301-TM-OO1 |publisher=[[Digital Equipment Corporation]]}}</ref> M9312 (1978),<ref>{{cite book |url=http://www.bitsavers.org/pdf/dec/unibus/M9312_TechRef.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.bitsavers.org/pdf/dec/unibus/M9312_TechRef.pdf |archive-date=2022-10-09 |url-status=live |title=M9312 bootstrap/terminator module technical manual |date=March 1981 |id=EK-M9312-TM-OO3 |publisher=[[Digital Equipment Corporation]]}}</ref> REV11-A and REV11-C,<ref>{{cite book |url=http://bitsavers.org/pdf/dec/qbus/Digital_Microcomputer_Interfaces_Handbook_1980.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/qbus/Digital_Microcomputer_Interfaces_Handbook_1980.pdf |archive-date=2022-10-09 |url-status=live |title=Microcomputer Interfaces Handbook |page=17 |date=1981 |publisher=[[Digital Equipment Corporation]]}}</ref> MRV11-C,<ref>{{cite book |url=http://bitsavers.org/pdf/dec/qbus/Digital_Microcomputer_Products_Handbook_1985.pdf |title=Microcomputer Products Handbook |chapter=10 MRV11-C Read-Only Memory Module |date=1985 |publisher=[[Digital Equipment Corporation]] |access-date=2022-06-12 |archive-date=2022-10-24 |archive-url=https://web.archive.org/web/20221024223027/http://bitsavers.org/pdf/dec/qbus/Digital_Microcomputer_Products_Handbook_1985.pdf |url-status=live}}</ref> and MRV11-D<ref>{{cite book |url=http://bitsavers.org/pdf/dec/qbus/Digital_Microcomputer_Products_Handbook_1985.pdf |title=Microcomputer Products Handbook |chapter=11 MRVll·D Universal Programmable Read.Only Memory |date=1985 |publisher=[[Digital Equipment Corporation]] |access-date=2022-06-12 |archive-date=2022-10-24 |archive-url=https://web.archive.org/web/20221024223027/http://bitsavers.org/pdf/dec/qbus/Digital_Microcomputer_Products_Handbook_1985.pdf |url-status=live}}</ref> ROM memories, all usable as bootstrap ROMs. The PDP-11/34 (1976),<ref>{{cite book |url=http://bitsavers.org/pdf/dec/pdp11/1134/1134_UsersManual.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/pdp11/1134/1134_UsersManual.pdf |archive-date=2022-10-09 |url-status=live|title=PDP-11/34 system user's manual |pages=1{{hyp}}5,2{{hyp}}1–2{{hyp}}12 |date=July 1977 |id=EK-11034-UG-001 |publisher=[[Digital Equipment Corporation]]}}</ref> PDP-11/60 (1977),<ref>{{cite book |url=http://bitsavers.org/pdf/dec/pdp11/1160/EK-11060-OP-003_PDP-1160_installation_and_operation_manual_Feb78.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/pdp11/1160/EK-11060-OP-003_PDP-1160_installation_and_operation_manual_Feb78.pdf |archive-date=2022-10-09 |url-status=live |title=PDP-11/60 installation and operation manual |pages=1{{hyp}}10,2{{hyp}}29-2{{hyp}}34,3{{hyp}}1-3{{hyp}}6 |date=February 1979 |id=EK-11060-OP-003 |publisher=[[Digital Equipment Corporation]]}}</ref> PDP-11/24 (1979),<ref>{{cite book |url=http://bitsavers.org/pdf/dec/pdp11/1124/EK-11024-TM-001_PDP11_24_System_Technical_Manual_Jun81.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/pdp11/1124/EK-11024-TM-001_PDP11_24_System_Technical_Manual_Jun81.pdf |archive-date=2022-10-09 |url-status=live |title=PDP-11/24 System Technical Manual |page=1{{hyp}}6 |date=June 1981 |id=EK-11024-TM-001 |publisher=[[Digital Equipment Corporation]]}}</ref> and most later models include boot ROM modules.

An Italian telephone switching computer, called "Gruppi Speciali", patented in 1975 by [[Alberto Ciaramella]], a researcher at [[CSELT]],<ref>[[Alberto Ciaramella|Ciaramella, Alberto]]. {{US patent|4117974|Device for automatically loading the central memory of electronic processors}} U.S. Patent No. 4,117,974. 1978-10-03. (submitted in 1975)</ref> included an (external) ROM. Gruppi Speciali was, starting from 1975, a fully single-button machine booting into the operating system from a ROM memory composed from semiconductors, not from ferrite cores. Although the ROM device was not natively embedded in the computer of Gruppi Speciali, due to the design of the machine, it also allowed the single-button ROM booting in machines not designed for that (therefore, this "bootstrap device" was architecture-independent), e.g. the PDP-11. Storing the state of the machine after the switch-off was also in place, which was another critical feature in the telephone switching contest.<ref>{{cite AV media |url=https://www.youtube.com/watch?v=5FmIQhgm8pI |archive-url=https://ghostarchive.org/varchive/youtube/20211113/5FmIQhgm8pI |archive-date=2021-11-13 |url-status=live |title=Alberto Ciaramella racconta il brevetto del boostrap dei computer concepito in CSELT |trans-title=Alberto Ciaramella discusses the patent for bootstrapping computers conceived at CSELT |language=it}}{{cbignore}}</ref>

Some minicomputers and [[superminicomputer]]s include a separate console processor that bootstraps the main processor.  The PDP-11/44 had an [[Intel 8085]] as a console processor;<ref>{{cite book |url=http://bitsavers.org/pdf/dec/pdp11/1144/1144_SystemTechMan.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/pdp11/1144/1144_SystemTechMan.pdf |archive-date=2022-10-09 |url-status=live |title=PDP-11/44 System Technical Manual |page=6{{hyp}}57 |id=EK-KD11Z-TM-001 |publisher=[[Digital Equipment Corporation]] |date=February 1979}}</ref> the [[VAX-11/780]], the first member of Digital's [[VAX]] line of 32-bit superminicomputers, had an [[LSI-11]]-based console processor,<ref>{{cite book |url=http://bitsavers.org/pdf/dec/vax/780/EK-11780-UG-001_VAX-11_780_Hardware_Users_Guide_197902.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/vax/780/EK-11780-UG-001_VAX-11_780_Hardware_Users_Guide_197902.pdf |archive-date=2022-10-09 |url-status=live |title=VAX-11/780 Hardware User's Guide |at=2.3 BOOTSTRAPPING and 3.6.1 Boot Command (B) |id=EK-11780-UG-001 |publisher=[[Digital Equipment Corporation]] |date=February 1979}}</ref> and the VAX-11/730 had an 8085-based console processor.<ref>{{cite book |url=http://bitsavers.org/pdf/dec/vax/730/EK-KA730-TD-001_VAX-11_730_CPU_Technical_Description_198205.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/vax/730/EK-KA730-TD-001_VAX-11_730_CPU_Technical_Description_198205.pdf |archive-date=2022-10-09 |url-status=live |title=VAX-11/730 Central Processing Unit Technical Description |page=1{{hyp}}9 |id=EK-KA730-TD-001 |publisher=[[Digital Equipment Corporation]] |date=May 1982}}</ref> These console processors could boot the main processor from various storage devices.

Some other superminicomputers, such as the VAX-11/750, implement console functions, including the first stage of booting, in CPU microcode.<ref>{{cite book |url=http://bitsavers.org/pdf/dec/vax/750/AA-K410C-TE_VAX-11_750_Software_Installation_Guide_198212.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/pdf/dec/vax/750/AA-K410C-TE_VAX-11_750_Software_Installation_Guide_198212.pdf |archive-date=2022-10-09 |url-status=live|title=VAX-11/750 Software Installation Guide |pages=1{{hyp}}2-1{{hyp}}4,B{{hyp}}1-B{{hyp}}8,C{{hyp}}1-C{{hyp}}2 |id=AA-K410C-TE |publisher=[[Digital Equipment Corporation]] |date=December 1982}}</ref>

====Microprocessors and microcomputers====
Typically, a microprocessor will, after a reset or power-on condition, perform a start-up process that usually takes the form of "begin execution of the code that is found starting at a specific address" or "look for a multibyte code at a specific address and jump to the indicated location to begin execution". A system built using that microprocessor will have the permanent ROM occupying these special locations so that the system always begins operating without operator assistance. For example, [[Intel x86]] processors always start by running the instructions beginning at F000:FFF0,<ref>{{cite book |title=Osborne 16-Bit Microprocessor Handbook |author-first1=Adam |author-last1=Osborne |author-link1=Adam Osborne |author-first2=Gerry |author-last2=Kane |date=1981 |pages=5–27 |publisher=OSBORNE/McGraw-Hill |isbn=0-931988-43-8 |url=http://www.bitsavers.org/pdf/osborne/books/Osborne_16-Bit_Microprocessor_Handbook_1981.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.bitsavers.org/pdf/osborne/books/Osborne_16-Bit_Microprocessor_Handbook_1981.pdf |archive-date=2022-10-09 |url-status=live |access-date=23 August 2019}}</ref><ref>{{cite book |url=http://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-system-programming-manual-325384.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-system-programming-manual-325384.pdf |archive-date=2022-10-09 |url-status=live |title=Intel 64 and IA-32 Architectures Software Developer's Manual Volume 3 (3A, 3B, 3C & 3D): System Programming Guide}}</ref> while for the [[MOS 6502]] processor, initialization begins by reading a two-byte vector address at $FFFD (MS byte) and $FFFC (LS byte) and jumping to that location to run the bootstrap code.<ref>{{cite book |title=Osborne 4&8-Bit Microprocessor Handbook |author-first1=Adam |author-last1=Osborne |author-link1=Adam Osborne |author-first2=Gerry |author-last2=Kane |date=1981 |pages=10–20 |publisher=Osborne/McGraw-Hill |isbn=0-931988-42-X}}</ref>

[[Apple Computer]]'s first computer, the [[Apple I|Apple 1]] introduced in 1976, featured PROM chips that eliminated the need for a front panel for the boot process (as was the case with the Altair 8800) in a commercial computer. According to Apple's ad announcing it "No More Switches, No More Lights ... the firmware in PROMS enables you to enter, display and debug programs (all in hex) from the keyboard."<ref>[[:File:Apple 1 Advertisement Oct 1976.jpg |Apple Ad, Interface Age, October 1976]]</ref>

Due to the expense of read-only memory at the time, the [[Apple II]] booted its disk operating systems using a series of very small incremental steps, each passing control onward to the next phase of the gradually more complex boot process. (See [[Apple DOS#Boot loader|Apple DOS: Boot loader]]). Because so little of the disk operating system relied on ROM, the hardware was also extremely flexible and supported a wide range of customized disk [[copy protection]] mechanisms. (See [[Software cracking#History|Software Cracking: History]].)

Some operating systems, most notably pre-1995 [[Macintosh]] systems from [[Apple Inc.|Apple]], are so closely interwoven with their hardware that it is impossible to natively boot an operating system other than the standard one. This is the opposite extreme of the scenario using switches mentioned above; it is highly inflexible but relatively error-proof and foolproof as long as all hardware is working normally. A common solution in such situations is to design a boot loader that works as a program belonging to the standard OS that hijacks the system and loads the alternative OS. This technique was used by Apple for its [[A/UX]] Unix implementation and copied by various freeware operating systems and [[BeOS|BeOS Personal Edition 5]].

Some machines, like the [[Atari ST]] [[microcomputer]], were "instant-on", with the operating system executing from a ROM. Retrieval of the OS from secondary or tertiary store was thus eliminated as one of the characteristic operations for bootstrapping. To allow system customizations, accessories, and other support software to be loaded automatically, the Atari's floppy drive was read for additional components during the boot process. There was a timeout delay that provided time to manually insert a floppy as the system searched for the extra components. This could be avoided by inserting a blank disk. The Atari ST hardware was also designed so the cartridge slot could provide native program execution for gaming purposes as a holdover from Atari's legacy making electronic games; by inserting the [[Spectre GCR]] cartridge with the Macintosh system ROM in the game slot and turning the Atari on, it could "natively boot" the Macintosh operating system rather than Atari's own [[Atari TOS|TOS]].

The [[IBM Personal Computer]] included ROM-based firmware called the [[BIOS]]; one of the functions of that firmware was to perform a [[power-on self test]] when the machine was powered up, and then to read software from a boot device and execute it. Firmware compatible with the BIOS on the IBM Personal Computer is used in [[IBM PC compatible]] computers. The [[UEFI]] was developed by Intel, originally for [[Itanium]]-based machines, and later also used as an alternative to the BIOS in [[x86]]-based machines, including [[Apple–Intel architecture|Apple Macs using Intel processors]].

[[Unix workstation]]s originally had vendor-specific ROM-based firmware. [[Sun Microsystems]] later developed [[OpenBoot]], later known as Open Firmware, which incorporated a [[Forth (programming language)|Forth]] interpreter, with much of the firmware being written in Forth. It was standardized by the [[IEEE]] as IEEE standard {{not a typo|1275-1994}}; firmware that implements that standard was used in [[PowerPC]]-based [[Macintosh|Macs]] and some other PowerPC-based machines, as well as Sun's own [[SPARC]]-based computers. The [[Advanced RISC Computing]] specification defined another firmware standard, which was implemented on some [[MIPS architecture|MIPS]]-based and [[DEC Alpha|Alpha]]-based machines and the [[SGI Visual Workstation]] x86-based workstations.