‘Software’ is a general term often used to describe anything at all running on a computer.
We use the term software to describe operating systems, desktop applications, video games, mobile apps, web apps, smart devices, and basically any code which enables a computer or device to function.
As we live in a world that has embraced technology, we can say software powers everything that makes possible the things we can do through computers.
But what about firmware? How does the term firmware vs software compare and is it important to know the difference?
If you’re familiar with the embedded systems field you’ll likely have come across the term firmware. Understanding differences between firmware vs software is essential for embedded engineers who primarily work with firmware.
Understanding what makes firmware vs software different is mainly down to the level at which the code runs. Firmware is used to describe code running close to the hardware layer of a machine while software tends to run close to the user application layer.
But what does all this mean and how does it distinguish firmware vs software? Let’s take a closer look.
Firmware Vs Software
The obvious and the hidden computer programs
Software can refer to any sort of running computer program. This can be a web browser, text editor, game app or any program running that’s made for a user like me and you to interact with.
Such programs also referred to as applications, are likely what most people think of when they hear ‘software’ because these programs are what the average computer user interacts with. Let’s call these the ‘obvious’ computer programs.
However, apart from applications developed for the average user, computers need all other sorts of programs to function. These are the ‘hidden’ programs the average computer user does not interact with or may not even know exists.
One way to describe these ‘hidden’ programs is as firmware.
Breaking down the term ‘Firmware’
Firmware typically refers to code running directly on or close to the hardware layer of a device. Code running at the hardware layer can also be described as running at a ‘low-level’. Let’s analyse this down further by defining exactly what hardware means.
In the context of computers, hardware references the components that physically exist on a device. It can be used to describe a mouse, keyboard, monitor, speakers, flash drive, USB ports, charging cables and so on.
Hardware can also be used to describe the physical parts hidden from view that exist on the circuit board of a computer such as the motherboard, graphics card, processors, integrated circuits, resistors, capacitors and even down to the microscopic transistors.
If you can see it, then you can call it hardware (although you’ll probably need a microscope to see those super tiny transistors!) .
Now, when we say code running at a ‘hardware level’ or ‘low-level’, we are referring to code that runs directly on any programmable hardware components that exist on a circuit board.
Not all hardware that makes up a computer can run code. For example, a resistor, capacitor or any other form of dumb hardware are not programmable and therefore can’t run code.
However, every computer will have a CPU (central processing unit) also known as a processor which acts as the brain of the computer. Processors are a typical example of a programmable hardware component that needs code to function.
The code that enables a processor to function is referred to as firmware. We use firmware in this case to distinguish code running that is essential to enable the most basic and necessary functions of a device.
Without Firmware there can be no Software
A computer can function without software such as a web browser, email client, video editors, game apps and so on. But that same computer can’t function without a BIOS (the first program to run on boot to initialise a PC) or a Bootloader (which loads the operating system).
In the case of a standard PC, core programs like these must run first before the operating system or any other application programs can run. Hence why we say firmware runs at a ‘low-level’, as it runs before all other software applications which run at a ‘higher-level’.
However, in reality there’s no exact line that can be drawn to define what programs should be called software/higher-level or firmware/low-level as it can be relative.
The below image represents a rough illustration of where some typical computer programs will fall in the layer of high-level vs low-level.
Note: In reality, the line between lower-level and higher-level programs are blurred. Depending on the context, some programs can be seen as running at a low-level, high-level or somewhere in the middle (see Middleware).
I’ll also briefly mention another form of firmware called Bare Metal which describes computer programs that can run without the need of an operating system. Bare Metal programs are directly flashed on the processor of the hardware via a physical programming header.
A Bootloader is a typical example of a Bare Metal program. Since the job of a Bootloader is to load the operating system, it can therefore run without needing an operating system. (You only need to be concerned about Bare Metal if you’re involved with embedded systems and I won’t go into further detail in this post!)
Whether you’re involved in writing firmware or not, it’s important to acknowledge how firmware differs from software. Firmware plays a more fundamental role in powering technology and is what ultimately allows software as we know it to run.
Hopefully, you now have a better understanding of how firmware vs software is different.
The following are some additional points that can be used to further understand key differences between firmware vs software and exactly what makes firmware distinguishable from the generic term of software.
Further points to distinguish firmware vs software
Using the term ‘Firmware’ can be used for clarity
All firmware is software but not all software is firmware.
Think of ‘software’ as an umbrella term that categorises anything that runs code. As firmware involves writing code, this makes firmware a form of software.
However, firmware describes code running on the lower-level layer of a device, while software is used to describe code running at a higher-level where the user is able to interact with it.
For this reason, we don’t call programs like a web browser running on your PC firmware. A web browser runs as a user application and is placed at a higher-level on the stack of programs running on a PC. In this case, we should refer to a web browser as a software application.
In contrast, a firmware program like a Bootloader runs directly on the processor and is needed before another program like an operating system or a web browser can run.
However, there’s technically nothing wrong with calling a Bootloader a software program because firmware is also a form of software.
It’s typical for firmware to be used interchangeably with software. The term firmware just allows a distinction that the program runs close to the hardware layer. While software can be used to describe any program at all.
Firmware engineers have different sets of challenges
Another reason why we should acknowledge the differences between firmware vs software is that firmware engineers face different challenges as opposed to the challenges of writing software applications.
Because firmware runs at a low-level, it tends to be very specific to the hardware it’s running on. A piece of firmware running on an Intel processor for example, is unlikely to run on an AMD processor without some porting and modifications.
Hardware like processors varies in their architecture so firmware is written to support the specific architecture of that device. This means firmware must always be written according to what the hardware can support.
This is also why some programming languages are more optimised for running firmware as opposed to application software.
A computer as a whole also varies in spec with differences in storage space, RAM, graphics support or power consumption requirements. Again, firmware must be written to ensure it will function giving the available capacity of the device.
Because of this, firmware engineers need to have knowledge of working with hardware components and be able to consider the limitations on the device they are writing code for.
This is entirely different to software application engineers, who are nowhere as concerned with the architecture or underlying limitations of the computer hardware.
Engineers who are concerned with the underlying hardware of a device they are writing code for we call embedded engineers or firmware engineers.
While embedded engineers like other software engineers develop computer programs, the challenges of working with code running close to the hardware layer categorises embedded systems under a separate field of engineering.
For more information on embedded systems see the posts we’ve tagged so far on this topic.
While ‘software’ has become an all-encompassing term used to describe code running on a device, we must not forget ‘firmware’ which is even more fundamental as it runs before software applications.
The main point to remember when comparing firmware vs software is: Firmware runs close to the hardware of a device and tends to be hidden from the average user. While software applications run at a level intended for the users to interact with.
While software describes all computer programs, firmware sets apart code that is optimised for a particular hardware and is responsible for controlling a device to enable its most basic functions.
Has this helped you understand the key differences between firmware vs software? If you have any further questions on this topic ask away in the comments!
See other articles you may be interested in below: