UTFS: Lightweight Storage for Microcontrollers

File storage is something that most developers rarely think about anymore. Modern computers have gigabytes of storage space available, and even low-cost systems can spare a few megabytes for a file system. The situation is very different in the embedded world, where a project might need to store configuration files, log data, or other information in only a few kilobytes of flash memory.

Traditional file systems introduce too much overhead for use on embedded platforms, so developers have to be more creative. The problem is that these one-off solutions are fragile and often introduce bugs that are difficult to troubleshoot. Fortunately, a better solution may be at hand. CLI Systems recently introduced a new file system called UTFS that brings many of the advantages of a traditional file system to embedded hardware.

What is UTFS?

Short for “micro TAR File System,” UTFS is a lightweight storage layer designed specifically for microcontrollers and other resource-constrained devices. Rather than attempting to replicate desktop file systems like FAT or EXT4, it focuses on a much simpler goal: storing named chunks of data in flat memory spaces such as EEPROM or external SPI flash chips. The system requires only two source files, performs no dynamic memory allocation, and uses a fixed 24-byte header for each stored file.

The problem with current solutions

The motivation behind UTFS comes from a problem familiar to many embedded developers. Configuration settings, serial numbers, calibration values, and feature flags are often stored inside a single structure written directly to non-volatile memory. While this approach is simple, it tightly couples application code to the storage format. Expanding a structure, changing field sizes, or reorganizing data can create compatibility issues and increase the risk of introducing bugs. UTFS instead allows subsystems to maintain their own independent data structures identified by filenames, reducing those dependencies.

The design takes inspiration from the decades-old TAR archive format. Like TAR, UTFS stores files sequentially as a header followed by raw data. Unlike TAR, however, it dramatically reduces overhead. Each UTFS file uses a 24-byte header containing an identifier, version information, feature flags, a user-defined signature value, data size, and a short filename. Files are then packed one after another without additional padding.

Porting UTFS to new hardware is very straightforward. Developers only need to implement two functions: one for reading bytes from storage and another for writing them. Example projects are already available for Linux, Arduino Uno EEPROM storage, and Microchip’s ATSAMD20 microcontroller using internal flash memory.

Where UTFS fits (and where it doesn't)

UTFS is not intended to compete with full-featured file systems. It does not provide journaling, wear leveling, atomic writes, or bad-block management. Instead, it targets the vast number of embedded projects that simply need a reliable way to organize persistent data without the complexity and overhead of a traditional file system. For more details, or to try UTFS out for yourself, check out the project’s GitHub repository.