What Is NVMe SAN IP? Building Storage Networks in FPGA Fabric

What Is NVMe SAN IP? Building Storage Networks in FPGA Fabric

Industry update — A February 2026 peer-reviewed review in Applied Sciences surveyed six open FPGA SmartNIC shells — Coyote, OpenNIC, RecoNIC, Corundum, ClickNP and FpgaNIC — and documented how, in composable NVMe-oF fabrics, the FPGA itself terminates NVMe headers and streams data at 100 Gb/s line rate, casting reconfigurable fabric as a first-class storage-networking node rather than a mere accelerator (MDPI Applied Sciences, February 2026).

Storage stopped being a box bolted to a single server a long time ago. In high-rate recorders, radar arrays and distributed instrumentation, storage is a network — many drives, many writers, one shared fabric. Building that fabric normally means racks of servers, host bus adapters and switches. But when the data is born inside an FPGA, you can build the storage network in the fabric itself. That is what an NVMe SAN IP core does. This guide explains what it is, why the FPGA is the right place to put it, and where a hardware NVMe-over-Fabrics endpoint earns its keep.

By the Logic Design Solutions engineering team · FPGA storage & NVMe IP · Published 16 July 2026

The short answer

An NVMe SAN IP core turns an FPGA into a node on an NVMe-over-Fabrics storage network — acting as an initiator, a target, or both — with no server and no software storage stack in the data path. The value is threefold: offload (the network transport and NVMe queueing run in hardware), determinism (bounded, repeatable latency instead of operating-system jitter) and edge placement (the storage network lives where the data is captured). Logic Design Solutions ships this capability as the NOE SAN IP line, built on the same NVMe and Ethernet cores used across its catalogue.

What is a SAN IP core?

A SAN IP core is an FPGA IP block that turns programmable logic into a fabric-attached storage endpoint: it translates NVMe commands into network transactions and back, in gates, so an FPGA can join a storage-area network as an initiator or target without a host CPU in the data path.

A SAN — storage area network — is block storage delivered over a dedicated network rather than over a cable to one machine. Instead of each host owning its own drives, drives live on a fabric and any authorised node can read and write them as if they were local. Data centres have done this for decades over Fibre Channel and iSCSI; the modern form carries the NVMe command set across the network and is called NVMe over Fabrics.

A SAN IP core is the piece that makes an FPGA a first-class citizen of that network. It implements the fabric endpoint entirely in logic: it encapsulates NVMe commands into network transactions on the way out, and unpacks incoming transactions back into NVMe operations on the way in. There is no host CPU translating between the storage world and the network world, because the FPGA is the translation — in gates, at line rate. That is the essential idea behind an nvme over fabrics fpga design: the endpoint is silicon fabric, not software running above a driver.

NVMe over Fabrics, briefly

NVMe over Fabrics (NVMe-oF) extends the NVMe command model — the same deep, parallel queues that make local NVMe fast — across a network transport instead of a local PCIe link. The command set stays familiar; only the delivery changes — the model is standardised by NVM Express, the same body behind the base NVMe specification. Common transports include RDMA over Ethernet, Fibre Channel and plain TCP, each trading complexity for reach and cost.

We unpack the protocol layer itself — how NVMe commands are carried over a transport, and how the queue model survives the trip — in our companion primer, NVMe over Fabrics on FPGA: concepts and where SAN IP fits. This article assumes that groundwork and focuses on the harder, more interesting question: how you build that endpoint in FPGA fabric, and why you would want to. If NVMe-oF is new to you, read the concepts piece first, then come back here.

Why build the SAN in FPGA fabric

A server can already be an NVMe-oF node, so the fair question is why put the endpoint in an FPGA at all. Three reasons, and they compound.

Offload: the transport runs in hardware

In a software SAN, every command crosses a driver, an operating-system network stack and host memory before it reaches a drive. Each hop costs cycles, copies and cache pressure. A hardware SAN core collapses that chain: the NVMe queueing and the network transport are implemented in logic, so payload moves through the fabric without a general-purpose CPU touching it. The processor, if there is one at all, is freed for the application instead of shovelling storage traffic.

Determinism: bounded latency, no OS jitter

General-purpose software gives you an average latency with a long, unpredictable tail — the scheduler preempts, the stack buffers, a garbage-collection or interrupt storm lands at the worst moment. For a radar recorder or a flight-test capture, that tail is the enemy: a single missed deadline can drop a frame you cannot recapture. A fabric endpoint has no scheduler and no OS in the path, so its timing is fixed and repeatable by construction. Determinism is not a tuning exercise here; it is a property of the architecture.

Edge placement: the network lives where the data is

Because the endpoint is a core in your FPGA, the storage network can start at the sensor rather than in a distant rack. Capture, encapsulate and ship to networked storage happen at the edge, inside the same device that already digitises the signal. That cuts hops, keeps data inside a controlled boundary, and shrinks the size, weight and power budget — the SWaP that decides whether a system flies, sails or fits in a vehicle at all.

Inside the architecture: initiator, target, switching

An NVMe SAN built in fabric is assembled from a small number of roles. The same FPGA can play one of them or several at once, which is exactly what makes the approach flexible.

The initiator role

As an initiator, the FPGA is the writer and reader. It generates NVMe commands and issues them across the fabric to remote targets, pushing captured data out to networked drives it does not physically own. This is the natural role for a sensor or acquisition node: it produces data at line rate and streams it into the storage network without ever mounting a local filesystem.

The target role

As a target, the FPGA does the opposite — it presents drives attached to it to the rest of the network, answering NVMe-oF commands from remote initiators. A target node turns a bank of local NVMe SSDs into shared, network-addressable storage. Because the target logic sits in fabric, it can serve the network while enforcing exactly the access rules the design demands, with no general-purpose OS to harden.

