Writing firmware takes more than a code editor. You need a cross-compiler that produces code for your chip, a way to put that code into flash, a way to debug it while it runs on real hardware, and ideally a way to test parts of it without the hardware at all. An IDE for embedded systems bundles some or all of these into one application. Many professional setups assemble them from separate tools instead.
This guide covers the main categories of software used for embedded systems, gives common examples of each, and finishes with suggestions for different situations.
What software is used for embedded systems?
A typical microcontroller toolchain looks like this:
| Stage | What it does | Common examples |
|---|---|---|
| Editor / IDE | Write and navigate code | STM32CubeIDE, MPLAB X, Keil µVision, VS Code |
| Configuration tool | Set up clocks, pins, peripherals; generate init code | STM32CubeMX, MPLAB Code Configurator, MCUXpresso Config Tools |
| Compiler & linker | Turn C/C++ into machine code for the target | Arm GNU Toolchain (arm-none-eabi-gcc), LLVM/Clang, IAR, Arm Compiler, XC8/XC16/XC32 |
| Build system | Decide what to rebuild and how | Make, CMake + Ninja, west (Zephyr), IDE-managed builds |
| Flash tool | Write the binary to the chip | STM32CubeProgrammer, esptool, avrdude, J-Flash, OpenOCD |
| Debug server & debugger | Halt, step, inspect memory through a probe | OpenOCD, pyOCD, J-Link GDB Server, GDB |
| Simulator / emulator | Run firmware or circuits without hardware | QEMU, Renode, Wokwi, Proteus, LTspice |
| Test & analysis | Unit tests, static analysis, CI | Unity, CppUTest, GoogleTest, cppcheck, clang-tidy |
An IDE may hide most of this behind a “Build” and a “Debug” button, but it’s worth knowing what each piece does. When something breaks, it’s usually one specific piece.
IDEs for embedded systems
Vendor IDEs
Most chip vendors offer a free IDE tuned for their own parts. These are often the fastest way to get a new board running, because they come with example projects, device headers, peripheral configuration tools and preconfigured debugging.
- STM32CubeIDE (STMicroelectronics): Eclipse-based, bundles GCC, GDB and the STM32CubeMX configurator. ST also offers extensions for VS Code.
- MPLAB X IDE (Microchip): for PIC, dsPIC, AVR and SAM devices, used with Microchip’s XC compilers. The free compiler editions don’t include every optimization level, and the higher levels need a paid license.
- MCUXpresso IDE (NXP): Eclipse-based, for NXP’s Arm microcontrollers. NXP also offers a VS Code extension.
- Code Composer Studio (Texas Instruments): for MSP430, C2000, Sitara and other TI parts.
- e² studio (Renesas), Simplicity Studio (Silicon Labs) and Microchip Studio (the former Atmel Studio, Windows only) cover their vendors’ parts.
- ESP-IDF tools (Espressif): the ESP-IDF framework with a VS Code extension or the Eclipse-based Espressif-IDE.
The downside of vendor IDEs is lock-in. Switching chip vendors usually means switching IDEs, and project files rarely transfer.
Commercial multi-vendor IDEs
- Keil MDK (Arm): the µVision IDE and Arm Compiler, widely used for Cortex-M. Recent versions also offer VS Code–based tooling, and Arm has offered a free community edition for non-commercial use.
- IAR Embedded Workbench: a commercial IDE and compiler for many architectures. It’s known for code size and optimization, and certified editions are available for functional-safety projects.
- SEGGER Embedded Studio: a cross-platform IDE for Arm and RISC-V that integrates well with J-Link probes. It’s free for non-commercial use.
Commercial toolchains cost money, but they’re common in automotive, medical and industrial work. In those fields, a compiler with safety certification documents, vendor support and long-term version stability is worth paying for.
Editor-based setups: VS Code, PlatformIO and friends
Many developers prefer a general-purpose editor with extensions:
- VS Code + PlatformIO: PlatformIO manages toolchains, frameworks (Arduino, ESP-IDF, Zephyr, STM32Cube, and others) and libraries for a very large number of boards. It’s popular with hobbyists and also used professionally.
- VS Code + CMake + Cortex-Debug: a vendor-neutral setup for Arm projects. You install the Arm GNU Toolchain and a debug server (OpenOCD, pyOCD or J-Link), and the Cortex-Debug extension adds a register view, peripheral views from SVD files and RTOS awareness.
- CLion (JetBrains): a C/C++ IDE with embedded features such as OpenOCD integration and STM32CubeMX project import.
- Arduino IDE 2.x: the simplest starting point for Arduino-compatible boards, now with a built-in debugger for supported boards.
- Eclipse Embedded CDT: the open-source Eclipse plugins that many vendor IDEs are built on.
Is VS Code an IDE or an editor?
Strictly speaking, Visual Studio Code is a code editor. Out of the box it edits text, searches files and integrates with Git. It becomes IDE-like once you add extensions for a language, a build system and a debugger. For embedded work, that means adding C/C++ support, CMake or PlatformIO, and a debug extension such as Cortex-Debug. The result can be as capable as a vendor IDE, but you’re responsible for configuring it.
Compilers and toolchains
The compiler is the piece that matters most for correctness and code size:
- Arm GNU Toolchain (
arm-none-eabi-gcc): free, ubiquitous for Cortex-M and Cortex-R, and bundled with many IDEs. - LLVM/Clang: increasingly used for Arm and RISC-V. It offers good diagnostics and powers tooling such as clang-tidy. Arm’s own Arm Compiler 6 is based on LLVM.
- avr-gcc: the compiler behind Arduino for AVR boards.
- RISC-V GCC/LLVM and Xtensa toolchains: used for ESP32 and other RISC-V parts, usually installed by the vendor framework.
- IAR, Microchip XC, TI compilers: vendor or commercial compilers for specific architectures.
A toolchain also includes the linker (with a linker script describing your chip’s flash and RAM layout), the C library (newlib or newlib-nano with GCC, picolibc in some setups), and utilities such as objcopy (convert ELF to HEX or BIN), size and objdump. If you ever need to read what the compiler produced, see assembly language programming for embedded systems.
Build systems
IDE-managed builds are convenient but awkward to run in continuous integration. Many teams move to CMake (often with Ninja) or Make so the same build runs on a developer laptop, in CI and inside an IDE. Zephyr uses CMake driven by its west tool. PlatformIO has its own build system.
Flashing and debugging tools
To load and debug code on a real chip, you need a debug probe and software that talks to it:
- Probes: ST-LINK (on most ST Nucleo/Discovery boards), SEGGER J-Link, CMSIS-DAP probes (including DAPLink and the Raspberry Pi Debug Probe), Microchip PICkit and MPLAB ICD/Snap, Atmel-ICE and the Black Magic Probe.
- Debug servers: OpenOCD, pyOCD, J-Link GDB Server and ST’s GDB server. These sit between the probe and GDB.
- Flashers: STM32CubeProgrammer, esptool (ESP32), avrdude (AVR), nRF tools (Nordic), J-Flash and OpenOCD’s own
programcommand.
The details of connecting a probe, starting a GDB session and debugging faults are in debugging microcontrollers with JTAG, SWD and GDB.
Simulators and emulators
“Simulation software for embedded systems” covers three different kinds of tools. Pick based on what you’re trying to check.
Circuit-level simulators
These simulate the electronics: voltages, currents, filters and power stages. LTspice, ngspice (built into KiCad), PSpice, Multisim, TINA-TI and Qucs-S are common, and the Falstad simulator runs in a browser for quick experiments. They’re for checking an op-amp stage or a regulator, not for running firmware.
Microcontroller and circuit co-simulation
These run your compiled firmware on a model of the microcontroller, connected to a simulated circuit:
- Proteus VSM (Labcenter): commercial and Windows-only, with models for many PIC, AVR, 8051 and some Arm parts plus a large peripheral library. See what Proteus software is for more.
- Wokwi: browser-based (also available inside VS Code) and popular for Arduino, ESP32, Raspberry Pi Pico and some STM32 boards. It’s handy for sharing reproducible examples.
- SimulIDE: free and open source, with AVR, PIC and Arduino support.
- Tinkercad Circuits (Autodesk): free in the browser and aimed at beginners using an Arduino Uno.
Firmware and system emulators
These emulate a processor and its peripherals so firmware can run without any physical board. They’re useful for automated testing:
- QEMU: emulates many CPUs. It’s used widely for embedded Linux on Arm and RISC-V, and it also models some Cortex-M boards.
- Renode (Antmicro, open source): simulates complete boards and even multi-node systems, such as several devices talking over a network. It’s often used in CI for Zephyr and other RTOS projects.
- Vendor simulators: Keil µVision and MPLAB X include instruction-set simulators that are useful for checking algorithms and timing on supported parts.
Emulators rarely model every peripheral exactly, so they don’t replace testing on real hardware. They do let you catch many bugs earlier and more cheaply. For a side-by-side comparison of simulation tools, see which software is best for simulation.
Testing and code-quality tools
- Unit test frameworks: Unity (with CMock and Ceedling), CppUTest and GoogleTest. Run them on the host PC for logic that doesn’t touch registers.
- Static analysis: cppcheck, clang-tidy and the Clang static analyzer (free), plus commercial tools that check MISRA C rules.
- Version control and CI: Git with a CI service that builds every commit, runs host tests and, on more mature teams, flashes a hardware test rig.
Bench tools that count as “software” too
A lot of embedded debugging happens outside the IDE:
- Serial terminals: PuTTY, Tera Term, minicom, picocom and the serial monitors in Arduino and PlatformIO.
- Logic analyzer software: Saleae Logic, or sigrok/PulseView with low-cost analyzers. These are invaluable for decoding UART, SPI and I2C.
- Oscilloscope software and protocol analyzers for timing and signal-integrity problems.
How to choose a toolset
| Situation | A sensible starting point |
|---|---|
| Learning on an Arduino or similar board | Arduino IDE 2, or VS Code + PlatformIO; Wokwi or Tinkercad for simulation |
| First project on a specific vendor’s MCU | That vendor’s free IDE and configuration tool, with the board’s built-in probe |
| Team project, multiple developers, CI | CMake + GCC or Clang, VS Code (or CLion) for editing, OpenOCD/pyOCD/J-Link for debugging, Renode or host tests in CI |
| ESP32 projects | ESP-IDF with its VS Code extension, or PlatformIO |
| Zephyr RTOS projects | west + CMake, VS Code, and the board’s probe; Renode or QEMU for CI |
| Safety-critical or regulated product | A commercial compiler with certification support (IAR, Arm/Keil, or others), plus static analysis and a documented toolchain version |
Whatever you pick, pin your toolchain version in the project, for example in a README, a container image or a PlatformIO configuration. Compiler updates can change code size and timing, and you’ll want to rebuild old firmware exactly as it shipped.
Is embedded development done in C or C++?
Both. C is still the most common language for microcontroller firmware, and nearly every tool above is built around it. C++ is widely used too, especially on 32-bit parts and in larger codebases, usually with restrictions such as no exceptions, no RTTI and limited heap use. All the major embedded compilers support both. For the C side, see embedded C programming for microcontrollers. For the bigger picture of how these tools fit into a project, see the embedded firmware development overview.