The short answer
An embedded system is the complete, dedicated computing system inside a product: the processor, memory, sensors, actuators, power circuitry, communication interfaces and the code that runs on them. Embedded software is the code part only: the instructions that tell that hardware what to do.
So embedded software is a component of an embedded system, not an alternative to it. A washing machine controller is an embedded system. The program on its microcontroller that reads the door switch, fills the drum and runs the spin cycle is embedded software.
What an embedded system is
An embedded system is a computer built to do a specific job inside a larger device, rather than to be a general-purpose machine like a laptop. Typical examples include a car’s engine control unit, a fitness tracker, a microwave oven controller, a router, an infusion pump or a factory sensor node.
Most embedded systems contain some mix of:
- A processor, usually a microcontroller (MCU) and sometimes a more powerful microprocessor or system-on-chip
- Memory for program code and working data
- Inputs such as sensors, buttons and analog signals
- Outputs such as motors, relays, LEDs and displays
- Communication interfaces such as UART, SPI, I2C, CAN, USB or wireless radios
- Power circuitry, often battery-based and power-constrained
- Software that ties it all together
For a fuller tour of these parts and how they connect, see our embedded system architecture guide.
What embedded software is
Embedded software is the code written for that specific hardware. Unlike most desktop or web software, it usually runs with tight limits on memory, processing power and energy. It often has to respond within a fixed time, and the person using the product may not know it’s there.
The layers of embedded software
Small projects may be a single program. Larger products usually split the code into layers:
- Boot code and bootloader: starts the chip, sets up clocks and memory, and in some products allows the firmware to be updated.
- Hardware abstraction layer (HAL) and device drivers: code that reads and writes peripheral registers to control GPIO, timers, ADCs, UART, SPI, I2C and so on.
- Board support package (BSP): configuration specific to one circuit board, such as which pin drives which LED.
- Operating system (optional): many systems run “bare-metal” with no OS. Others use a real-time operating system (RTOS) such as FreeRTOS or Zephyr, or embedded Linux on larger processors.
- Middleware: file systems, network stacks, USB stacks, graphics libraries and cryptography.
- Application code: the logic that makes the product what it is, such as a thermostat’s control loop or a drone’s flight controller.
Firmware vs embedded software
You’ll see “firmware” and “embedded software” used almost interchangeably. When people draw a line, firmware usually means the low-level code stored in non-volatile memory and closely tied to the hardware: boot code, drivers and the basic control program. Embedded software is the broader term, and on larger devices it can also include middleware, user interfaces and applications. On a small microcontroller, the distinction mostly disappears: the single program in flash is both.
Key differences at a glance
| Embedded system | Embedded software | |
|---|---|---|
| What it is | The complete dedicated computer: hardware plus code | The code that runs on that hardware |
| Physical? | Yes: circuit boards, chips, sensors, enclosure | No: instructions stored in memory |
| Main parts | MCU or processor, memory, I/O, power, interfaces, software | Boot code, drivers, optional RTOS, middleware, application |
| Changed by | Board revisions, component changes, new manufacturing runs | Recompiling and reflashing, or over-the-air updates |
| Cost of a change | Usually high, especially after production starts | Usually lower, though testing and certification still cost time |
| Typical failures | Component faults, noise, heat, power problems | Bugs, timing errors, memory overflows, lock-ups |
| Engineering focus | System requirements, electronics, mechanics, integration | Programming, real-time behaviour, memory and power optimization |
A worked example: a smart thermostat
Splitting one familiar product into its parts makes the distinction concrete.
The embedded system includes:
- A microcontroller with built-in Wi-Fi
- A temperature and humidity sensor on an I2C bus
- A small display and a few buttons or a touch panel
- Relay or triac outputs that switch the heating and cooling equipment
- A power supply, a backup battery or supercapacitor, and the enclosure
The embedded software includes:
- Startup code that configures clocks, pins and peripherals
- A driver that reads the sensor over I2C
- A display driver and user-interface code
- A control algorithm that decides when to switch heating on or off
- A Wi-Fi and network stack that talks to a phone app or cloud service
- A firmware update mechanism
- A watchdog timer routine that resets the device if the code hangs
Replace the sensor with a different model and you’ve changed the embedded system, and probably need a new driver too. Change the scheduling feature in the app logic and you’ve changed only the embedded software.
How the two depend on each other
Embedded software is written for specific hardware. It assumes particular register addresses, pin assignments, clock speeds and memory sizes. The same program usually won’t run on a different board without changes, which is one big difference from desktop software that runs on many PCs.
The dependence runs the other way too: the hardware does nothing useful without the code. A microcontroller fresh from the factory, with no firmware loaded, just sits there.
That’s why embedded projects are often developed as a pair. The hardware team picks parts and designs the board while the software team writes and tests code, often starting on a development board before the custom hardware exists.
Deciding what goes in hardware and what goes in software
Some functions can be done either way, and choosing is a central design decision, sometimes called hardware/software partitioning:
- Debouncing a button can be done with a resistor-capacitor filter or a few lines of code.
- Generating a PWM signal can be done in software by toggling a pin, but a hardware timer does it more precisely and frees the CPU.
- Filtering a signal can be done with analog components before the ADC, or digitally in software after sampling.
- Encryption can run in software or on a hardware crypto accelerator, if the chip has one.
Hardware solutions tend to be faster and use less CPU time, but they add parts cost and are hard to change later. Software solutions are flexible and cheap to update, but they use processor time, memory and energy.
Is embedded software written in C or C++?
Both, and C is still the most common. C gives direct control over memory and hardware registers, compilers exist for almost every microcontroller, and most vendor libraries and example code are written in C.
C++ is widely used too, especially in larger projects and in the Arduino ecosystem, whose “sketches” are C++. Embedded C++ developers often avoid or limit features that can be costly on small systems, such as exceptions and heavy dynamic memory allocation. Rust is gaining interest for its memory-safety guarantees. MicroPython and CircuitPython are popular for prototyping and learning on capable boards. Assembly language is still used occasionally for startup code or very time-critical routines.
Embedded systems engineer vs embedded software engineer
Job titles blur in practice, but there’s a general pattern:
- An embedded software engineer (or firmware engineer) mainly writes, tests and debugs the code: drivers, RTOS tasks, communication stacks and application logic. They need a working knowledge of hardware, such as reading datasheets and schematics and using an oscilloscope or logic analyzer, but their output is software.
- An embedded systems engineer often looks at the whole product: requirements, choosing the processor and components, hardware/software partitioning, integration and testing. Depending on the company, that may include circuit design, software or both.
Neither is strictly “better”. It depends on whether you’re more drawn to code or to the wider system. Many people start in one and move toward the other. Pay and demand vary a lot by region, industry and experience, so local job listings are a better guide than general claims.