Switching and aggregation in fabric

The most FPGA-native role is the one in the middle: bridging, fan-out and aggregation. An FPGA can gather several capture streams, marshal them into the fabric, and route or replicate traffic between initiators and targets — work that would otherwise need a discrete switch. Building this in fabric keeps the whole storage network inside a coherent, CPU-less design where every path is deterministic. Each role connects to your capture datapath through a standard AXI interface, so the SAN endpoint drops into an existing design rather than dictating it. In the NOE line, these roles are assembled from the same NVMe host logic and Ethernet MAC that Logic Design Solutions ships as standalone cores, which is why the pieces fit together cleanly rather than being bolted on.

Designing a networked recorder or a distributed acquisition system? Tell us your topology and sustained rate — we will map it to the right SAN roles.

Talk to an FPGA engineer

Defense and instrumentation use cases

The offload-determinism-edge combination is not academic; it maps directly onto the environments where a software SAN struggles.

Airborne and naval recorders

Radar, electronic-warfare and wideband RF systems generate continuous, high-rate streams that must be captured without gaps. A networked, fabric-based SAN lets several high-rate capture nodes write into a shared, ruggedised storage pool with bounded latency, inside a SWaP envelope a rack of servers could never meet.

Distributed data acquisition and test

On a test range or an engine bench, many sensors capture in parallel and their data has to land coherently. FPGA initiators at each acquisition point streaming to one or more target nodes give you a storage network that scales by adding nodes, not by rebuilding a central server.

Sovereign and auditable storage paths

Where the whole data path must be reviewable — no commodity operating system, no opaque driver stack — a storage network implemented in FPGA logic is inherently easier to reason about and certify. What the fabric does is what the design says it does, with no background processes in between.

Server SAN vs FPGA NVMe SAN IP

Software storage server versus a fabric-based NVMe SAN endpoint
Criterion Server-based SAN FPGA NVMe SAN IP
Data path Driver, OS network stack, host memory NVMe queueing and transport in logic
Latency profile Good average, long unpredictable tail Fixed and repeatable by construction
CPU / OS in path Required None — CPU-less operation
Roles Initiator or target via software Initiator, target or switching in fabric
Placement Rack / data centre At the sensor, at the edge
SWaP Chassis, power and cooling of a server Fits the FPGA already in the system
Auditability Depends on OS and driver stack Deterministic, reviewable logic
Best for General-purpose enterprise storage Deterministic edge capture and recording

The table is not an argument that one always beats the other. A data centre serving mixed enterprise workloads wants the flexibility of a software SAN. A recorder that must never drop a frame in a size-constrained platform wants the fabric endpoint. The right answer follows the mission, not the fashion.

What NVMe SAN IP does not solve

A fabric SAN core is a powerful building block, not a whole storage product. It is worth being clear about its edges:

  • It is block storage, not a filesystem. A SAN endpoint moves NVMe blocks across a network; namespace layout, directories and file semantics are a separate layer you design on top.
  • It is aimed at embedded and edge scale, not hyperscale. This is a deterministic endpoint for capture and instrumentation, not a replacement for a large enterprise storage array with its management ecosystem.
  • It cannot outrun an under-sized network or drive. Sustained rate is still bounded by the transport you choose and the SSDs behind the target. The core removes software overhead; it does not create bandwidth that the physical link and media do not have.
  • Security at rest is a separate decision. Encryption, key handling and access policy sit alongside the transport and must be specified for the mission, not assumed.

Get the topology and the sustained-rate budget right first; the SAN core then does exactly the job it is meant to, and nothing it is not.

Need an NVMe host or storage IP core for your FPGA? Our engineers ship production-proven cores for AMD and Altera devices.

Talk to our IP team

Frequently asked questions

What is NVMe SAN IP in one sentence?

It is an FPGA IP core that implements an NVMe-over-Fabrics storage-network endpoint — initiator, target or switching — entirely in logic, so an FPGA can read and write networked NVMe storage with no server or software storage stack in the data path.

How is this different from NVMe host IP?

NVMe host IP talks to a drive over a local PCIe link. NVMe SAN IP talks to drives across a network using NVMe over Fabrics. The SAN core adds the transport and the initiator, target or switching roles on top of the same underlying NVMe command model.

Which transport does NVMe over Fabrics use on an FPGA?

NVMe-oF can run over RDMA on Ethernet, Fibre Channel or TCP. On an FPGA the practical route is typically over Ethernet, which is why a SAN core is usually paired with an Ethernet MAC. The right transport depends on your reach, latency and cost targets.

Does an FPGA SAN endpoint need a processor?

No. The transport and NVMe queueing are implemented in fabric, so the endpoint runs with deterministic timing and no operating system in the data path. Any processor in the system is freed for the application rather than storage traffic.

Why not just use a storage server?

For general enterprise storage, a server is often the better fit. For deterministic edge capture — radar, flight test, distributed instrumentation — the fabric endpoint wins on bounded latency, size, weight and power, and an auditable data path a general-purpose OS cannot match.

Can one FPGA be both initiator and target?

Yes. The roles are logic that can coexist in the same device, and an FPGA can also perform switching and aggregation between them. That flexibility is a large part of why building the storage network in fabric is attractive.

LDS
Logic Design Solutions
FPGA design house and soft-IP core vendor — NVMe, SATA, ARINC 429 and Ethernet IP for AMD and Altera FPGAs since 1994.

Building a storage network into your next FPGA? Send us your node topology and sustained data rate — we will help you shape the initiator, target and switching roles into a design that holds its timing.

Talk it through with an engineer

  1. NVM Express — NVMe over Fabrics specification and command model
  2. SNIA — storage area network (SAN) primer and definitions
  3. PCI-SIG — PCI Express specifications underpinning NVMe