[4.1.3] Hardware–firmware–OS–apps
How hardware, firmware and the operating system work together to run applications
Big picture: from silicon to your favourite app
Every time you tap an icon or double-click a shortcut, a carefully layered system springs into action. At the base is the hardware – the physical electronic components such as the processor, memory chips, storage devices and input/output peripherals. Sitting directly on top of the hardware is low-level control software called firmware (for example, BIOS/UEFI in PCs, or boot ROMs in phones and printers). Once the hardware has been initialised by firmware, the operating system (OS) loads and provides the environment in which applications can run safely and efficiently. Each layer has a defined role; applications do not touch hardware directly but ask the OS for services, and the OS in turn works with firmware and device electronics to get the job done.
This page explains the responsibilities of each layer, how they connect, what happens when the system starts, and why the separation matters for performance, portability and security at IGCSE level.
Roles of the layers
Hardware: the physical capability of the system
Hardware refers to the tangible parts of a computer system. Key elements include the CPU (carries out instructions), RAM (stores data and instructions currently in use), secondary storage (such as SSDs and hard drives), and peripherals (display, keyboard, mouse, network interface, printer). Hardware determines the maximum possible speed, the amount of data that can be stored or processed at once, and which features are available. On its own, hardware cannot organise work – it needs instructions and configuration.
Firmware: the hardware's built-in control
Firmware is permanent or semi-permanent software programmed into non-volatile chips on the device. Its job is to initialise and test hardware, provide very basic input/output services, and locate and start the operating system. Examples include PC BIOS/UEFI, smartphone bootloaders, and microcontroller firmware in printers or SSDs. Firmware speaks the hardware's exact language and knows how to set voltages, speeds and timings. It is designed to run before the OS and continues to provide essential routines and configuration after the OS is running.
Operating system: the platform for applications
The operating system is system software that manages resources and offers standard services. It loads programs into memory, schedules the processor, controls files and storage, communicates with devices through drivers, enforces security permissions and presents a user interface (GUI or CLI). Applications call the OS using APIs (Application Programming Interfaces) rather than trying to drive devices directly. This layered approach lets a web browser or game run on different computers without being rewritten for each specific keyboard, screen or network card.
Applications: tools for user goals
Applications are programs that help users perform tasks – writing an essay, editing a photo, chatting with friends, designing a model or analysing data. Applications depend on the OS for memory, files, graphics, sound and networking. When you run an application, the OS loads it, gives it time on the CPU, and mediates all requests to devices.
Responsibilities at a glance
| Layer | Main responsibility | Examples of tasks | Who uses it directly? |
|---|---|---|---|
| Hardware | Provide compute, storage and I/O capability | Execute instructions, hold data in RAM, display pixels, transmit network packets | Controlled by firmware and OS |
| Firmware | Initialise and test hardware; start the OS | Power-on self test, device configuration, bootloader functions | OS and technicians (via setup screens) |
| Operating system | Manage resources; provide services and user interface | Process scheduling, memory management, file systems, drivers, security | Applications and users |
| Applications | Enable user tasks and produce outputs | Word processing, web browsing, image editing, games | End users |
From power-on to app launch: the boot sequence
What happens step by step
- Power on: electricity reaches the motherboard and devices. The CPU begins executing instructions from a fixed location in non-volatile memory where boot firmware is stored.
- Firmware initialises hardware: memory, CPU timers, storage controllers and peripherals are detected and tested. Basic settings such as clock speeds and boot order are applied.
- OS loader runs: the firmware locates the operating system kernel on a storage device and loads it into RAM. Control is handed to the OS.
- OS initialises drivers and services: the kernel sets up memory management, device drivers and core services like the file system and network stack. The login screen or desktop appears.
- User starts an application: when you open an app, the OS loads its program files and required libraries into RAM, assigns a process, and begins scheduling CPU time. The app now requests services through OS APIs.
The boot process is a handshake between firmware and the OS, moving from very low-level control to a general-purpose platform suitable for any application the user chooses.
Contrasting real-world boot scenarios
UEFI firmware performs hardware checks, then loads a boot manager from the system drive. The OS kernel initialises drivers for the graphics adapter, storage and network. A full GUI desktop appears and the user launches applications such as a browser or office suite.
A boot ROM verifies cryptographic signatures (secure boot) to prevent unauthorised software. A minimal bootloader loads the mobile OS kernel and device drivers for radios, display and touch. The homescreen is presented; apps run in sand-boxed environments with permissions controlled by the OS.
On power-up, device firmware initialises motors, sensors and memory. A compact OS (or even firmware-only menu) loads, offering a basic UI and network stack. Printing apps on a computer later talk to the printer via the computer's OS and drivers; the printer's internal firmware controls the actual page mechanism.
How applications use the OS and drivers
Service requests via APIs
Applications rely on APIs to ask the OS for services such as creating files, drawing on the screen, playing audio and sending data over a network. The OS checks whether the request is permitted, manages memory buffers and talks to the hardware through device drivers. Drivers are specialised system components that understand the firmware and electronics of a specific device model.
Why this separation matters
- Portability: the same application can run on many types of hardware if the OS provides the same APIs and drivers are available.
- Security and stability: the OS enforces permissions and isolates processes so a faulty app cannot easily crash the whole system or read other users' files.
- Maintainability: replacing a printer or graphics card requires updating the driver, not rewriting every application.
- Performance: the OS shares the CPU fairly and caches frequently used data, while drivers and firmware use device features efficiently.
When things go wrong: identifying the weak link
Troubleshooting by layer
Because the system is layered, you can often diagnose problems by deciding which layer is responsible. Use the tabs to compare common failure patterns and their likely causes.
Symptom: a new graphics card shows a low resolution or the printer only produces garbled text. Cause: the OS driver does not match the model, so the OS falls back to basic modes. Fix: install the correct driver or update the OS.
Symptom: storage device intermittently fails or the system cannot boot after a device firmware update. Cause: firmware uses new features or settings that the OS or existing drivers do not expect. Fix: update drivers/OS, or roll back the firmware to a compatible version.
Symptom: frequent crashes, missing system files, or services not starting. Cause: OS files are corrupted or configuration is invalid. Fix: repair the installation, restore from backup, or reset settings while keeping user data.
Quick decision guide
| Observation | Most likely layer | First action |
|---|---|---|
| Device not detected at all | Hardware or firmware | Check connections and firmware setup screens; try another port or power source |
| Device detected but limited features | Driver/OS | Install or update the correct driver; check OS updates |
| Apps freeze while others work | Application | Update or reinstall the app; check for conflicting extensions or add-ons |
Security and updates across the layers
Keeping each layer trustworthy
- Hardware: physical security (locks, restricted access) prevents tampering and protects data stored on devices.
- Firmware: secure boot and signed updates help ensure only trusted code runs before the OS starts.
- Operating system: user accounts, permissions, encryption, firewall and regular patches reduce vulnerabilities.
- Applications: permission requests and updates close bugs that could leak data or allow malware.
Updates must be compatible. Installing a driver for the wrong OS version or applying unsupported firmware can break the chain that lets applications run.
Deep Dive: drivers vs firmware
Drivers live within the OS and act as translators between the OS's standard calls and a device's specific commands. They can be replaced or updated without changing the device. Firmware lives on the device and governs how it behaves even before the OS is involved. Updating firmware changes the device's own behaviour. Both are required for complex peripherals: the OS calls the driver; the driver issues commands that the firmware interprets to control motors, lights, sensors or memory chips.
Summary of key terminology
- Hardware: the physical components of a computer system.
- Firmware: low-level control software stored on the device, used to initialise hardware and load the OS.
- Operating system (OS): system software that manages resources and provides a platform for applications.
- Device driver: OS component that enables the OS to communicate with a specific hardware device.
- API: a defined set of functions that applications use to request OS services.
- Boot process: the sequence from power-on to loading the OS and starting applications.
Key Takeaways
- Hardware, firmware, OS and applications are distinct layers that work together; each has clear responsibilities.
- Firmware starts first, initialises hardware and loads the operating system; the OS then provides services and a safe platform for applications.
- Applications never access devices directly; they request services from the OS via APIs, and the OS uses drivers to control hardware.
- Layering improves portability, security, stability and maintainability.
- Troubleshooting is easier when you identify which layer is responsible: hardware, firmware, OS or application.