Industry update — At Embedded World 2026, Patriot Memory’s ACPI industrial brand unveiled the M2PDR-8LP, an industrial-grade PCIe Gen5 x4 M.2 SSD rated at up to 14,000 MB/s sequential read, underscoring how fast embedded NVMe media now push the host controller that must format and write them (Patriot Memory, March 2026).
By the Logic Design Solutions FPGA IP engineering team · Published 16 Jul 2026 · Updated 16 Jul 2026
An exFAT file system on an FPGA is written by an exFAT File-System IP core: it produces OS-readable files — mountable on Windows, macOS and Linux — with no CPU, OS or driver, by building exFAT structures in logic atop an NVMe Host core.
An FPGA can already write terabytes to an SSD at line rate without a processor anywhere in the design. But raw blocks on a drive are not files — pull that SSD out, plug it into a laptop, and the operating system sees an unformatted volume. The missing piece is a file system, and putting one on an FPGA without a CPU is a genuinely hard problem. An exFAT File-System IP core solves it: layered on top of an NVMe Host core, it lets the FPGA write media that Windows, macOS or Linux can mount and read directly — no embedded processor, no software stack, no operating system in the path.
- The short answer
- Raw blocks vs. files: the gap
- Why a file system without a CPU is hard
- How exFAT is built
- How the exFAT layer sits on the NVMe Host core
- With a CPU vs. without a CPU
- Where it matters: recorders, instrumentation, defense
- Where this is the wrong approach
- Frequently asked questions
- Related reading
The short answer
An exFAT File-System IP core implements the exFAT file system — boot region, File Allocation Table, allocation bitmap and directory entries — in FPGA logic, and drives an NVMe Host IP core beneath it to move the actual data to the SSD. The result is an end-to-end, CPU-less storage chain: your application logic hands over a file name and a stream of data, and the FPGA lays down a valid exFAT volume that any modern operating system can mount. This is the differentiator — most FPGA storage designs stop at raw block writes, or bolt on a soft processor to get a file system. Doing the file system in hardware keeps the whole path deterministic and OS-free.
Raw blocks vs. files: the gap
An NVMe Host core, on its own, speaks in logical block addresses. You give it a block number and a buffer; it writes those bytes to that block on the SSD. That is exactly what a self-contained recorder needs when the same system reads its own data back — it knows where it put everything, so it does not need a file system to find it again.
The moment a human or a different machine has to read that media, the picture changes. Operating systems do not read raw blocks; they read files, and files live inside a file system — a defined on-disk layout that says which blocks belong to which file, what the files are called, and how big they are. Without that layout, a laptop mounting the drive sees noise and offers to format it.
So the real requirement behind “the SSD has to be readable on a PC” is: the FPGA must write a valid file system. And since the whole point of the design was to avoid a processor, that file system has to be produced in hardware, on the fly, as the data streams in.
Why is a file system without a CPU hard to build?
File systems were designed to be driven by software. A general-purpose OS keeps large parts of the file-system state in RAM, manipulates linked structures with pointers, handles errors with exception code, and generally assumes a processor is free to walk data structures whenever it likes. Re-creating that behaviour as fixed logic is where the engineering effort concentrates:
- Structures have to be maintained as a hardware state machine. Allocating a cluster means finding a free entry in the allocation bitmap, updating it, updating the File Allocation Table, and eventually writing back the directory entry — all in a defined order, with no software loop to fall back on.
- Everything must keep up with the write stream. On a high-rate recorder, the file-system bookkeeping cannot stall the data path. The logic has to interleave metadata updates with payload writes without dropping samples.
- The on-disk result must be bit-exact. An operating system is an unforgiving reader: checksums, reserved fields and structure layout all have to match the specification precisely, or the volume simply will not mount.
- There is no OS to clean up. Power loss, a full volume or a removed card have to be handled by the logic itself, because there is no driver waiting to recover the file system.
This is why writing OS-readable media from an FPGA without a CPU is uncommon, and why an off-the-shelf, pre-verified exFAT File-System IP core is valuable: the hard, error-prone work of turning a software-shaped file system into deterministic logic is already done and tested.
How exFAT is built
exFAT (Extended File Allocation Table) is Microsoft’s file system for flash media, published as an open specification in 2019. It was designed as the successor to FAT32, removing FAT32’s practical file-size and volume-size limits while staying simple enough to implement in constrained environments — which is precisely what makes it a good fit for a hardware implementation. Understanding its regions makes the IP core’s job concrete.
The volume layout
An exFAT volume is a sequence of well-defined regions:
- Boot region. A boot sector and its backup describe the volume geometry: bytes per sector, sectors per cluster, the offset and length of the FAT, the start of the cluster heap, and a boot checksum. Get any field wrong and the OS rejects the volume.
- File Allocation Table (FAT). The table that records cluster chains — which cluster follows which for a fragmented file. exFAT keeps the FAT concept from its predecessors but streamlines it.
- Cluster heap. The bulk of the volume, divided into fixed-size clusters — the smallest unit of allocation. File data lives here.
- Allocation bitmap. One bit per cluster marking it free or in use. This is what the logic consults and updates every time it needs space, and it is a first-class exFAT structure rather than a scan of the FAT.
- Up-case table. A table used for case-insensitive file-name comparison, which the file system must lay down for a compliant volume.
- Root directory. The starting point of the directory tree, made up of directory entries.
Clusters and allocation
Everything hinges on the cluster. Files are stored as one or more clusters; a large file is a chain of them. exFAT allows a neat optimisation that suits streaming hardware especially well: when a file is written contiguously, it can be flagged as “no FAT chain”, meaning its clusters are known to be consecutive and the file system does not need to walk the FAT to read it — the allocation bitmap alone tracks the space. A recorder that writes one long, continuous stream naturally produces contiguous files, so this path keeps both the write logic and later the read side simple.
Directory entries
A file in exFAT is not a single record but a set of directory entries: a primary File entry (attributes, timestamps), a Stream Extension entry (data length, first cluster, the no-FAT-chain flag), and one or more File Name entries holding the Unicode name. The set carries a checksum so a reader can detect corruption. The IP core has to assemble these entry sets correctly — this is exactly the kind of exacting, spec-literal work that is painful to do by hand and reassuring to license as verified logic.
How does the exFAT layer sit on the NVMe Host core?
The power of the approach is in the layering. Think of it as a hardware storage stack, each layer with one job:
- Your application logic produces data — sensor samples, video, telemetry — and asks to write it as a named file, typically connected to the core over an AXI interface.
- The exFAT File-System IP core turns that request into file-system operations: it allocates clusters via the bitmap, maintains the FAT where needed, builds the directory entry set, and decides which logical blocks the payload and metadata must occupy.
- The NVMe Host IP core takes those block-level writes and executes the NVMe protocol — submission and completion queues, doorbells, PCIe data transfers — to put the bytes on the SSD.
- The SSD stores a volume that is now a fully formed exFAT file system.
Crucially, none of these layers needs a processor. The exFAT core does not run software; it is a state machine that emits block writes. The NVMe Host core, covered in our complete guide to NVMe Host IP for FPGA, executes them in hardware. The clean interface between them — file operations above, block operations below — is what lets the same file-system layer, in principle, sit on a different storage back end. The same architectural idea applies when the transport is a SATA Host IP core rather than NVMe: the file system speaks blocks, and the host core underneath speaks the wire protocol.
Need an FPGA to write files a PC can read, with no CPU in the design? That is exactly what our exFAT File-System IP core, on top of our NVMe Host core, is built for.
With a CPU vs. without a CPU
The same “write OS-readable files” requirement can be met two ways. The comparison below is qualitative — the right choice depends on your system — but it shows why a hardware file system is compelling when determinism and simplicity matter.
| Aspect | Soft CPU + software file system | exFAT File-System IP (no CPU) |
|---|---|---|
| Processor | Soft core (MicroBlaze, Nios, RISC-V) plus its memory and caches | None — the file system is logic |
| Software stack | OS/RTOS, drivers, file-system library to integrate and maintain | No OS, no driver, no firmware to maintain |
| Timing behaviour | Scheduler-dependent; latency varies with software load | Deterministic hardware pipeline |
| Certification / audit surface | Larger — software must be reviewed and, in regulated domains, certified | Smaller — a bounded, traceable logic block |
| Boot / readiness | Waits for the processor and stack to come up | Ready when the fabric is configured |
| Best fit | Systems that already carry a CPU for other reasons | Pure-hardware recorders and instrumentation that want no software in the storage path |
Neither column is universally “better”. If your design already includes a processor doing real work, adding a software file system may be the pragmatic choice. But if you moved to an FPGA specifically to escape software non-determinism, importing a CPU just to format a drive undoes that decision — and that is where the hardware exFAT core earns its place.
Where it matters: recorders, instrumentation, defense
Flight and mission recorders
An airborne recorder — often built on an NVMe host recorder IP core — captures continuous data and must be recoverable on the ground quickly. If the FPGA writes an exFAT volume directly, a technician can remove the drive or card and open the files on a standard laptop — no proprietary reader, no software export step. Combined with the deterministic, OS-free write path, this suits systems where every function has to be simple to qualify and every sample has to be captured.
Test instrumentation and data acquisition
High-rate DAQ systems generate large capture files that engineers then analyse on a PC. Writing exFAT in hardware means the instrument produces immediately usable media at full capture rate, without a processor stealing cycles from the acquisition path and without a post-processing conversion. The removal of FAT32’s small-file and small-volume limits is exactly what large, long captures need.
Defense and rugged embedded systems
In defense and other high-assurance domains, minimising the software footprint is a goal in itself: less code is less to secure, less to certify, and less to fail unpredictably — the same rationale behind putting avionics buses such as ARINC 429 in FPGA fabric. A storage path with no operating system — exFAT file system and NVMe host both in fabric — keeps the removable-media interface interoperable with standard tools while holding the trusted computing base as small as the mission allows.
Across all three, the common thread is portable, standard-readable media produced by hardware. That specific combination — OS-readable files, no CPU — is uncommon, and it is where an exFAT File-System IP core is a real differentiator rather than a commodity block.
Where this is the wrong approach
A hardware exFAT layer is powerful, but it is not always the right tool:
- Your system already has a capable CPU. If a processor is present and lightly loaded, a software file system may be simpler than adding an IP core — the hardware core shines when you want no processor at all.
- The media never leaves the system. If your own logic both writes and reads the SSD, you do not need a file system at all; raw block writes through the NVMe Host core are lighter.
- You need advanced file-system features. exFAT is deliberately lean — no journaling, no permissions, no snapshots. If your use case needs those, exFAT is the wrong file system regardless of where it runs.
- You store only tiny amounts of data. For a few kilobytes of configuration or calibration, flash and a trivial layout beat any full file system.
In summary
Giving an FPGA the ability to write files an operating system can read — without a CPU, an OS or a driver anywhere in the design — comes down to two cooperating hardware layers: an exFAT File-System IP core that maintains the on-disk structures (boot region, FAT, allocation bitmap, directory entry sets, contiguous-file optimisation), sitting on an NVMe Host IP core that moves the blocks over PCIe. The file system speaks blocks down; your application speaks files up. For flight recorders, instrumentation and defense systems that need portable, standard-readable media with a minimal software footprint, doing the file system in fabric is not just possible — it is the differentiator.
Need an NVMe host or storage IP core for your FPGA? Our engineers ship production-proven cores for AMD and Altera devices.
Frequently asked questions
Can an FPGA really write an exFAT volume with no processor at all?
Yes. An exFAT File-System IP core implements the file-system logic — cluster allocation, the File Allocation Table, the allocation bitmap and directory entry sets — as a hardware state machine, and drives an NVMe Host core beneath it to write the blocks. There is no OS, no driver and no soft CPU in the path, which is what keeps it deterministic.
Why exFAT rather than FAT32 or NTFS?
exFAT is Microsoft’s flash-oriented file system, published as an open specification, and it removes FAT32’s practical file-size and volume-size limits while staying simple enough to implement in logic. NTFS is far more complex (journaling, permissions, advanced metadata), which makes a hardware implementation impractical. For large streaming captures on removable media, exFAT is the natural fit.
Will the media be readable on Windows, macOS and Linux?
exFAT is natively supported on modern Windows and macOS, and on Linux through the in-kernel exFAT driver. Because the IP core writes a specification-compliant volume, a drive or card written by the FPGA mounts on those systems like any other exFAT medium — provided the on-disk structures match the specification exactly, which is the core’s job.
How does the exFAT core relate to the NVMe Host core?
They are stacked. The exFAT core turns file operations into block-level reads and writes; the NVMe Host core executes those as NVMe commands over PCIe to the SSD. The clean file-over-block interface is what lets the file system stay independent of the underlying transport — the same idea works over a SATA Host core.
Does the file-system layer slow down the write path?
The core is designed to interleave metadata maintenance with payload writes so it can keep up with the data stream rather than stalling it. Contiguous files — the natural output of a continuous recorder — use the exFAT “no FAT chain” optimisation, which keeps the bookkeeping minimal. Actual sustained rates depend on your FPGA family, PCIe generation and SSD; those should be sized against your application’s real throughput.
What happens on power loss or a full volume?
Because there is no OS to recover the file system, these conditions are handled in the logic itself. The correct design goal is that the volume remains mountable and already-written files remain intact up to the last completed write. How aggressively partial writes are protected is a design decision to discuss against your reliability requirements.
Related reading
- NVMe Host Recorder IP for high-speed data acquisition on FPGA — the recorder data path this file system writes onto.
- SATA vs NVMe for FPGA storage: which interface to use — choosing the transport beneath the exFAT layer.
- AXI-to-NVMe: connecting NVMe Host IP to your FPGA fabric — how your application logic drives the storage stack.
- What is an FPGA IP core? Soft IP vs hard IP — background on licensing pre-verified logic like the exFAT core.
Want an FPGA that writes OS-readable media end to end, with no CPU in the storage path? Tell us your target family, throughput and media, and we will point you to the right IP or scope the design.
- Microsoft — exFAT file system specification: the open specification defining the boot region, FAT, allocation bitmap, up-case table and directory entry structures.
- NVM Express, Inc. — NVMe Specifications: the command-queue and transport model the NVMe Host core implements beneath the file system.
- PCI-SIG — PCI Express Specifications: the PCIe link generations that carry the NVMe traffic to the SSD.
- Linux kernel documentation — exFAT file system: reference for native exFAT support on Linux, relevant to reading FPGA-written media.
