View source for Booting

{{Short description|Process of starting a computer}}
{{Redirect|Quick boot|the feature of the Quarterdeck memory manager|Quickboot (QEMM)}}
{{About|bootstrapping operating systems|the general concept|Bootstrapping}}
{{Other uses|Boot (disambiguation)}}
{{Use dmy dates|date=July 2019|cs1-dates=y}}

[[File:Flow-diagram-computer-booting-sequences.svg|thumb|A flow diagram of a computer booting]]

In [[computing]], '''booting''' is the process of starting a [[computer]] as initiated via [[Computer hardware|hardware]] such as a button on the computer or by a [[software]] command. After it is switched on, a computer's [[central processing unit]] (CPU) has no software in its [[main memory]], so some process must load software into memory before it can be executed. This may be done by hardware or [[firmware]] in the CPU, or by a separate processor in the computer system.

Restarting a computer also is called [[Reboot (computing)|rebooting]], which can be "hard", e.g. after electrical power to the CPU is switched from off to on, or "soft", where the power is not cut. On some systems, a soft boot may optionally clear [[RAM]] to zero. Both hard and soft booting can be initiated by hardware such as a button press or by a software command. Booting is complete when the operative [[runtime system]], typically the [[operating system]] and some applications,<ref group="nb">Including [[Daemon (computing)|daemons]].</ref> is attained.

The process of returning a computer from a state of [[sleep mode|sleep]] (suspension) does not involve booting; however, restoring it from a state of [[hibernation (computing)|hibernation]] does. Minimally, some [[embedded systems]] do not require a noticeable boot sequence to begin functioning and when turned on may simply run operational programs that are stored in ROM. All computing systems are [[state machine]]s, and a reboot may be the only method to return to a designated zero-state from an unintended, locked state.

In addition to loading an operating system or stand-alone utility, the boot process can also load a storage dump program for diagnosing problems in an operating system.

