Skip to content

Build System

eBuild — Build System & SDK Generator

18-Command CLI · 14 SDK Targets · Reproducible Builds

The EoS build system and SDK generator. An 18-command CLI that compiles, signs, packages, and flashes firmware for all 41 BSP profiles. Generates per-component SDKs, runs reproducible builds, and integrates the full EoSim simulation pipeline.

For a shorter introduction to ebuild, see the ebuild overview. This page is the engineering detail.

  • Python 3.8+
  • MIT licensed
  • Critical — Foundation Layer
  • 18CLI Commands
  • 14SDK Targets
  • 41BSP Profiles
  • 100%Reproducible Builds

How It Works

Step-by-step flow — from initialization to output.
  1. 1

    Initialize a Project

    Run ebuild init to scaffold a new EoS project. Choose a BSP profile (board + architecture + peripheral set) and eBuild generates the CMakeLists.txt, linker script, and manifest.yml.

    # Create a new EoS project for STM32F4 Discovery
    ebuild init my_sensor_node --profile stm32f4-discovery
    cd my_sensor_node
    # Generated: CMakeLists.txt, manifest.yml, src/main.c
  2. 2

    Edit manifest.yml

    The manifest.yml is the single source of truth for your firmware. It specifies the board, kernel profile (minimal/standard/full), enabled services (eAI, eDB, EIPC), and pinned component versions.

    # manifest.yml
    board: stm32f4-discovery
    profile: standard
    services:
      - eai: 0.1.0
      - edb: 0.1.0
      - eipc: 0.1.0
    features:
      - uart_console
      - ota_update
  3. 3

    Build the Firmware

    ebuild build reads the manifest, resolves all dependencies, invokes CMake + Ninja, and produces a signed .eos firmware image. The same manifest always produces the same binary (reproducible build).

    # Build for the target
    ebuild build
    # Output: build/firmware.eos (signed), build/firmware.hex, build/firmware.elf
    
    # Build with verbose output
    ebuild build --verbose
    
    # Build for a different profile
    ebuild build --profile stm32f4-minimal
  4. 4

    Simulate Before Flashing

    Run the firmware in EoSim before touching real hardware. ebuild sim launches EoSim with the compiled binary, opens the GPIO visualizer, and optionally starts a GDB server for debugging.

    # Run in EoSim with GUI
    ebuild sim --gui
    
    # Run with GDB server on port 3333
    ebuild sim --gdb
    
    # In another terminal:
    arm-none-eabi-gdb build/firmware.elf
    (gdb) target remote :3333
    (gdb) break sensor_task
  5. 5

    Flash and Monitor

    ebuild flash programs the firmware to the target board via OpenOCD, J-Link, or ST-Link. ebuild monitor opens a serial console to the device.

    # Flash via OpenOCD (auto-detects probe)
    ebuild flash
    
    # Flash via J-Link
    ebuild flash --probe jlink
    
    # Open serial monitor at 115200 baud
    ebuild monitor --baud 115200

Usage Examples

Real-world scenarios showing eBuild in action.
CI/CD PipelineA GitHub Actions workflow that builds, tests, and signs firmware for every pull request.
# .github/workflows/firmware.yml
name: Firmware CI
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install eBuild
        run: pip install embeddedos-ebuild
      - name: Build firmware
        run: ebuild build --profile stm32f4-discovery
      - name: Run tests in EoSim
        run: ebuild test --sim --timeout 60
      - name: Upload signed firmware
        uses: actions/upload-artifact@v4
        with:
          name: firmware
          path: build/firmware.eos

Features

The shape of eBuild at a glance.
  • 14 SDK Targets

    Auto-generates a build SDK for every component (EoS, EAI, ENI, EIPC, eBoot, eApps, …).

  • Profile Composition

    Combine board + product profile + feature flags; resolves the full dependency graph.

  • Reproducible Builds

    Pinned source revs, isolated toolchains, hash-stable outputs.

  • Signing & Packaging

    Built-in Ed25519 signing, .eos / .img / .hex / .uf2 packaging.

  • Bench & Fuzz

    Integrated micro-benchmark and fuzzer drivers for kernel / app modules.

  • Workspace Mode

    Multi-repo monorepos with shared toolchain caches.

  • Static Analysis

    Integrated clang-tidy, cppcheck, and MISRA-C 2012 checker.

  • Coverage Reports

    GCOV/LCOV coverage reports with HTML output.

Role in the EoS Ecosystem

Why eBuild matters — and what breaks without it. See how the pieces fit together in the EmbeddedOS ecosystem overview.

eBuild is the developer-facing entry point to the entire EoS ecosystem. Every firmware image that runs on an EoS device was built by eBuild. It is the tool that ties together the EoS kernel, eBoot signing, eAI model packaging, eDB schema migrations, and EoSim simulation into a single, reproducible workflow. Without eBuild, developers would need to manually coordinate CMake, signing tools, BSP configuration, and simulation — a fragile and error-prone process. eBuild makes the entire EoS stack accessible to a developer with a single CLI.

Depends On

  • EoS Kernel — compiles and links EoS kernel source for the target BSP
  • eBoot — signs the firmware image with the Ed25519 key that eBoot verifies
  • EoSim — launches the simulator for pre-flash testing
  • CMake + Ninja — underlying build system invoked by eBuild

Enables / Powers

  • All EoS developers — every firmware project uses eBuild
  • CI/CD pipelines — reproducible builds enable automated testing and deployment
  • EoStudio — the IDE's Build button invokes eBuild under the hood
  • OTA update system — eBuild produces the signed .eos images that eBoot verifies

Open source on GitHub

MIT licensed and developed in the open. Issues, discussions, and pull requests welcome.

⌥ embeddedos-org/ebuild
Build System & SDK Generator
  • Python 3.8+
  • MIT
Open the embeddedos-org/ebuild repository on GitHub ↗

Every EmbeddedOS repository, with install commands, is listed on the downloads page.

In the EoS stack

eBuild is highlighted in the layer below.

  1. App layer
  2. UI / browser layer
  3. Data layer
  4. AI runtime
  5. Neural interface
  6. IPC fabric
  7. EoS kernel + HAL
  8. eos-platform profile
  9. eBootloader
  10. Build / IDE / Sim

Technical Specifications

Build SystemCMake 3.25+ with Ninja generator (parallel builds)
Supported CompilersGCC 13+, Clang/LLVM 17+, ARM Compiler 6, IAR EWARM, RISC-V GCC, Xtensa GCC
BSP Profiles41 pre-configured BSP profiles across 6 categories
SDK GenerationAutomatic SDK generation with headers, libraries, and CMake package config
Static AnalysisIntegrated clang-tidy, cppcheck, and MISRA-C 2012 checker
CoverageGCOV/LCOV coverage reports with HTML output
LicenseMIT

Ask your AI about EmbeddedOS

See where open-source embedded software and hardware fit your industry, in the assistant you already use.