CppCon 2026

Embedded systems live in a world where timing, memory, and reliability are not “nice to have” properties—they are the system. And yet, storage is often treated as if it exists outside those constraints: you write a file, you call an API, and you assume the system will “get around to it.” In most applications, that assumption is fine. In real-time systems, it quietly becomes a risk.

This talk starts from a simple but uncomfortable question: what if storage had to be as predictable as the rest of your real-time system?

We will explore what changes when predictability is no longer an optimization, but a design requirement for an embedded file system. Using a deterministic file system written in modern C++ as a concrete case study, we will walk from system-level requirements all the way down to implementation details that make storage behavior measurable, bounded, and reasoned about.

Along the way, we will look at design choices that are often avoided in general-purpose file systems: fixed-block allocation instead of dynamic growth, metadata-first layouts that make state explicit, strictly bounded operations with worst-case guarantees, and explicit ownership models that eliminate ambiguity around lifetime and responsibility. We will also examine how storage operations interact with real-time scheduling, and what happens when file I/O is no longer “background work,” but part of the timing budget.

Modern C++20 plays a central role—not as a performance trick, but as a way to encode intent. Strong types prevent invalid configurations from compiling. RAII makes resource ownership explicit and deterministic. Compile-time configuration moves entire classes of errors out of runtime. And carefully constrained abstractions allow us to build systems that remain suitable for deeply resource-limited microcontrollers without sacrificing clarity.

But determinism always comes with a cost. Once you commit to predictable behavior, you give up some flexibility: storage efficiency may decrease, allocation strategies become more rigid, and you may lose features that depend on dynamic behavior. This talk does not hide those tradeoffs—it makes them visible, measurable, and intentional. We will discuss when deterministic storage is the right answer, and just as importantly, when it is not.

Finally, we will step back from the implementation and look at portability. The same architectural ideas will be mapped across multiple environments: file-backed storage used for testing, SPI flash on microcontrollers, and block devices under embedded Linux. The goal is not a single file system, but a reusable way of thinking about storage in constrained systems.

By the end of this talk, attendees will not just understand a file system design—they will have a practical framework for reasoning about timing guarantees, resource ownership, failure modes, and architectural tradeoffs in embedded C++ systems where predictability matters more than peak throughput.