SPDK (Storage Performance Development Kit)

C libraries and ready-made targets for building storage software that drives NVMe SSDs from user space, polling for completions instead of waiting on kernel interrupts.

Linux Foundation project

What it is: Block storage
Type: Open source
Made by: SPDK project (Linux Foundation), started at Intel
Foundation: The Linux Foundation, joined April 2025. A series of LF Projects, LLC, since Intel handed it over in 2025
License: BSD-3-Clause
Facts checked: 28 October 2026

What it is

SPDK moves the storage stack out of the kernel. Its foundation is a user-space NVMe driver: the SSD is unbound from the kernel’s nvme driver (the scripts/setup.sh script does this and reserves hugepages), the application maps the device’s queues into its own memory, and one thread per core submits commands and polls for completions without system calls, interrupts, locks or copies. Threads pass messages instead of sharing data. On top sit a block device layer (bdev) that gives NVMe drives, Ceph RBD images, AIO files, RAID, logical volumes and RAM disks one asynchronous interface, Blobstore, a power-fail-safe block allocator for databases and storage services that don’t need a POSIX file system, and an acceleration framework that hands copies, CRC32C and other operations to engines such as Intel DSA, or to software.

Most users run one of its targets rather than write their own application. nvmf_tgt serves bdevs over NVMe over Fabrics (TCP or RDMA), vhost serves them to QEMU virtual machines as virtio-blk or virtio-scsi disks over vhost-user, iscsi_tgt speaks iSCSI, and the ublk target exposes them back to the local kernel as block devices. All are configured over a JSON-RPC socket with scripts/rpc.py. Ceph’s NVMe-oF gateway and Longhorn’s V2 data engine are built on SPDK. Intel started it in 2013 and open-sourced it in 2015; in 2019 the community’s NVMe driver passed 10 million IOPS on a single CPU core, and in 2023 a two-socket Xeon server reached 120 million IOPS. In December 2024 Intel announced it was divesting from SPDK, and the project moved to the Linux Foundation in 2025 under a Technical Steering Committee whose participating organisations include Arm, Dell, HPE, Nutanix, NVIDIA, Samsung, Solidigm, StarWind and Tencent. Releases are named by year and month, three a year: 26.09 came out on September 25, 2026.

Why teams pick it

Very high IOPS per core: no interrupts, system calls, locks or copies on the I/O path, so one core can drive millions of operations per second
Ready-made NVMe-oF, vhost, iSCSI and ublk targets, so you get a fast storage server or VM disk backend without writing C
Building blocks for your own storage engine: the bdev layer, logical volumes, RAID, Blobstore and hardware acceleration modules
Permissive BSD-3-Clause licence and vendor-neutral governance since the move to the Linux Foundation

Watch out for

Polling keeps its cores busy even when idle; interrupt modes for NVMe over PCIe (25.05) and other modules are newer and narrower
Takes devices away from the kernel: once an SSD is bound to SPDK, kernel file systems and ordinary tools can’t use it unless SPDK exports it back, for example as a ublk device
Needs hugepages, root to set up, and real tuning (CPU masks, queue depths, NUMA placement); it is a development kit, not a finished storage product
Its main sponsor left: Intel divested in December 2024, and per-patch CI and merges were paused until the Linux Foundation project set up new CI in 2025

Alternatives

What all block storage have in common →Compare side by side →

Amazon EBSAWSNetwork-attached virtual disks for EC2 instances, sized and tuned per volume.

CrucibleOpen sourceOxide’s distributed block storage: the VM’s side encrypts every block and mirrors it to three storage servers on three different sleds, which keep it in files on ZFS.

How it fits with other technologies

What SPDK (Storage Performance Development Kit) uses

Export a RAM disk over NVMe/TCP with nvmf_tgt, from the SPDK docs (run from the SPDK directory as root) · bash

scripts/setup.sh                       # reserve hugepages, unbind NVMe devices from the kernel
build/bin/nvmf_tgt &

scripts/rpc.py nvmf_create_transport -t TCP -m 8 -c 8192
scripts/rpc.py bdev_malloc_create -b Malloc0 512 512   # 512 MiB, 512-byte blocks
scripts/rpc.py nvmf_create_subsystem nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001 -d SPDK_Controller1
scripts/rpc.py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0
scripts/rpc.py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t tcp -a 192.168.100.8 -s 4420

# on a Linux host: nvme connect -t tcp -n "nqn.2016-06.io.spdk:cnode1" -a 192.168.100.8 -s 4420

Ways to serve SPDK storage#

Target	Who connects	Typical use
NVMe-oF (`nvmf_tgt`)	Remote hosts with the kernel’s `nvme-tcp` or `nvme-rdma` drivers	Disaggregated flash, storage gateways such as Ceph’s
vhost (`vhost`)	QEMU VMs on the same host, through `vhost-user-blk-pci` or `vhost-user-scsi-pci`	Fast VM disks without the guest’s I/O going through the host kernel
iSCSI (`iscsi_tgt`)	Any iSCSI initiator	Older SANs and hosts without NVMe-oF
ublk	The local Linux kernel, as a `/dev/ublkb*` block device, over io_uring	Using SPDK volumes with ordinary file systems and tools

See it in a real stack

No architecture uses SPDK (Storage Performance Development Kit) yet. Drop it into the playground and wire it up yourself.Open playground →

Where it came from2013–2026

NVMe SSDs made storage fast enough that the kernel became the bottleneck: an interrupt, a context switch and a trip through the block layer for every I/O cost more than the drive’s own latency on media such as Intel’s Optane. Intel started SPDK in 2013 to rebuild the storage stack for that hardware, borrowing the approach of its packet-processing kit DPDK, on which SPDK’s environment layer still builds: drivers in user space, polling instead of interrupts. It opened the project to the community in 2015 under a BSD licence.

The project measured itself in IOPS per core. A redesigned NVMe driver passed 10 million IOPS on one core in 2019, a system scaled to 80 million IOPS in 2021, and a 2U server with two Sapphire Rapids Xeons and Optane SSDs reached 120 million 512-byte random reads per second in 2023. Over the same years SPDK grew targets for NVMe-oF, vhost and iSCSI, and storage vendors such as Nutanix built products on it.

On December 5, 2024 Intel announced that it was divesting from SPDK and that the project would move to the Linux Foundation in 2025. Eleven days later it switched off its CI, which ran most per-patch and nightly testing, and merges to the main branch stopped. The new LF project set up open-source CI infrastructure, formed a Technical Steering Committee, and shipped v25.05 on May 29, 2025, the first release after the transition.

Why it’s built this way

Drivers in user space: Mapping the device’s queues into the application avoids a system call and a copy for every I/O, and lets the application, not the kernel, decide how requests are queued.
Poll instead of waiting for interrupts: At millions of I/Os per second, an interrupt and context switch per completion cost more than the device’s latency. Checking completion queues in a loop lowers both latency and its variance, at the price of a busy core.
No locks on the I/O path; pass messages between threads: Each thread owns its queues and data, and work for another thread is sent to it as a message, so throughput scales with cores instead of stalling on shared locks.

Timeline

2013
Intel starts SPDK
2015
Opened to the community under a BSD licence
2019
New NVMe driver passes 10 million IOPS on one CPU core
2023
120 million IOPS from one 2U Xeon server
2024
Intel announces it will divest and hand SPDK to the Linux Foundation (December 5)
2025
v25.05, the first release under the Linux Foundation (May 29)
2026
v26.09 released (September 25)

Sources16 · facts checked 28 October 2026

Improve this page on GitHub