Industry update — Altera’s Agilex 5 D-Series FPGAs now ship hard IP for up to six PCIe 4.0 x8 controllers, giving designers native, CPU-free lanes to wire multiple NVMe SSDs straight into the fabric (Embedded Computing Design, May 2026).
Adding fast, file-system-ready storage to an FPGA used to mean one of two unappealing choices: drop in a soft processor and a software stack, or spend months writing a storage protocol from scratch. An NVMe Host IP core removes that dilemma. It turns your FPGA into a complete NVMe host controller — talking directly to modern M.2 and U.2 SSDs over PCIe — with the entire protocol implemented in logic, no CPU required. This guide explains what an NVMe Host IP core does, how the AMD (Xilinx) and Altera variants differ, when to pick Gen4 versus Gen5, and how to choose the right core for your target device.
- The short answer
- What is an NVMe Host IP core?
- Why does “no soft CPU” matter?
- NVMe Host IP on AMD (Xilinx) FPGAs
- NVMe Host IP on Altera FPGAs
- Gen4 vs Gen5: which PCIe generation do you need?
- How do you choose the right core?
- Writing OS-readable media: the exFAT layer
- When is an NVMe Host core the wrong tool?
- Frequently asked questions
The short answer
An NVMe Host IP core lets an FPGA act as a full NVMe host — issuing commands, managing submission and completion queues, and moving data to and from an SSD over PCIe — entirely in hardware, with no embedded processor and no operating system. The right core for your project depends on three things: your target FPGA family (which fixes the available PCIe hard block), the PCIe generation you need (Gen4 versus Gen5), and whether you need the SSD to be readable on a PC afterwards (which calls for an exFAT file-system layer on top of the host core).
What is an NVMe Host IP core?
NVMe (Non-Volatile Memory Express) is the protocol modern SSDs speak over PCIe. On a PC, an NVMe driver inside the operating system handles the conversation: it builds command queues in memory, rings a doorbell register, and waits for the SSD to post completions. An NVMe Host IP core reproduces that host role as a block of synthesizable logic you drop into your FPGA design.
Concretely, the core implements the NVMe command set, the submission and completion queue mechanics, the doorbell handshakes, and the data transfers, sitting on top of the FPGA’s PCIe interface. Your application logic talks to the core through a streaming or memory-mapped interface — you hand it a buffer and a logical block address, and it writes that data to the SSD. The 400-plus pages of the NVM Express base specification stay inside the IP, not in your schedule.
This is the defining trait of a soft IP core, as opposed to hard IP: it is pre-designed, pre-verified logic you license and integrate, rather than RTL you write and validate yourself. For a protocol as intricate as NVMe — with its queue arbitration, namespace handling and PCIe link management — the verification effort alone is what makes building from scratch rarely worth it.
Why does “no soft CPU” matter?
Many FPGA storage designs reach for a soft processor (a MicroBlaze, a Nios, or a RISC-V core) running an NVMe software stack. It works, but it imports the very problems engineers move to an FPGA to escape:
- Non-deterministic latency. A software scheduler decides when the storage task runs. For a continuous recorder that cannot drop a sample, “usually fast” is not good enough.
- A software attack and certification surface. An operating system and driver stack add code that must be secured and, in regulated domains, certified.
- Resource and power overhead. The soft CPU, its memory controller and its caches consume logic and watts that a fully hardware path does not.
A hardware-only NVMe Host core keeps the entire state machine in FPGA fabric. There is no OS, no driver, and in many designs no external DDR needed for the storage path itself. The payoff is deterministic timing and a far simpler system to qualify — a decisive advantage in avionics, defense and instrumentation, the same domains that drive our ARINC 429 avionics data-bus IP, where every function has to be traceable.
NVMe Host IP on AMD (Xilinx) FPGAs
On AMD (formerly Xilinx) devices, the NVMe Host core sits on top of the integrated PCIe block of the target family. The portfolio spans a wide range of UltraScale+ and adaptive SoC families, so the same host functionality can land on a small cost-optimized part or a large data-center-class device. Commonly targeted families include:
- Artix UltraScale+ — cost- and power-optimized designs that still need real NVMe throughput.
- Kintex UltraScale+ — the mid-range workhorse for high-rate recorders and instrumentation.
- Zynq UltraScale+ — where a processing system coexists with the fabric, but the storage path itself stays in hardware.
The practical selection question on AMD parts is which PCIe hard block the family provides and how many lanes you can route to the SSD. A Gen4 x4 link to an M.2 drive is a typical high-throughput configuration; the host core drives it without a soft CPU in the loop. AMD documents its own hardware NVMe acceleration approach in its NVMe Host Accelerator IP product page, which illustrates why the host role is increasingly handled in fabric rather than software.
NVMe Host IP on Altera FPGAs
On Altera devices, the equivalent NVMe Host core targets the Agilex and earlier families. The headline platform here is Agilex 7 with the R-Tile — a PCIe tile that brings Gen5 capability to the device, opening the door to the highest sustained write rates in the current FPGA generation. The host core uses that tile to reach SSD throughput that a Gen3 or Gen4 link cannot — a configuration we break down in our guide to NVMe host IP on Agilex 7 with the R-Tile for Gen5 storage.
The selection logic mirrors the AMD side: the family and its PCIe tile fix the achievable generation and lane count, and the host core abstracts the protocol above it. Choosing Altera versus AMD is therefore less about the NVMe core itself and more about the rest of your system — the transceivers, the toolchain, the supply situation and any qualification you have already done on a given family; our FPGA IP vendor buyer’s checklist walks through exactly those tradeoffs. A storage IP vendor that ships the host core for both ecosystems lets you make that platform decision on its own merits, rather than being locked in by your storage choice.
Unsure which FPGA family and PCIe generation fit your storage target? A short technical conversation usually settles it.
Gen4 vs Gen5: which PCIe generation do you need?
Each PCIe generation roughly doubles the per-lane data rate of the one before it. That headline figure is real, but the right generation for your design is set by your data rate and your device, not by wanting the newest number.
| Consideration | Gen4 | Gen5 |
|---|---|---|
| Relative link rate | Baseline high-speed | Roughly double Gen4 per lane |
| FPGA support | Broadly available across UltraScale+ and Agilex | Requires a Gen5-capable tile (e.g. Agilex 7 R-Tile) |
| Signal integrity effort | Moderate | Higher — tighter PCB and channel budget |
| Typical fit | Most high-rate recorders and DAQ | Highest sustained-write, multi-stream recorders |
The honest rule of thumb: choose Gen5 when your sustained write rate genuinely exceeds what a Gen4 x4 link delivers, and your board and FPGA can support it. For a large share of designs, a well-fed Gen4 link is the sweet spot — more than enough throughput, broader device choice, and a simpler PCB. The NVM Express organization’s specifications describe the queue model that lets either generation reach its potential; under-feeding the command queues is the usual reason a fast link disappoints.
How do you choose the right core?
Work through four questions in order:
- Which FPGA family are you committed to? If the device is fixed by other constraints, that determines your PCIe tile and therefore your achievable generation. Make sure a host core exists for that exact family.
- What sustained write rate do you actually need? Size to the real, continuous rate of your application — not the SSD’s burst number on the datasheet — then add headroom.
- How much logic can you spare? The host core competes with your application logic for the device. Budget the core plus your design with margin; do not pick a part that only fits the core.
- Does the SSD need to be readable on a PC? If yes, you need a file-system layer on top of the host core (see below). If the data is consumed by your own system, raw block writes are enough.
Writing OS-readable media: the exFAT layer
An NVMe Host core writes raw logical blocks. That is perfect when your own system reads the data back, but it produces media a PC cannot mount. If a field engineer needs to pull the SSD and open the files on a laptop, you need a file system — and again, without a CPU, that file system has to live in hardware too.
An exFAT File System IP core layered on the NVMe Host core solves exactly this: the FPGA writes files an operating system can read, with no embedded processor anywhere in the path. It is a genuine differentiator for portable recorders and removable-media systems, and it is the kind of CPU-less, end-to-end storage chain that is hard to assemble from generic parts — the same approach behind our NVMe host recorder IP for high-speed data acquisition.
When is an NVMe Host core the wrong tool?
NVMe is not the answer to every storage problem. Reach for something else when:
- Your throughput is modest. If your data rate sits comfortably under what a single SATA link delivers, a SATA Host core is smaller, simpler and cheaper in logic. NVMe earns its footprint only above that line — our SATA vs NVMe comparison maps out exactly where that line sits.
- You only store kilobytes. For configuration or calibration data, QSPI flash or an EEPROM costs a fraction of the resources of any SSD controller.
- The data must leave the box. If storage is remote, an NVMe-over-Fabrics or Ethernet path fits better than a local SSD.
- The FPGA is too small. If the device cannot hold the core plus your application logic with margin, the right move is to revisit the device — the classic FPGA-versus-ASIC and IP-reuse tradeoff — not to starve the core.
In summary
An NVMe Host IP core is the cleanest way to give an FPGA modern, high-speed storage without importing a processor and a software stack. The core abstracts the NVMe protocol; your real decisions are the FPGA family (AMD or Altera, which fixes the PCIe tile), the generation (Gen4 for most designs, Gen5 when sustained rates demand it), and whether you need an exFAT layer for PC-readable media. Get those three right and you have a deterministic, certifiable storage path built entirely in hardware.
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
Does an NVMe Host IP core really work without a processor?
Yes. A fully hardware NVMe Host core implements the protocol state machine — command queues, doorbells, PCIe link management and data transfers — directly in FPGA logic. There is no operating system and no driver, which is what gives it deterministic, repeatable latency.
Which FPGA families can run an NVMe Host core?
The core targets AMD (Xilinx) families such as Artix UltraScale+, Kintex UltraScale+ and Zynq UltraScale+, and Altera families including Agilex 7. The achievable PCIe generation depends on the family’s PCIe tile — for example, the Agilex 7 R-Tile enables Gen5.
Should I choose Gen4 or Gen5?
Choose Gen5 only when your sustained write rate genuinely exceeds what a Gen4 x4 link delivers and your board and FPGA support it. For most recorders and data-acquisition designs, a well-fed Gen4 link is the practical sweet spot.
Can the FPGA write an SSD that a PC can read afterwards?
Yes, by layering an exFAT File System IP core on top of the NVMe Host core. The FPGA then writes files an operating system can mount directly, still with no embedded processor in the path.
When is NVMe overkill compared with SATA?
When your throughput fits comfortably under a single SATA link. A SATA Host core uses less logic and is simpler to integrate, so NVMe is worth its larger footprint only when you genuinely need multiple gigabytes per second or very low latency.
Do I need external DDR memory for the storage path?
Not always. Many hardware NVMe Host cores keep the storage data path self-contained, which removes an external memory controller from that path and simplifies the board. Confirm the buffering model against your target throughput when selecting a core.
Need an NVMe Host core for your target FPGA, or a custom storage design end to end? Tell us your family, generation and throughput — we’ll point you to the right core or scope the work.
- NVM Express, Inc. — NVMe Specifications: the base and PCIe transport specifications defining the command-queue model used by any NVMe host.
- PCI-SIG — PCI Express Specifications: the PCIe generations (Gen4, Gen5) that set the physical link rates available to an FPGA host.
- AMD — NVMe Host Accelerator IP: vendor reference for handling the NVMe host role in FPGA hardware rather than software.
- Altera Agilex 7 FPGAs and SoCs: family and PCIe tile (R-Tile) reference relevant to Gen5 NVMe host designs.
