MemScope

Local-first firmware footprint intelligence for embedded teams.

MemScope analyzes your ELF, MAP, and linker artifacts to give you a clear picture of where your firmware’s flash and RAM are going — and gates your CI build when a regression sneaks in. Built for embedded engineers who want SonarQube-style enforcement without sending build artifacts to a cloud.

pip install memscope-fw

Screenshots

A single memscope analyze run on a representative STM32H7-class firmware (Cortex-M7 + FreeRTOS + lwIP + USB CDC, 6 memory regions, ~100 contributing input sections, ~150 symbols) produces this self-contained interactive HTML report — open it in any browser, no internet required, no JS framework to install. Headline cards surface the tightest region (here, RAM_D1 at 99.8% capacity — the kind of near-overflow that’s invisible until you flash silicon), total Flash / RAM consumption, and the alignment-waste budget you could reclaim:

MemScope analyze HTML report — headline view

Below the fold: Memory Layout Explorer (interactive section bars per region), Visual Insights (top contributors / functions / globals), Region Utilization (per-region capacity, alignment overhead, fragmentation), Section Explorer (drill-down with byte-level lookup), Component Ownership, Issues and Recommendations, Comparison vs baseline, and Diagnostics and Assumptions so reviewers can see exactly what was inferred vs measured. See the full-page screenshot →

memscope diff compares two builds and highlights the regressions that matter — headline byte deltas, per-region growth chart, top regressions and reductions tables, plus a deterministic JSON contract your CI can gate on:

MemScope diff report — build-to-build comparison

The fixtures used to generate these screenshots are in docs/demo/ — reproducible with python -m memscope analyze --map docs/demo/demo.map --linker docs/demo/demo.ld --html report.html.

License at a glance. MemScope is free — the memscope-fw distribution on PyPI is gratis for any use, including commercial use by companies of any size. No license key, no watermark, no time limit, no seat count, no procurement required. Run analyze, validate, diff, and --strict CI gating today, indefinitely. Optional commercial Bundles (PR/Slack notifications, SoC-family analysis extras, ISO 26262 / IEC 62304 / DO-178C compliance evidence packages, custom bespoke extensions) extend the tool for paying customers — those are delivered as Customer-Bound Wheels separately from the free PyPI core. Bundle licences are not yet for sale — the commercial entity is still being registered. Closed-source proprietary EULA — not OSI / FSF open source. Full text: see the License section on this PyPI page (or the LICENSE file shipped inside the installed wheel).

What it does

Why teams pick MemScope over rolling their own scripts

Capability Hand-rolled scripts MemScope
Parse ELF + MAP + linker config consistently across toolchains Different per project One CLI, GNU + IAR + Keil + Clang/LLD all supported (dedicated parsers per toolchain, normalized to a single internal model)
Stable JSON schema your CI can rely on Brittle Versioned + validate subcommand
Drop-in CMake integration DIY cmake/FirmwareFootprint.cmake
Interactive HTML report for design reviews None Self-contained, no internet needed to open
CI gating with friendly error messages grep + bash --strict exit codes
Multi-core / multi-region partition awareness Usually missing First-class

Install

pip install memscope-fw

Requires Python ≥ 3.11. Wheels are published per-platform for Windows (x86_64) + Linux (manylinux2014, x86_64) + macOS (Apple Silicon / arm64), each on Python 3.11 / 3.12 / 3.13 / 3.14.

5-minute quick start

# 1. Analyze a single build — produces report.html you can open in any browser
memscope analyze \
  --elf path/to/firmware.elf \
  --map path/to/firmware.map \
  --linker path/to/linker.ld \
  --json report.json \
  --html report.html

# 2. Compare two builds (e.g. before/after a refactor)
memscope diff \
  --current-json report.json \
  --baseline-json baseline.json \
  --html diff.html

# 3. Gate CI on a regression budget (exits non-zero if violated)
memscope analyze --strict \
  --elf firmware.elf --map firmware.map --linker linker.ld \
  --baseline-json baseline.json

The HTML report is fully self-contained — D3, ECharts, and all interactive visualizations are bundled inline, so it works in air-gapped CI environments and can be archived as a single file.

What’s free vs what’s paid

Free for everyone, forever (the memscope-fw distribution on PyPI):

Paid commercial Bundles (delivered as Customer-Bound Wheels, separately from PyPI):

Bundle availability. Bundle licences are not yet on sale. The commercial entity that will issue them is being registered; until then, only the free core is operational and there is nothing to purchase. To be notified when Bundles become available, email dumitrescu.adrian121@gmail.com.

Documentation

Public documentation (CLI reference, CMake integration, CI tutorial, report interpretation guide, config schema, troubleshooting, privacy & GDPR posture, enterprise procurement Q&A) ships in docs/public/ and is also published at https://adrian-dumitrescu.github.io/memscope-docs/.

A condensed walkthrough is available via:

memscope --help                         # top-level commands
memscope analyze --help                 # per-command reference

Every subcommand has built-in --help documentation.

Privacy posture

Support

For Bundle inquiries, custom engineering engagements, bug reports in the free core, and integration help:

When reporting an issue, please include the output of memscope diagnostics export — it bundles version, environment, and parser diagnostics into a single ZIP that’s safe to attach.

License

Closed-source proprietary EULA. The binding text — with a Plain-English summary at the top — is in the LICENSE file shipped inside the wheel, and surfaced in the License section on the PyPI project page.

In short: