Interrupt: a Jekyll site and a community for embedded software makers

What Interrupt actually is, and who runs it

Interrupt is a community for embedded software makers and professionals alike, and the project page lists two places to talk: a Slack channel and a Discourse forum at community.memfault.com. The repository behind it is the site itself, and the last push was on 2026-10-08. The primary language listed for the project is C, which is a clue about the subject matter rather than the code, because the top level of the repository is a Jekyll site with directories for posts, drafts, data, layouts, includes, plugins and sass, plus a feed, a tags page and an about page. The project is sponsored and edited by Memfault, which is also why the domain is interrupt.memfault.com and why the site is built around a company that sells firmware observability and deployment tooling to embedded teams.

Running the site in Docker

Docker is the recommended way to run the site, and the reason is visible in the Dockerfile, which pins a Ruby version and installs a Python environment and Node alongside it. The instructions are to follow the Docker Engine install guide for your operating system, clone the repository and run the server script.

$ git clone https://github.com/memfault/interrupt.git
$ cd interrupt
$ ./interrupt-server.sh

The server is then reachable on port 4000. The Dockerfile shows what the image needs. It starts from ruby:3.3.8-slim-bookworm, installs build-essential, git, python3 with pip and venv, and nodejs, forces the bundler to use the Ruby platform, installs bundler version 4.0.10, installs the gems, and then creates a separate Python virtual environment at /venv where it installs a pinned wheel and the contents of requirements.txt. The port 4000 is exposed and the entrypoint script runs the site. The Python requirements are worth noting, since they are unusual for a Jekyll site: a newer version of blockdiag from a pull request rather than the release, because the released one is not compatible with a modern Pillow, plus a pinned Pillow and funcparserlib.

Running it locally, and the two runtimes involved

The local path needs Python 3.8 or later and Ruby 3.3.8, and optionally yarn for the linters, with volta suggested as the easy way to get it. The Python side is set up with a virtual environment so the system Python is not cluttered.

$ git clone https://github.com/memfault/interrupt.git
$ cd interrupt
# Setup a virtual environment to avoid cluttering your system
$ python3 -m venv .venv
# Activate the environment
$ source .venv/bin/activate
$ pip install -r requirements.txt

The Ruby side is managed with bundler, and the project strongly recommends a Ruby version manager such as rbenv, with instructions for setting it up for your operating system and installing the right Ruby version.

# Check that your Ruby version is correct
$ ruby -v
$ bundle install

The yarn dependencies are installed as well, and that step also installs the git hooks.

$ yarn install

Launching, and the flags the serve command uses

The site is served with a single command that also opens it in your browser.

$ bundle exec jekyll serve --drafts --livereload --open-url --future

Each flag is doing something a contributor needs. The drafts flag means you can preview a post you have not published, the livereload flag refreshes the page when a file changes, the open-url flag opens the browser for you, and the future flag includes posts with a date in the future, which matters for a site where publication is scheduled by date. The repository also ships a build.sh and a cloudflare_build.sh, which suggests the site is deployed in more than one way, and a netlify.toml for one of them.

The linting setup, and what it says about the content

The package manifest is small and tells you what the project considers a defect in an article. There are two linters over the post directories, one that checks formatting with prettier and one that checks spelling with typos, each with a fix variant for prettier. The dependencies are prettier at version 3.3.2 and lefthook, which is a git hooks manager, and the spelling checker is the Rust implementation packaged for npm. The lefthook.yml file at the root is what wires the hooks up, and the .gitmessage-publish-article file is a commit message template for publishing an article, which tells you that publication is a commit-driven workflow with a prescribed message format. There is a _typos.toml configuration as well, so the spell checker has its own word list.

The example directory, which is the real archive

The most valuable part of the repository is the example/ directory, and it is far more technical than a typical set of blog posts. Among the entries are arm-cortex-m-exceptions, armv7-mpu, best-of-binutils, ble-primer, breakpoint, c-struct-padding-initialization, ccache-debugging, code-size-deltas, compiler-flags, conda-developer-environments, cortex-m-fault-debug, debugger-traces, debugging-asserts, debugmon, device-heartbeat-metrics, embedded-rust-async, emulating-raspberry-pi-in-qemu, faster-compilation, firmware-shell, freertos-example, freertos-example-llvm, and fwup-architecture, fwup-delta, fwup-encryption and fwup-signing. The names alone sketch out a curriculum, from the low level exception handling of Cortex-M through debugger traces, firmware delta updates and code size measurement. The fwup series in particular is a cluster, which suggests a set of articles on one subject rather than one article.

The wider site, and how to contribute

The site is more than the repository, with a blog directory, a jobs directory for the job board, an events directory, a feeds file, a tags page and a 404 page, plus configuration for both the main site and a preview variant, which is how a review of a pull request works before it goes live. Contributions are welcome on embedded software topics, and there are two ways to make one, emailing the project address or opening a pull request, with the contributing page holding the detail. Before getting in touch the project asks you to get acquainted with the code of conduct, and the code-of-conduct.md file is at the repository root. The acknowledgements note that the site is based on the Emerald theme, and the licence file and a .codeowners file are present, along with a .devcontainer/ directory for working on the site in a container.

Editorial conclusion

Interrupt fits an embedded developer who wants worked examples of the awkward parts of the job, things like fault debugging on Cortex-M, firmware delta updates, code size deltas and ccache debugging, in a format you can read in a browser. It does not fit a reader looking for a tool to install, because the repository is the source of a website and a community rather than a library, and it does not fit someone who needs the content without the site, since the articles are Jekyll posts with images and layout rather than a self-contained document set. Before you contribute, read the code of conduct, since the project asks you to familiarise yourself with it before getting in touch, and follow the contributing page, which is where the pull request process is described.

Frequently asked questions

Official sources

1. Issues
2. memfault/interrupt on GitHub
3. Project website
4. README