Tak tento projekt mě opravdu překvapil. Jedná se o C/C++ IDE odvozené od Code::Block-u a zaměřené speciálně na embedded programování. Podpora ARMů je přímo ukázková. No a protože to je určrno pro embedded vývoj, tak funguje i laděná, podpora assemberu a řada dalších záležitostí nefunkčních/neimplementovaných v Code::Block-u. Jednoznačný palec nahoru.

Upozorňuji - nejedná se o JAVU, ale o plnokrevné C++. Součástí balíku je i arm-none-eabi toolchain. V mém případě nezajímavé, ale pro někoho jistě podstatná je i přenositelnost celého balíku prostým překopírováním adresáře bez nutnosti nové instalace.


  • Multiple device targets (ARM, PIC, AVR,  ....).
  • Included optional: GNU ARM Embedded "bare-metal" compiler with different optimized libraries.
  • Powerful debugger fully optimized for embedded development.
  • Written in C++. No interpreted languages (Jave or .NET) or proprietary libs needed.
  • Extensible through plugins


  • Syntax highlighting, customizable and extensible
  • Syntax highlighting for assembler sources for all the supported targets (ARM,AVR,PIC,...)
  • Code folding for C/ C++ and XML files.
  • Tabbed interface (VS2010 style)
  • Code completion
  • Class/symbol Browser (also for the compiler predefined symbols)
  • Smart indent
  • Spelling checker with US dictionary pre-installed
  • CScope integration with binaries pre-installed  
  • One-key swap between .h and .c/.cpp files
  • Open files list for quick switching between files (optional)
  • External customizable "Tools"
  • To-do list management with different users

Build engine:

  • Multiple compiler/target support:
    • EmBlocks "bare-metal" GNU ARM compiler (with memory report in EmBlocks)
    • Keil/ARM realview
    • ARM GCC (generic)
    • PIC32 Microchip
    • PIC24,PIC30,dsPIC Microchip
    • PIC18 Microchip
    • AVR GCC ATmel (MHV windows toolchain detection)
    • ...and more to come
  • Auto detection of installed toolchains
  • Build options for Compiler, Linker and Assembler
  • Inherited options from upper levels are visible at lower levels.
  • Support for parallel builds (utilizing your CPU's extra cores)
  • Multi-target projects
  • Workspaces to combine multiple projects
  • Inter-project dependencies inside workspace
  • New Project Wizard for NXP-ARM, ST-ARM, EnergyMicro and Microchip targets (others will follow)
  • Project loader for uVision ARM projects
  • Project loader for Mplab 8 projects (PIC32,dsPIC, PIC30, PIC24 and PIC18)
  • Project loader for Atmel Studio project/workspace (AVR and ARM)
  • Project importer MplabX projects

ARM GNU Embedded "bare-metal" Compiler:

  • Based on GNU 4.7-branch
  • Special libraries for the cortex family (with and without fpu/softfp etc)
  • Newlib builds optimized for Speed & Size (and default)
  • Newlib Nano-branch included
  • Unwind handling is excluded for minimum size builds
  • All libraries are selectable from linker panel EmBlocks
  • CMSIS library preinstalled and available without further settings
  • Fully documented and accessible at EmBlocks help menu (inclusive ARM quick references) 


  • Special tailored GDB binaries optimized for embedded debugging
    (ARM, AVR, MIPS & MSP430 are selectable in the install package)
  • Step-in/out, Step-over, Step-instruction, Run to cursor & Set PC at cursor
  • Disassembler view mode, mixed or plain
  • Memory view hex,char or dec (signed/unsigned) and 8,16 or 32 bits selectable
  • Memory view Scrollable (uVision style) and with "Address modify" function
  • System view with CMSIS-SVD (XML) description support.
    Display all the peripherals registers of the device and modify the values if necessary. 
  • Live data and variables (on mouse-over) on GDB server support
  • Semihosting text in debugger-target view through GDB
  • Navigation between register, disassembly and memory views
    e.g. show memory pointed by register/system or disassembly immediate values etc.
  • GUI debug interface settings
  • Easy integration of additional GDB-servers by squirrel scripting
  • Automatic GDB server launch and termination
        *ST-link GDB server available in package which supports flash/ram execution.
  • Scripted register window parser for register-flags
  • Changeable register values in register window
  • Cursor aware variable inspect (on cursor or on selection) with live updates
  • Custom variable types possible via scripting
  • Assembler syntax highlight with PC-aware line colouring
  • Breakpoints in source windows are visible also in assembler pane
  • "Break on valid source line if possible" option
  • etc. etc

Additional Plug-ins:

  • Auto versioning
  • File diff viewer.
  • Hex editor (even for large files).
  • Doxy documentation generation front-end.
  • Code snippets.
  • Code statistics.
  • and many more...


It all started with the use of Code::Blocks as an IDE for embedded software development as a replacement for other Java written tools which were too slow or unstable.

Impressed by the Scintilla editor capabilities there was a growing wish for more embedded related features instead of the Desktop oriented approach.

Instead of all those options like e.g. a resource compiler or dynamic library builds, we need options for assembler tools and static library buildings. The linker for embedded tools often need more specific information like device type, heap/stack space or linker script settings. And if those features are there then it is also tempting to make it more universal instead of the GCC flavor of Code::Blocks. By supporting all kind of compiler tools the IDE will become a multi target solution.

So the rewriting of Code::Blocks started and the changes needed were so significant that they could only be realized in a forked source base. Once rewriting a lot of code, in all kind of places, Em::Blocks now really supports multiple targets within one project with assembler highlighting for the target in scope. There are dedicated options for assembler and linker tools and the project manager is fully optimized to embedded software design.

By forking Code::Blocks there is one big advantage, both IDE's can by used side-by-side without conflicting errors.


One of the big advantages of Em::Blocks is that it supports multiple targets within one project. For example, you can have a build configuration targeting the ARM and one targeting the PIC32.

You can use e.g. different targets for debugging and release if the debugging environment is more stable, faster,flexible ...

With the use of virtual targets you can even build all these targets within one click.

Every compiler toolchain has options on global level and you can set options for the default target of a project. If the build target is different from the project default target, the project settings are disabled for that configuration automatically, and only the global and target settings are taken into account for that particular build.

On lower levels, Project/Target, you can see which settings are valid by inheriting options from upper levels. It's even possible to see where those settings are inherited from by the color.