''Boot'' is short for [[bootstrapping|''bootstrap'']]<ref>{{cite dictionary |url=https://www.computer-dictionary-online.org/definitions-b/bootstrap.html |title=bootstrap |dictionary=Computer Dictionary of Information Technology |access-date=2019-08-05 |archive-date=2019-08-05 |archive-url=https://web.archive.org/web/20190805133324/https://www.computer-dictionary-online.org/definitions-b/bootstrap.html |url-status=live}}</ref><ref>{{cite dictionary |url=http://www.thefreedictionary.com/bootstrap |title=Bootstrap |dictionary=[[The Free Dictionary]] |access-date=2008-08-27 |archive-date=2006-08-27 |archive-url=https://web.archive.org/web/20060827213259/http://www.thefreedictionary.com/bootstrap |url-status=live}}</ref> or ''bootstrap load'' and derives from the phrase ''[[Bootstrapping#Etymology|to pull oneself up by one's bootstraps]]''.<ref>{{cite dictionary |url=http://idioms.thefreedictionary.com/pull+oneself+up+by+bootstraps |title=Pull oneself up by bootstraps |dictionary=Idioms by The Free Dictionary |access-date=2019-10-07 |archive-date=2018-10-05 |archive-url=https://web.archive.org/web/20181005184001/http://idioms.thefreedictionary.com/pull+oneself+up+by+bootstraps |url-status=live}}</ref><ref>{{Cite dictionary|url=https://techterms.com/definition/bootstrap|title=Bootstrap Definition|dictionary=Tech Terms|access-date=2019-10-02|archive-date=2020-05-10 |archive-url=https://web.archive.org/web/20200510175435/https://techterms.com/definition/bootstrap|url-status=live}}</ref> The usage calls attention to the requirement that, if most software is loaded onto a computer by other software already running on the computer, some mechanism must exist to load the initial software onto the computer.<ref>{{cite dictionary |url=http://www.phrases.org.uk/meanings/290800.html |title=Pull yourself up by your bootstraps |dictionary=The Phrase Finder |access-date=2010-07-15 |archive-date=2012-04-17 |archive-url=https://web.archive.org/web/20120417231134/http://www.phrases.org.uk/meanings/290800.html |url-status=live}}</ref> Early computers used a variety of ad-hoc methods to get a small program into memory to solve this problem. The invention of [[read-only memory]] (ROM) of various types solved this paradox by allowing computers to be shipped with a start up program that could not be erased. Growth in the capacity of ROM has allowed ever more elaborate start up procedures to be implemented.

== 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 [[IBM System/360|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>''From Gutenberg to the Internet'', Jeremy M. Norman, 2005, page 436, {{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 manual|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 manual|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 manual|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 manual|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 manual|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 bootstrap 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 manual|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 [[IBM System/360 Model 85|360/85]], [[IBM System/370 Model 165|370/165]] and [[IBM System/370 Model 168|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 which 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 manual|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 manual|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 manual|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 manual|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 manual |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 [[Printed circuit board|circuit board]]]]

The introduction of integrated circuit [[read-only memory]] (ROM), with its many variants, including [[Mask ROM|mask-programmed ROM]]s, [[programmable read-only memory|programmable ROM]]s (PROM), [[EPROM|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 manual |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 manual |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 manual |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 manual |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 manual |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 manual |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 manual |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 manual |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 manual |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 manual |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 manual |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 manual |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 manual |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 [[Read-only memory|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.

== Modern boot loaders<span class="anchor" id="Boot-loader"></span> ==
{{See also|Comparison of boot loaders|Bootloader}}<!--

Note to editors: this section (in the [[Booting]] article) contains much of the same text as the [[Bootloader]] article. Changes to one article will _not_ automatically update the text in the other, as the following sub-sections are not currently ‘transcluded’ from one article to the other.

See [[Help:Transclusion]] for more information.

-->
When a computer is turned off, its software{{mdashb}}including operating systems, application code, and data{{mdashb}}remains stored on [[non-volatile memory]]. When the computer is powered on, it typically does not have an operating system or its loader in [[random-access memory]] (RAM). The computer first executes a relatively small program stored in [[read-only memory]] (ROM, and later [[EEPROM]], [[NOR flash]]) which support [[execute in place]], to initialize CPU and motherboard, to initialize [[DRAM]] (especially on x86 systems), to access the nonvolatile device (usually block-addressed device, e.g. NAND flash, SSD) or devices from which the operating system programs and data can be loaded into RAM; in addition, this program may initialize display devices (such as [[GPU]]s), text input devices (such as the [[computer keyboard|keyboard]]) and pointer input devices (such as the [[computer mouse|mouse]]).

The small program that starts this sequence is known as a ''bootstrap loader'', ''bootstrap'' or ''boot loader''. Often, multiple-stage boot loaders are used, during which several programs of increasing complexity load one after the other in a process of [[chain loading]].

Some earlier computer systems, upon receiving a boot signal from a human operator or a peripheral device, may load a very small number of fixed instructions into memory at a specific location, initialize at least one CPU, and then point the CPU to the instructions and start their execution. These instructions typically start an input operation from some peripheral device (which may be switch-selectable by the operator). Other systems may send hardware commands directly to peripheral devices or I/O controllers that cause an extremely simple input operation (such as "read sector zero of the system device into memory starting at location 1000") to be carried out, effectively loading a small number of boot loader instructions into memory; a completion signal from the I/O device may then be used to start execution of the instructions by the CPU.

Smaller computers often use less flexible but more automatic boot loader mechanisms to ensure that the computer starts quickly and with a predetermined software configuration. In many desktop computers, for example, the bootstrapping process begins with the CPU executing software contained in ROM (for example, the [[BIOS]] of an [[IBM PC]]) at a predefined address (some CPUs, including the Intel [[Intel 8086|x86 series]] are designed to execute this software after reset without outside help). This software contains rudimentary functionality to search for devices eligible to participate in booting, and load a small program from a special section (most commonly the [[boot sector]]) of the most promising device, typically starting at a fixed [[entry point]] such as the start of the sector.

Boot loaders may face peculiar constraints, especially in size; for instance, on the IBM PC and compatibles, the boot code must fit in the [[Master Boot Record]] (MBR) and the [[Partition Boot Record]] (PBR), which in turn are limited to a single sector; on the [[IBM System/360]], the size is limited by the IPL medium, e.g., [[Punched card|card]] size, track size.

On systems with those constraints, the first program loaded into RAM may not be sufficiently large to load the operating system and, instead, must load another, larger program. The first program loaded into RAM is called a first-stage boot loader, and the program it loads is called a second-stage boot loader. On many embedded CPUs, the CPU built-in [[boot ROM]], sometimes called the zero-stage boot loader,<ref>{{cite web |url=https://crvf2019.github.io/pdf/43.pdf |title=An Introduction to RISC-V Boot flow |access-date=2024-09-04}}</ref> can find and load first-stage boot loaders.

=== First-stage boot loaders ===
Examples of first-stage (hardware initialization stage) boot loaders include [[BIOS]], [[UEFI]], [[coreboot]], [[Libreboot]] and [[Das U-Boot]]. On the IBM PC, the boot loader in the [[Master Boot Record]] (MBR) and the [[Partition Boot Record]] (PBR) was coded to require at least 32&nbsp;KB<ref name="Paul_1997_OD-A3"/><ref name="msakamoto-mbr">{{cite web |author-first=Masahiko |author-last=Sakamoto |title=Why BIOS loads MBR into 7C00h in x86? |date=2010-05-13 |url=http://www.glamenv-septzen.net/en/view/6 |website=Glamenv-Septzen.net |access-date=2012-08-22 |archive-date=2017-08-24 |archive-url=https://web.archive.org/web/20170824002951/https://www.glamenv-septzen.net/en/view/6 |url-status=live}}</ref> (later expanded to 64&nbsp;KB<ref name="BBS_101">{{cite web |author1=Compaq Computer Corporation |author2=Phoenix Technologies Ltd |author3=Intel Corporation |date=1996-01-11 |title=BIOS Boot Specification 1.01 |url=https://acpica.org/sites/acpica/files/specsbbs101.pdf |archive-url=https://ghostarchive.org/archive/20221009/https://acpica.org/sites/acpica/files/specsbbs101.pdf |archive-date=2022-10-09 |url-status=live |access-date=2017-12-21}}</ref>) of system memory and only use instructions supported by the original [[8088]]/[[8086]] processors.

=== Second-stage boot loaders ===
{{Anchor|SECOND-STAGE}}
Second-stage (OS initialization stage) boot loaders, such as shim,<ref>{{cite web |last1=Red Hat Bootloader Team |title=UEFI shim loader |url=https://github.com/rhboot/shim |website=GitHub |access-date=28 October 2023}}</ref> [[GNU GRUB]], [[rEFInd]], [[BOOTMGR]], [[SYSLINUX|Syslinux]], [[NTLDR]] and [[iBoot]], are not themselves operating systems, but are able to load an operating system properly and transfer execution to it; the operating system subsequently initializes itself and may load extra [[device driver]]s. The second-stage boot loader does not need drivers for its own operation, but may instead use generic storage access methods provided by system firmware such as the BIOS, UEFI or [[Open Firmware]], though typically with restricted hardware functionality and lower performance.<ref>{{cite book |publisher=Microsoft |title=Windows NT Server Resource Kit |chapter=Chapter 6 - Troubleshooting Startup and Disk Problems |chapter-url=http://www.microsoft.com/resources/documentation/windowsnt/4/server/reskit/en-us/resguide/troubles.mspx?mfr=true |archive-url=https://web.archive.org/web/20070515104908/http://www.microsoft.com/resources/documentation/windowsnt/4/server/reskit/en-us/resguide/troubles.mspx?mfr=true |archive-date=2007-05-15}}</ref>

Many boot loaders (like GNU GRUB, rEFInd, Windows's BOOTMGR, Syslinux, and Windows NT/2000/XP's NTLDR) can be configured to give the user multiple booting choices. These choices can include different operating systems (for [[dual boot|dual or multi-booting]] from different partitions or drives), different versions of the same operating system (in case a new version has unexpected problems), different operating system loading options (e.g., booting into a rescue or [[safe mode]]), and some standalone programs that can function without an operating system, such as memory testers (e.g., [[memtest86+]]), a basic shell (as in GNU GRUB), or even games (see [[List of PC Booter games]]).<ref>{{cite web |url=http://www.coreboot.org/Tint |title=Tint |publisher=coreboot |access-date=2010-11-20 |archive-date=2010-12-28 |archive-url=https://web.archive.org/web/20101228053937/http://www.coreboot.org/Tint |url-status=live}}</ref> Some boot loaders can also load other boot loaders; for example, GRUB loads BOOTMGR instead of loading Windows directly. Usually a default choice is preselected with a time delay during which a user can press a key to change the choice; after this delay, the default choice is automatically run so normal booting can occur without interaction.

The boot process can be considered complete when the computer is ready to interact with the user, or the operating system is capable of running system programs or application programs.

=== Embedded and multi-stage boot loaders ===
{{Anchor|Embedded|MULTI-STAGE}}<!-- Note to future editors: consider breaking this into two sections if the contents expand to more than one paragraph. 

Possible alternate section title?: “Embedded and complex systems” 

See also the similar text contents at [[Bootloader#Embedded]]

-->
Many [[embedded system]]s must boot immediately. For example, waiting a minute for a [[Television set|digital television]] or a [[GPS navigation device]] to start is generally unacceptable. Therefore, such devices have software systems in ROM or [[flash memory]] so the device can begin functioning immediately; little or no loading is necessary, because the loading can be precomputed and stored on the ROM when the device is made.{{cn|date=September 2023}}

Large and complex systems may have boot procedures that proceed in multiple phases until finally the operating system and other programs are loaded and ready to execute. Because operating systems are designed as if they never start or stop, a boot loader might load the operating system, configure itself as a mere process within that system, and then irrevocably transfer control to the operating system. The boot loader then terminates normally as any other process would.

=== Network booting ===
{{Main|Network booting}}

Most computers are also capable of booting over a [[computer network]]. In this scenario, the operating system is stored on the disk of a [[server (computing)|server]], and certain parts of it are transferred to the client using a simple protocol such as the [[Trivial File Transfer Protocol]] (TFTP). After these parts have been transferred, the operating system takes over the control of the booting process.

As with the second-stage boot loader, network booting begins by using generic network access methods provided by the network interface's boot ROM, which typically contains a [[Preboot Execution Environment]] (PXE) image. No drivers are required, but the system functionality is limited until the operating system kernel and drivers are transferred and started. As a result, once the ROM-based booting has completed it is entirely possible to network boot into an operating system that itself does not have the ability to use the network interface.

== IBM-compatible personal computers (PC) ==
=== Boot devices ===
{{Anchor|Boot device|Quick boot}}
{{See also|System partition and boot partition}}
[[File:Windows To Go USB Drive.png|thumb|[[Windows To Go]] bootable flash drive, a [[Live USB]] example|link=Windows To Go]]

The boot device is the storage device from which the operating system is loaded. A modern PC's [[UEFI]] or [[BIOS]] firmware supports booting from various devices, typically a local [[solid-state drive]] or [[hard disk drive]] via the [[GUID Partition Table|GPT]] or [[Master Boot Record]] (MBR) on such a drive or disk, an [[optical disc drive]] (using [[El Torito (CD-ROM standard)|El Torito]]), a [[Universal Serial Bus|USB]] [[mass storage]] device ([[USB flash drive]], [[memory card reader]], USB hard disk drive, USB optical disc drive, USB solid-state drive, etc.), or a network interface card (using [[Preboot Execution Environment|PXE]]). Older, less common BIOS-bootable devices include [[boot floppy|floppy disk drives]], [[Zip drive]]s, and [[LS-120]] drives.

Typically, the system firmware (UEFI or BIOS) will allow the user to configure a ''boot order''. If the boot order is set to "first, the DVD drive; second, the hard disk drive", then the firmware will try to boot from the DVD drive, and if this fails (e.g. because there is no DVD in the drive), it will try to boot from the local hard disk drive.

For example, on a PC with [[Microsoft Windows|Windows]] installed on the hard drive, the user could set the boot order to the one given above, and then insert a [[Linux]] [[Live CD]] in order to try out [[Linux]] without having to install an operating system onto the hard drive. This is an example of [[dual booting]], in which the user chooses which operating system to start after the computer has performed its [[Power-on self-test]] (POST). In this example of dual booting, the user chooses by inserting or removing the DVD from the computer, but it is more common to choose which operating system to boot by selecting from a [[boot manager]] menu on the selected device, by using the computer keyboard to select from a [[BIOS]] or [[UEFI]] Boot Menu, or both; the Boot Menu is typically entered by pressing {{key press|F8}} or {{key press|F12}} keys during the POST; the [[BIOS Setup]] is typically entered by pressing {{key press|F2}} or {{key press|DEL}} keys during the POST.<ref>{{Cite web |title=List of PC brands with their corresponding hot-keys |url=https://www.disk-image.com/faq-bootmenu.htm |access-date=2020-09-26 |website=www.disk-image.com |archive-date=2020-11-11 |archive-url=https://web.archive.org/web/20201111195541/http://www.disk-image.com/faq-bootmenu.htm |url-status=live}}</ref><ref>{{Cite web |title=How to Enter the BIOS on Any PC: Access Keys by Manufacturer {{!}} Tom's Hardware |url=https://www.tomshardware.com/amp/reviews/bios-keys-to-access-your-firmware,5732.html |access-date=2020-09-26 |website=www.tomshardware.com |archive-date=2023-02-20 |archive-url=https://web.archive.org/web/20230220131717/https://www.tomshardware.com/reviews/bios-keys-to-access-your-firmware,5732.html |url-status=live}}</ref>

Several devices are available that enable the user to ''quick-boot'' into what is usually a variant of Linux for various simple tasks such as Internet access; examples are [[Splashtop OS|Splashtop]] and [[Latitude ON]].<ref>{{cite web |url=http://archive.linuxgizmos.com/montavista-linux-drives-dells-quick-boot-feature/ |title=MontaVista Linux drives Dell's quick-boot feature |author-first=Eric |author-last=Brown |date=2008-10-02 |publisher=linuxdevices.com |access-date=20 November 2010}}</ref><ref>{{cite web |url=https://www.phoronix.com/scan.php?page=article&item=splashtop_voodoo&num=1 |title=SplashTop Linux On HP, Dell Notebooks? |author-first=Michael |author-last=Larabel |author-link=Michael Larabel |date=2008-06-14 |publisher=[[Phoronix]] |access-date=20 November 2010 |archive-date=2016-10-05 |archive-url=https://web.archive.org/web/20161005104151/https://www.phoronix.com/scan.php?page=article&item=splashtop_voodoo&num=1 |url-status=live}}</ref><ref>{{cite web |url=https://www.youtube.com/watch?v=InUpF5Uetfc |archive-url=https://ghostarchive.org/varchive/youtube/20211113/InUpF5Uetfc |archive-date=2021-11-13 |url-status=live |title=Voodoo Envy's Instant-On IOS (powered by Splashtop) |date=16 July 2008 |publisher=YouTube |access-date=20 November 2010}}{{cbignore}}</ref>

=== Boot sequence ===
[[File:Binary executable file2.png|thumb|A [[hex dump]] of [[FreeBSD]]'s boot0 MBR]]
[[File:Award BIOS first screen.png|thumb|[[Award Software]] BIOS from 2000 during booting]]

Upon starting, an IBM-compatible personal computer's [[x86]] CPU, executes in [[real mode]], the instruction located at [[reset vector]] (the physical memory address {{Mono|FFFF0h}} on 16-bit x86 processors<ref>{{cite web |url=http://bitsavers.org/components/intel/80286/210498-001_iAPX_286_Programmers_Reference_1983.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/components/intel/80286/210498-001_iAPX_286_Programmers_Reference_1983.pdf |archive-date=2022-10-09 |url-status=live |title=iAPX 286 Programmer's Reference Manual |at=Section 5.3 SYSTEM INITIALIZATION, p. 5-7 |publisher=[[Intel]] |quote=Since the CS register contains F000 (thus specifying a code segment starting at physical address F0000) and the instruction pointer contains FFF0, the processor will execute its first instruction at physical address FFFF0H. |date=1983 |access-date=2019-08-23}}</ref> and {{Mono|FFFFFFF0h}} on 32-bit and 64-bit x86 processors<ref>{{cite web |url=http://bitsavers.org/components/intel/80386/230985-001_80386_Programmers_Reference_Manual_1986.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.org/components/intel/80386/230985-001_80386_Programmers_Reference_Manual_1986.pdf |archive-date=2022-10-09 |url-status=live |title=80386 Programmer's Reference Manual |at=Section 10.2.3 First Instructions, p. 10-3 |publisher=Intel |quote=After RESET, address lines A31–20 are automatically asserted for instruction fetches. This fact, together with the initial values of CS:IP, causes instruction execution to begin at physical address FFFFFFF0H. |date=1986 |access-date=2013-11-03}}</ref><ref>{{cite web |url=http://download.intel.com/products/processor/manual/325462.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://download.intel.com/products/processor/manual/325462.pdf |archive-date=2022-10-09 |url-status=live |at=Section 9.1.4 First Instruction Executed, p. 2611 |publisher=[[Intel Corporation]] |title=Intel 64 and IA-32 Architectures Software Developer's Manual |date=May 2012 |access-date=2012-08-23 |quote=The first instruction that is fetched and executed following a hardware reset is located at physical address FFFFFFF0h. This address is 16 bytes below the processor's uppermost physical address. The EPROM containing the software-initialization code must be located at this address.}}</ref>), usually pointing to the firmware ([[Unified Extensible Firmware Interface|UEFI]] or [[BIOS]]) entry point inside the ROM. This memory location typically contains a jump instruction that transfers execution to the location of the firmware ([[Unified Extensible Firmware Interface|UEFI]] or [[BIOS]]) start-up program. This program runs a [[power-on self-test]] (POST) to check and initialize required devices such as [[main memory]] ([[DRAM]]), the PCI bus and the PCI devices (including running embedded [[Option ROM]]s). One of the most involved steps is setting up DRAM over [[Serial Presence Detect|SPD]], further complicated by the fact that at this point memory is very limited.

After initializing required hardware, the firmware ([[Unified Extensible Firmware Interface|UEFI]] or [[BIOS]]) goes through a pre-configured list of [[Non-volatile memory|non-volatile storage devices]] ("boot device sequence") until it finds one that is bootable.

==== BIOS ====

Once the BIOS has found a bootable device it loads the boot sector to linear address {{Mono|7C00h}} (usually [[X86 memory segmentation|segment]]:[[Offset (computer science)|offset]] {{Mono|0000h}}:{{Mono|7C00h}},<ref name="Paul_1997_OD-A3"/><ref name="BBS_101" />{{rp|29}} but some BIOSes erroneously use {{Mono|07C0h}}:{{Mono|0000h}}{{citation needed|date=August 2012|reason=Some Compaq BIOSes are known to jump to 07C0h:0000h instead of the correct and official 0000h:7C00h address. This breaks any boot sector/MBR code not written to be relocatible or assuming certain register values on startup.}}) and transfers execution to the boot code. In the case of a hard disk, this is referred to as the [[Master Boot Record]] (MBR). The conventional MBR code checks the MBR's partition table for a partition set as ''bootable''<ref group=nb>The [[active partition]] may contain a [[Second-stage boot loader]], e.g., OS/2 Boot Manager, rather than an OS.</ref> (the one with ''active'' flag set).<!-- <ref>Per MBR specifications{{Citation needed|date=May 2023}} the [[active partition]] is not required to be [[primary partition]], however the [[boot sector]] code may require it to be in order to work properly.{{Citation needed |date=May 2023}}</ref> --> If an [[active partition]] is found, the MBR code loads the [[boot sector]] code from that partition, known as [[Volume Boot Record]] (VBR), and executes it. The MBR boot code is often operating-system specific.

A bootable MBR device is defined as one that can be read from, and where the last two bytes of the first sector contain the [[little-endian]] [[Word (data type)|word]] {{Mono|AA55h}},<ref group="nb" name="NB_Magic_AA55"/> found as byte sequence {{Mono|55h}}, {{Mono|AAh}} on disk (also known as the [[MBR boot signature]]), or where it is otherwise established that the code inside the sector is executable on x86 PCs.<!-- since not all BIOSes actually check for the signature -->

The boot sector code is the first-stage boot loader. It is located on [[fixed disk]]s and [[removable drive]]s, and must fit into the first 446<!-- 512-4*16-2 --> [[bytes]] of the [[Master Boot Record]] in order to leave room for the default 64-byte<!-- 4*16 --> [[partition table]] with four partition entries and the two-byte [[MBR boot signature|boot signature]], which the BIOS requires for a proper boot loader &mdash; or even less, when additional features like more than four partition entries (up to 16 with 16 bytes each), a [[MBR disk signature|disk signature]] (6 bytes), a [[MBR disk timestamp|disk timestamp]] (6 bytes), an [[Advanced Active Partition]] (18 bytes) or special [[multi-boot]] loaders<!-- like LOADER --> have to be supported as well in some environments. In [[floppy]] and [[superfloppy]] [[Volume Boot Record]]s, up to 59<!-- 51+8 (ignoring the 3-byte-jump which can be counted as code) --> bytes are occupied for the [[Extended BIOS Parameter Block]] on [[FAT12]] and [[FAT16]] volumes since DOS 4.0, whereas the [[FAT32]] EBPB introduced with DOS 7.1 requires even 87<!-- 79+8 --> bytes, leaving only 423<!-- 512-87-2 (ignoring the 3-byte-jump which can be counted as code) --> bytes for the boot loader when assuming a sector size of 512 bytes. Microsoft boot sectors therefore traditionally imposed certain restrictions on the boot process, for example, the boot file had to be located at a fixed position in the root directory of the file system and stored as consecutive sectors,<ref name="Duncan_1988_MS-DOS_Encyclopedia"/><ref name="Chappell_1994_DOS-Internals"/> conditions taken care of by the <code>[[SYS (DOS command)|SYS]]</code> command and slightly relaxed in later versions of DOS.<ref name="Chappell_1994_DOS-Internals"/><ref group="nb" name="NB_PC_DOS_Contiguous_files"/> The boot loader was then able to load the first three sectors of the file into memory, which happened to contain another embedded boot loader able to load the remainder of the file into memory.<ref name="Chappell_1994_DOS-Internals"/> When Microsoft added [[Logical block addressing|LBA]] and FAT32 support, they even switched to a boot loader reaching over ''two'' physical sectors and using 386 instructions for size reasons. At the same time other vendors managed to squeeze much more functionality into a single boot sector without relaxing the original constraints on only minimal available memory (32&nbsp;KB) and processor support ({{not a typo|8088/8086}}).<ref group="nb" name="NB_DR-DOS_707"/> For example, DR-DOS boot sectors are able to locate the boot file in the FAT12, FAT16<!-- since DR DOS 3.31 --> and FAT32<!-- DR-DOS 7.07 --> file system, and load it into memory as a whole via [[cylinder-head-sector|CHS]] or LBA, even if the file is not stored in a fixed location and in consecutive sectors.<ref name="Rosch_1991_SYS"/><ref name="Paul_1997_OD-A3"/><ref name="Paul_2001"/><ref name="Paul_2002"/><ref name="Paul_2017"/><ref group="nb" name="NB_DR-DOS_File-size"/><ref group="nb" name="NB_DR-DOS_707"/>

The VBR is often OS-specific; however, its main function is to load and execute the operating system boot loader file (such as <code>bootmgr</code> or <code>ntldr</code>), which is the second-stage boot loader, from an active partition. Then the boot loader loads the [[OS kernel]] from the storage device.

If there is no active partition, or the active partition's boot sector is invalid, the MBR may load a secondary boot loader which will select a partition (often via user input) and load its boot sector, which usually loads the corresponding operating system kernel. In some cases, the MBR may also attempt to load secondary boot loaders before trying to boot the active partition. If all else fails, it should issue an [[INT (x86 instruction)|INT]] 18h<ref name="BBS_101"/><ref name="Paul_1997_OD-A3"/> [[BIOS interrupt call]] (followed by an INT 19h just in case INT 18h would return) in order to give back control to the BIOS, which would then attempt to boot off other devices, attempt a [[network booting|remote boot]] via network.<ref name="Paul_1997_OD-A3"/>

==== UEFI ====

Many modern systems ([[Intel Mac]]s and newer [[Personal computer|PCs]]) use [[UEFI]].<ref>{{cite web |url=http://www.intel.com/technology/framework/ |title=Intel Platform Innovation Framework for EFI |publisher=Intel |access-date=2008-01-07 |archive-date=2011-08-21 |archive-url=https://web.archive.org/web/20110821043030/http://www.intel.com/technology/framework/ |url-status=live}}</ref><ref>{{cite web |url=http://www.coreboot.org/OpenBIOS |title=OpenBIOS - coreboot |publisher=coreboot.org |access-date=2013-03-20 |archive-date=2013-03-18 |archive-url=https://web.archive.org/web/20130318081707/http://www.coreboot.org/OpenBIOS |url-status=live}}</ref>

Unlike BIOS, UEFI (not '''Legacy boot''' via CSM) does not rely on boot sectors, UEFI system loads the boot loader ('''EFI application''' file in [[USB disk]] or in the [[EFI System Partition]]) directly,<ref>{{Cite web |title=UEFI - OSDev Wiki |url=https://wiki.osdev.org/UEFI |access-date=2020-09-26 |website=wiki.osdev.org |archive-date=2020-11-12 |archive-url=https://web.archive.org/web/20201112030038/https://wiki.osdev.org/UEFI |url-status=live}}</ref> and the OS kernel is loaded by the boot loader.

== Other kinds of boot sequences ==
{{Anchor|SPL}}
[[File:Bootloader Android HTC Pico.JPG|right|thumb|An [[unlocked bootloader]] of an [[Android (operating system)|Android]] device, showing additional available options]]

Many modern CPUs, SoCs and microcontrollers (for example, [[Texas Instruments|TI]] [[OMAP]]) or sometimes even [[digital signal processors]] (DSPs) may have boot ROM integrated directly into their silicon, so such a processor can perform a simple boot sequence on its own and load boot programs (firmware or software) from boot sources such as NAND flash or eMMC. It is difficult to hardwire all the required logic for handling such devices, so an integrated boot ROM is used instead in such scenarios. Also, a boot ROM may be able to load a boot loader or diagnostic program via serial interfaces like [[UART]], [[Serial Peripheral Interface Bus|SPI]], [[USB]] and so on. This feature is often used for system recovery purposes, or it could also be used for initial non-volatile memory programming when there is no software available in the non-volatile memory yet. Many modern microcontrollers (e.g. flash memory controller on [[USB flash drive]]s) have firmware ROM integrated directly into their silicon.

Some [[embedded system]] designs may also include an intermediary boot sequence step. For example, [[Das U-Boot]] may be split into two stages: the platform would load a small SPL (Secondary Program Loader), which is a stripped-down version of U-Boot, and the SPL would do some initial hardware configuration (e.g. [[DRAM]] initialization using CPU cache as RAM) and load the larger, fully featured version of U-Boot.<ref>{{cite web |url=http://processors.wiki.ti.com/index.php/The_Boot_Process |title=Overview – The four bootloader stages |date=2013-12-05 |access-date=2015-01-25 |publisher=[[Texas Instruments]] |website=ti.com |archive-date=2014-12-23 |archive-url=https://web.archive.org/web/20141223025158/http://processors.wiki.ti.com/index.php/The_Boot_Process |url-status=live}}</ref> Some CPUs and SoCs may not use CPU cache as RAM on boot process, they use an integrated boot processor to do some hardware configuration, to reduce cost.<ref>{{cite web |url=https://rxos.readthedocs.io/en/develop/how_it_works/boot.html |title=The boot process rxos 1.0rc1 documentation |access-date=2015-10-25 }}</ref>

It is also possible to take control of a system by using a hardware debug interface such as [[JTAG]]. Such an interface may be used to write the boot loader program into bootable non-volatile memory (e.g. flash) by instructing the processor core to perform the necessary actions to program non-volatile memory. Alternatively, the debug interface may be used to upload some diagnostic or boot code into RAM, and then to start the processor core and instruct it to execute the uploaded code. This allows, for example, the recovery of embedded systems where no software remains on any supported boot device, and where the processor does not have any integrated boot ROM. JTAG is a standard and popular interface; many CPUs, microcontrollers and other devices are manufactured with JTAG interfaces ({{as of|2009|lc=true}}).{{cite needed|date=September 2023}}

Some microcontrollers provide special hardware interfaces which cannot be used to take arbitrary control of a system or directly run code, but instead they allow the insertion of boot code into bootable non-volatile memory (like flash memory) via simple protocols. Then at the manufacturing phase, such interfaces are used to inject boot code (and possibly other code) into non-volatile memory. After system reset, the microcontroller begins to execute code programmed into its non-volatile memory, just like usual processors are using ROMs for booting. Most notably this technique is used by [[Atmel AVR]] microcontrollers, and by others as well. In many cases such interfaces are implemented by hardwired logic. In other cases such interfaces could be created by software running in integrated on-chip boot ROM from [[GPIO]] pins.

Most DSPs have a serial mode boot, and a parallel mode boot, such as the host port interface (HPI boot).

In case of DSPs there is often a second microprocessor or microcontroller present in the system design, and this is responsible for overall system behavior, interrupt handling, dealing with external events, user interface, etc. while the DSP is dedicated to signal processing tasks only. In such systems the DSP could be booted by another processor which is sometimes referred as the ''host processor'' (giving name to a Host Port). Such a processor is also sometimes referred as the ''master'', since it usually boots first from its own memories and then controls overall system behavior, including booting of the DSP, and then further controlling the DSP's behavior. The DSP often lacks its own boot memories and relies on the host processor to supply the required code instead. The most notable systems with such a design are cell phones, modems, audio and video players and so on, where a DSP and a CPU/microcontroller are co-existing.

Many [[FPGA]] chips load their configuration from an external serial [[EEPROM]] ("configuration ROM") on power-up.

== Security ==
Various measures have been implemented which enhance the [[Computer security|security]] of the booting process. Some of them are made mandatory, others can be disabled or enabled by the [[end user]]. Traditionally, booting did not involve the use of [[cryptography]]. The security can be bypassed by [[Bootloader unlocking|unlocking the boot loader]], which might or might not be approved by the manufacturer.  Modern boot loaders make use of concurrency, meaning they can run multiple processor cores, and threads at the same time, which add extra layers of complexity to secure booting.

[[Matthew Garrett]] argued that booting security serves a legitimate goal but in doing so chooses [[Default (computer science)|defaults]] that are hostile to users.<ref>{{Cite web |title=mjg59 {{!}} Boot Guard and PSB have user-hostile defaults |url=https://mjg59.dreamwidth.org/58424.html |access-date=2022-11-30 |website=mjg59.dreamwidth.org |language=en}}</ref>

=== Measures ===
* UEFI secure boot<ref>{{Cite web |title=Microsoft blocks UEFI bootloaders enabling Windows Secure Boot bypass |url=https://www.bleepingcomputer.com/news/security/microsoft-blocks-uefi-bootloaders-enabling-windows-secure-boot-bypass/ |access-date=2022-12-11 |website=[[BleepingComputer]] |language=en-us}}</ref>
* Android Verified boot
* Samsung Knox
* Measured boot with the Trusted Platform Module, also known as "trusted boot".
* Intel BootGuard
* Disk encryption
* Firmware passwords

===Bootloop===
[[File:TL-WR1043-ND V1 Serial Console.jpg|thumb|right|[[UART]] console of a [[TP-Link]] router with [[OpenWrt]] that is stuck in a bootloop]]

When [[debugging]] a concurrent and distributed [[system of systems]], a '''bootloop''' (also called '''boot loop''' or '''boot-loop''') is a diagnostic condition of an [[#Detection of an erroneous state|§ erroneous state]] that occurs on computing devices; when those devices repeatedly fail to complete the [[booting]] process and [[Reboot|restart]] before a boot sequence is finished,  a restart might prevent a user from accessing the regular interface.

{{quote|As the complexity of today's products increases, single projects, single departments or even single companies can no longer develop total products, causing concurrent and distributed development. Today and worldwide, industries are facing complex product development and its vast array of associated problems, relating to project organization, project control and product quality. Many processes will become distributed as well. The defect detection process, so important for measuring and eventually achieving product quality, is typically one of the first to experience problems caused by the distributed nature of the project. The distribution of defect detection activities over several parties introduces risks like the inadequate review of work products, occurrence of "blind spots" with respect to test coverage or over-testing of components. Lifecycle-wide coordination of defect detection is therefore needed to ensure effectiveness and efficiency of defect detection activities. —J.J.M. Trienekens; R.J. Kusters. (2004)<ref name=2004DefectDetection >J.J.M. Trienekens; R.J. Kusters. (2004)  [https://ieeexplore.ieee.org/document/1372126 (conference 19-21 September 2003)   Workshop: defect detection in distributed software development] ''Eleventh Annual International Workshop on Software Technology and Engineering Practice'' published [https://doi.org/10.1109/STEP.2003.40 IEEE Xplore: 27 December 2004] </ref>}}

====Detection of an erroneous state====
The system might exhibit its erroneous state, say in an explicit bootloop or [[Blue screen of death]], before recovery is indicated.<ref name=23JulReview /> Detection of an erroneous state may require a [[Apache Kafka|distributed event store and stream-processing platform]] for real-time operation of a distributed system.

====Recovery from an erroneous state====
An erroneous state can trigger bootloops; this state can be caused by misconfiguration from previously known-good operations.{{efn|name=crowdstrikeBootloop}} Recovery attempts from that erroneous state then enter a reboot, in an attempt to return to a known-good state. In Windows OS operations, for example, the recovery procedure was to reboot three times, the reboots needed to return to a usable menu. <ref name=1pctOfWindows >Joe Tidy, BBC News [https://www.bbc.com/news/articles/cpe3zgznwjno (20 Jul 2024) CrowdStrike IT outage affected 8.5 million Windows devices, Microsoft says]</ref> <ref name=theBreakingChange >Eye Security update: the Breaking Change, 4:09 AM UTC on July 19th 2024, reverted 05:27 AM UTC [https://www.eye.security/blog/crowdstrike-falcon-blue-screen-issue-updates (19 Jul 2024) BSOD error in latest CrowdStrike update] Reddit update, 20 000 replies</ref> <ref name=23JulReview >Tim Warren, The Verge [https://www.theverge.com/2024/7/23/24204196/crowdstrike-windows-bsod-faulty-update-microsoft-responses (23 Jul 2024) Inside the 78 minutes that took down millions of Windows machines]</ref>

====Recovery policy====
Recovery might be specified via [[Security Assertion Markup Language]] (SAML), which can also implement [[Single sign-on]] (SSO) for some applications; in the [[zero trust security model]] identification, authorization, and authentication are separable concerns in an SSO session. When recovery of a site is indicated (viz. a [[blue screen of death]] is displayed on an airport terminal screen){{efn|name=crowdstrikeBootloop}} personal site visits might be required to remediate the situation.<ref name=2004DefectDetection /> 

==== Examples ====
* [[Windows NT 4.0]]<ref>{{cite book | last=Ruley | first=John D. | author2= David Methvin | author3=Tom Henderson | author4=Martin Heller | date=1997 | url=https://books.google.com/books?id=fA0gDTOdUWUC&q=%22infinite+loop%22+%22reboot%22 | title=Networking Windows NT 4.0: Workstation and Server | publisher=Wiley | page=257 | isbn=9780471175025 | via=Google Books}}</ref>
* [[Windows 2000]]<ref>{{cite journal | last=Shultz | first=Gregory | date=February 2001 | url=https://www.proquest.com/docview/191083238 | title=Disabling automatic reboot prevents possible reboot loop | journal=Windows Professional | publisher=Element K Journals | volume=6 | issue=2 | page=9 | id={{ProQuest|191083238}} | via=ProQuest}}</ref>
* [[Windows Server]]<ref>{{Cite web |title=New Windows Server updates cause DC boot loops, break Hyper-V |url=https://www.bleepingcomputer.com/news/microsoft/new-windows-server-updates-cause-dc-boot-loops-break-hyper-v/ |access-date=2022-05-17 |website=[[BleepingComputer]] |language=en-us}}</ref>
* [[Windows 10]]<ref>{{Cite web |author1=Paul Wagenseil |date=2021-01-21 |title=Windows 10 update sending PCs into endless boot cycle: What to do |url=https://www.tomsguide.com/news/windows-10-automatic-repair-boot-loop |access-date=2022-05-20 |website=[[Tom's Guide]] |language=en}}</ref>
* The [[Nexus 5X]]<ref>{{Cite web |last=Hollister |first=Sean |date=2021-10-19 |title=Google has tried everything but building the best phone |url=https://www.theverge.com/2021/10/19/22734039/google-pixel-6-pro-price-marketing-premium-flagship-editorial |access-date=2022-05-17 |website=[[The Verge]] |language=en}}</ref>
* [[Android 10]]: when setting a specific image as wallpaper, the [[luminance]] value exceeded the maximum of 255 which happened due to a [[Round-off error|rounding error]] during conversion from [[sRGB]] to [[RGB color spaces|RGB]]. This then crashed the SystemUI component on every boot.<ref>{{Cite web |title='It was unintentional,' says creator of 'cursed' Android wallpaper |url=https://www.theweek.in/news/sci-tech/2020/06/11/it-was-unintentional-says-creator-of-cursed-android-wallpaper.html |access-date=2022-05-19 |website=The Week |language=en}}</ref><ref>{{Cite web |last=Hager |first=Ryne |date=2020-06-01 |title=Google thinks it has solved the mystery of the cursed bootlooping wallpaper |url=https://www.androidpolice.com/2020/06/04/choosing-the-wrong-wallpaper-can-bootloop-your-android-phone/ |access-date=2022-05-19 |website=Android Police |language=en-US}}</ref>
* [[Google Nest]] hub<ref>{{Cite web |last=Peckham |first=James |date=2022-03-29 |title=Google Nest Hub gets a new UI that's so fresh it could bootloop your smart display |url=https://www.androidpolice.com/google-nest-hub-ui-redesign-may-bootloop-smart-display/ |access-date=2022-05-19 |website=Android Police |language=en-US}}</ref>
* [[LG smartphone bootloop issues]]
* On 19 July 2024, an update of [[CrowdStrike]]{{'}}s Falcon software caused the [[2024 CrowdStrike incident]] resulting in [[Microsoft Windows]] systems worldwide stuck in bootloops or [[recovery mode]].{{efn|name=crowdstrikeBootloop|1= CrowdStrike reverted the content update at 05:27 UTC,<ref name="crowdstrike.com-240719">{{Cite web |title=Statement on Falcon Content Update for Windows Hosts |url=https://www.crowdstrike.com/blog/statement-on-windows-sensor-update/ |access-date=19 July 2024 |website=crowdstrike.com |language=en}}</ref> This left machines stuck in a [[Bootloop|boot loop]] or in [[recovery mode]].<ref>{{Cite web |last=Baran |first=Guru |date=19 July 2024 |title=CrowdStrike Update Pushing Windows Machines Into a BSOD Loop |url=https://cybersecuritynews.com/crowdstrike-update-bsod-loop/ |access-date=19 July 2024 |website=Cyber Security News |language=en-US}}</ref> and devices booted after the revert were not affected.<ref name="www.eye.security">{{Cite web |title=CrowdStrike Falcon blue screen issue updates |url=https://www.eye.security/blog/crowdstrike-falcon-blue-screen-issue-updates |access-date=19 July 2024 |website=www.eye.security |language=en}}</ref><ref>{{Cite web |date=19 July 2024 |title=Botched security update breaks Windows worldwide, causing BSOD and crashes |url=https://www.neowin.net/news/botched-security-update-breakes-windows-worldwide-causing-bsod-and-crashes/ |access-date=19 July 2024 |website=Neowin |language=en}}</ref>}}

== See also ==
{{Wiktionary|bootup}}
{{Div col|colwidth=18em}}
* {{section link|Bootstrapping|Computing}}
* [[Multi-booting]]
* [[Boot disk]]
* [[Bootkit]]
* [[Comparison of boot loaders]]
* [[Linux startup process]]
* [[Macintosh startup]]
* [[Microreboot]]
* [[Multi boot]]
* [[Network booting]]
* [[RedBoot]]
* [[Self-booting disk]]
* [[Windows startup process]]
{{Div col end}}

== Notes ==
{{Notelist}}

{{reflist|group="nb"|refs=
<ref group="nb" name="NB_Magic_AA55">The signature at offset <code>+1FEh</code> in boot sectors is <code>55h AAh</code>, that is <code>55h</code> at offset <code>+1FEh</code> and <code>AAh</code> at offset <code>+1FFh</code>. Since [[little-endian]] representation must be assumed in the context of [[IBM PC]] compatible machines, this can be written as 16-bit word <code>AA55h</code> in programs for [[Intel x86|x86]] processors (note the swapped order), whereas it would have to be written as <code>55AAh</code> in programs for other CPU architectures using a [[big-endian]] representation. Since this has been mixed up numerous times in books and even in original Microsoft reference documents,<!-- one example of many: http://technet.microsoft.com/en-us/library/cc977219.aspx as of 2012-01-14 --> this article uses the offset-based byte-wise on-disk representation to avoid any possible misinterpretation.</ref>
<ref group="nb" name="NB_PC_DOS_Contiguous_files">The [[PC&nbsp;DOS&nbsp;5.0]] manual incorrectly states that the system files no longer need to be contiguous. However, for the boot process to work the system files still need to occupy the first two directory entries and the first three sectors of [[IBMBIO.COM]] still need to be stored contiguously. [[SYS (DOS command)|SYS]] continues to take care of these requirements.<!-- See Chappell "DOS Internals" for further details --></ref>
<ref group="nb" name="NB_DR-DOS_File-size">There is one exception to the rule that [[DR-DOS]] [[Volume boot record|VBR]]s will load the whole [[IBMBIO.COM]] file into memory: If the IBMBIO.COM file is larger than some 29&nbsp;KB, trying to load the whole file into memory would result in the boot loader to [[#Paul_1997_ODA3|overwrite]] the [[call stack|stack]] and [[Relocation (computing)|relocated]] [[Disk Parameter Table]] (DPT/FDPB).{{citeref|Paul|1997|A}} Therefore, a [[DR-DOS&nbsp;7.07]] VBR would only load the first 29&nbsp;KB of the file into memory, relying on another loader embedded into the first part of IBMBIO.COM to check for this condition and load the remainder of the file into memory by itself if necessary. This does not cause compatibility problems, as IBMBIO.COM's size never exceeded this limit in previous versions without this loader.{{citeref|Paul|1997|A}} Combined with a dual entry structure this also allows the system to be loaded by a [[PC&nbsp;DOS]] VBR, which would load only the first three sectors of the file into memory.</ref>
<ref group="nb" name="NB_DR-DOS_707">As an example, while the extended functionality of DR-DOS [[master boot record|MBR]]s and [[volume boot record|boot sector]]s compared to their [[MS-DOS]]/[[PC&nbsp;DOS]] counterparts could still be achieved utilizing conventional [[code optimization]] techniques in [[assembly language]] up to [[DR-DOS 7.05|7.05]]<!-- yes, 7.05, not 7.06, as 7.06 was designed to be compatible with Microsoft's MS-DOS 7.10 boot sector -->, for the addition of [[logical block addressing|LBA]], [[FAT32]] and [[NEWLDR|LOADER]] support the [[DR-DOS 7.07|7.07]] sectors had to resort to [[self-modifying code]], [[opcode]]-level programming in [[machine language]], controlled utilization of (documented) [[side effect (computer science)|side effect]]s, multi-level data/code [[instruction overlapping|overlapping]] and algorithmic [[fold (function)|fold]]ing techniques to squeeze everything into a single physical sector, as it was a requirement for [[backward compatibility|backward]]- and cross-compatibility with other operating systems in [[multi-boot]] and [[chain load]] scenarios.</ref>
}}

== References ==
{{reflist|refs=
<ref name="Duncan_1988_MS-DOS_Encyclopedia">{{Cite book |title=The MS-DOS Encyclopedia: versions 1.0 through 3.2 |author-first1=Ray |author-last1=Duncan |author-first2=Steve |author-last2=Bostwick |author-first3=Keith |author-last3=Burgoyne |author-first4=Robert A. |author-last4=Byers |author-first5=Thom |author-last5=Hogan |author-first6=Jim |author-last6=Kyle |author-first7=Gordon |author-last7=Letwin |author-link7=Gordon Letwin |author-first8=Charles |author-last8=Petzold |author-link8=Charles Petzold |author-first9=Chip |author-last9=Rabinowitz |author-first10=Jim |author-last10=Tomlin |author-first11=Richard |author-last11=Wilton |author-first12=Van |author-last12=Wolverton |author-first13=William |author-last13=Wong |author-first14=JoAnne |author-last14=Woodcock |contribution=Technical advisors |contributor-first1=Mark |contributor-last1=Zbikowski |contributor-link1=Mark Zbikowski |contributor-first2=Paul |contributor-last2=Allen |contributor-link2=Paul Allen |contributor-first3=Steve |contributor-last3=Ballmer |contributor-link3=Steve Ballmer |contributor-first4=Reuben |contributor-last4=Borman |contributor-first5=Rob |contributor-last5=Borman |contributor-first6=John |contributor-last6=Butler |contributor-first7=Chuck |contributor-last7=Carroll |contributor-first8=Mark |contributor-last8=Chamberlain |contributor-first9=David |contributor-last9=Chell |contributor-first10=Mike |contributor-last10=Colee |contributor-first11=Mike |contributor-last11=Courtney |contributor-first12=Mike |contributor-last12=Dryfoos |contributor-first13=Rachel |contributor-last13=Duncan |contributor-first14=Kurt |contributor-last14=Eckhardt |contributor-first15=Eric |contributor-last15=Evans |contributor-first16=Rick |contributor-last16=Farmer |contributor-first17=Bill |contributor-last17=Gates |contributor-link17=Bill Gates |contributor-first18=Michael |contributor-last18=Geary |contributor-first19=Bob |contributor-last19=Griffin |contributor-first20=Doug |contributor-last20=Hogarth |contributor-first21=James W. |contributor-last21=Johnson |contributor-first22=Kaamel |contributor-last22=Kermaani |contributor-first23=Adrian |contributor-last23=King |contributor-first24=Reed |contributor-last24=Koch |contributor-first25=James |contributor-last25=Landowski |contributor-first26=Chris |contributor-last26=Larson |contributor-first27=Thomas |contributor-last27=Lennon |contributor-first28=Dan |contributor-last28=Lipkie |contributor-first29=Marc |contributor-last29=McDonald |contributor-link29=Marc McDonald |contributor-first30=Bruce |contributor-last30=McKinney |contributor-first31=Pascal |contributor-last31=Martin |contributor-first32=Estelle |contributor-last32=Mathers |contributor-first33=Bob |contributor-last33=Matthews <!-- |contributor-link33=Robert Matthews (scientist)??? --> |contributor-first34=David |contributor-last34=Melin |contributor-first35=Charles |contributor-last35=Mergentime |contributor-first36=Randy |contributor-last36=Nevin |contributor-first37=Dan |contributor-last37=Newell |contributor-first38=Tani |contributor-last38=Newell |contributor-first39=David |contributor-last39=Norris |contributor-first40=Mike |contributor-last40=O'Leary |contributor-first41=Bob |contributor-last41=O'Rear |contributor-link41=Bob O'Rear |contributor-first42=Mike |contributor-last42=Olsson |contributor-first43=Larry |contributor-last43=Osterman |contributor-first44=Ridge |contributor-last44=Ostling |contributor-first45=Sunil |contributor-last45=Pai |contributor-first46=Tim |contributor-last46=Paterson |contributor-link46=Tim Paterson |contributor-first47=Gary |contributor-last47=Perez |contributor-first48=Chris |contributor-last48=Peters |contributor-first49=Charles |contributor-last49=Petzold |contributor-link49=Charles Petzold |contributor-first50=John |contributor-last50=Pollock |contributor-first51=Aaron |contributor-last51=Reynolds |contributor-link51=Aaron R. Reynolds |contributor-first52=Darryl |contributor-last52=Rubin |contributor-first53=Ralph |contributor-last53=Ryan |contributor-first54=Karl |contributor-last54=Schulmeisters |contributor-first55=Rajen |contributor-last55=Shah |contributor-first56=Barry |contributor-last56=Shaw |contributor-first57=Anthony |contributor-last57=Short |contributor-first58=Ben |contributor-last58=Slivka |contributor-first59=Jon |contributor-last59=Smirl |contributor-first60=Betty |contributor-last60=Stillmaker |contributor-first61=John |contributor-last61=Stoddard |contributor-first62=Dennis |contributor-last62=Tillman |contributor-first63=Greg |contributor-last63=Whitten |contributor-first64=Natalie |contributor-last64=Yount |contributor-first65=Steve |contributor-last65=Zeck |date=1988 |edition=Completely reworked |publisher=[[Microsoft Press]] |location=Redmond, Washington, USA |isbn=1-55615-049-0 |lccn=87-21452 |oclc=16581341}} (xix+1570 pages; 26&nbsp;cm) (NB. This edition was published in 1988 after extensive rework of the withdrawn 1986 first edition by a different team of authors: {{cite web |url=https://www.pcjs.org/pubs/pc/reference/microsoft/mspl13/msdos/encyclopedia/ |title=The MS-DOS Encyclopedia (1988) |website=PCjs Machines |archive-url=https://web.archive.org/web/20181014053041/https://www.pcjs.org/pubs/pc/reference/microsoft/mspl13/msdos/encyclopedia/ |archive-date=2018-10-14 |url-status=live}})</ref>
<ref name="Chappell_1994_DOS-Internals">{{cite book |title=DOS Internals |author-first=Geoff |author-last=Chappell |chapter=Chapter 2: The System Footprint |editor-first1=Andrew |editor-last1=Schulman |editor-first2=Amorette |editor-last2=Pedersen |date=January 1994 |edition=1st printing, 1st |series=The Andrew Schulman Programming Series |publisher=[[Addison Wesley Publishing Company]] |isbn=978-0-201-60835-9}} (xxvi+738+iv pages, 3.5"-floppy [https://web.archive.org/web/20190421200111/https://gopher.tildeverse.org/gopher.viste.fr/9/programming/PC/DOS/DOS%2520Internals/DOS_Internals.zip][https://web.archive.org/web/20200222111608/https://www.pcjs.org/pubs/pc/programming/DOS_Internals/]) Errata: [https://web.archive.org/web/20200222111742/http://www.geoffchappell.com/notes/dos/internals/][https://web.archive.org/web/20200222111853/https://gopher.tildeverse.org/gopher.viste.fr/1/programming/PC/DOS/DOS%2520Internals/crtdrvr][https://web.archive.org/web/20200222111945/https://gopher.tildeverse.org/gopher.viste.fr/1/programming/PC/DOS/DOS%2520Internals/xmswatch]</ref>
<ref name="Rosch_1991_SYS">{{cite magazine |title=DR DOS 5.0 - The better operating system? |author-first=Winn L. |author-last=Rosch |magazine=[[PC Magazine]] |date=1991-02-12 |volume=10 |number=3 |page=<!-- 245, -->241–246, 257, 264, 266 |url=https://books.google.com/books?id=YxFTezF9-sMC&pg=PT250 |access-date=2019-07-26 |url-status=live |archive-url=https://archive.today/20190725223320/https://books.google.nl/books?id=YxFTezF9-sMC&pg=PT250&lpg=PT250&redir_esc=y%23v=onepage&q&f=false |archive-date=25 July 2019 |quote=[…] [[SYS (DOS command)|SYS]] has been improved under [[DR&nbsp;DOS 5.0]] so you don't have to worry about leaving the first cluster free on a disk that you want to make bootable. The DR&nbsp;DOS system files can be located anywhere on the disk, so any disk with enough free space can be set to boot your system. […]}} (NB. The source attributes this to the SYS utility while in fact this is a feature of the advanced bootstrap loader in the boot sector. SYS just plants this sector onto the disk.)</ref>
<ref name="Paul_1997_OD-A3">{{anchor|Paul_1997_ODA3}}{{cite web |author-first=Matthias R. |author-last=Paul |title=Caldera OpenDOS 7.01/7.02 Update Alpha 3 IBMBIO.COM - README.TXT and BOOT.TXT - A short description of how OpenDOS is booted |url=http://www.uni-bonn.de/~uzs180/download/ibmbioa3.zip |date=1997-10-02 |orig-date=1997-09-29 |access-date=2009-03-29 |url-status=dead |archive-url=https://web.archive.org/web/20031004074600/http://www-student.informatik.uni-bonn.de/~frinke/ibmbioa3.zip |archive-date=2003-10-04}} [https://web.archive.org/web/20181225154705/http://mirror.macintosharchive.org/max1zzz.co.uk/+Windows%20&%20DOS/DOS/System/Novell/Support/Bins/Op702src.zip<!-- Op702src.zip is an unofficial renamed distribution of the ibmbioa3.zip file -->]</ref>
<ref name="Paul_2001">{{cite web |title=FAT32 in DR-DOS |author-first=Matthias R. |author-last=Paul |date=2001-01-17 |work=opendos@delorie |url=http://www.delorie.com/opendos/archives/browse.cgi?p=opendos/2001/01/17/02:29:47 |access-date=2017-10-06 |url-status=live |archive-url=https://web.archive.org/web/20171006205537/http://www.delorie.com/opendos/archives/browse.cgi?p=opendos%2F2001%2F01%2F17%2F02%3A29%3A47 |archive-date=2017-10-06 |quote=[…] The [[DR-DOS]] boot sector […] searches for the [[IBMBIO.COM]] ([[DRBIOS.SYS]]) file and then loads the *whole* file into memory before it passes control to it. […]}}</ref>
<ref name="Paul_2002">{{cite web |title=Can't copy |author-first=Matthias R. |author-last=Paul |date=2002-02-20 |work=opendos@delorie |url=http://www.delorie.com/opendos//archives/browse.cgi?p=opendos/2002/02/20/16:17:57 |access-date=2017-10-06 |url-status=live |archive-url=https://web.archive.org/web/20171006211007/http://www.delorie.com/opendos//archives/browse.cgi?p=opendos%2F2002%2F02%2F20%2F16%3A17%3A57 |archive-date=2017-10-06 |quote=[…] The [[DR-DOS]] boot sector loads the whole [[IBMBIO.COM]] file into memory before it executes it. It does not care at all about the [[IBMDOS.COM]] file, which is loaded by IBMBIO.COM. […] The DR-DOS boot sector […] will find the […] kernel files as long as they are logically stored in the root directory. Their physical location on the disk, and if they are fragmented or not, is don't care for the DR-DOS boot sector. Hence, you can just copy the kernel files to the disk (even with a simply [[COPY (DOS command)|COPY]]), and as soon as the boot sector is a DR-DOS sector, it will find and load them. Of course, it is difficult to put all this into just 512 bytes, the size of a single sector, but this is a major convenience improvement if you have to set up a DR-DOS system, and it is also the key for the DR-DOS multi-OS [[NEWLDR|LOADER]] utility to work. The [[MS-DOS]] kernel files must reside on specific locations, but the DR-DOS files can be anywhere, so you don't have to physically swap them around each time you boot the other OS. Also, it allows to upgrade a DR-DOS system simply by copying the kernel files over the old ones, no need for [[SYS (DOS command)|SYS]], no difficult setup procedures as required for MS-DOS/[[PC&nbsp;DOS]]. You can even have multiple DR-DOS kernel files under different file names stored on the same drive, and LOADER will switch between them according to the file names listed in the [[BOOT.LST]] file. […]}}</ref>
<ref name="Paul_2017">{{cite web |title=The continuing saga of Windows 3.1 in enhanced mode on OmniBook 300 |author-first=Matthias R. |author-last=Paul |orig-date=2017-08-07 |date=2017-08-14 |work=MoHPC - the Museum of HP Calculators |url=http://hpmuseum.org/forum/thread-8774-post-76925.html#pid76925 |access-date=2017-10-06 |url-status=live |archive-url=https://web.archive.org/web/20171006204718/http://hpmuseum.org/forum/thread-8774-post-76925.html |archive-date=2017-10-06 |quote=[…] the [[DR-DOS]] [[FDISK (DOS command)|FDISK]] does not only partition a disk, but can also format the freshly created volumes and initialize their boot sectors in one go, so there's no risk to accidentally mess up the wrong volume and no need for [[FORMAT (DOS command)|FORMAT]] /S or [[SYS (DOS command)|SYS]]. Afterwards, you could just copy over the remaining DR-DOS files, including the system files. It is important to know that, in contrast to [[MS-DOS]]/[[PC&nbsp;DOS]], DR-DOS has "smart" boot sectors which will actually "mount" the file-system to search for and load the system files in the root directory instead of expecting them to be placed at a certain location. Physically, the system files can be located anywhere and also can be fragmented. […]}}</ref>
}}

{{Firmware and booting}}

[[Category:Booting| ]]