HighPoint Technologies this week pulled back the curtain on a sweeping portfolio of PCIe 5.0 switch cards and adapters designed to blast data directly between NVMe storage and GPUs at up to 64GB/s. The hardware promises to bring hyperscale‑grade AI data paths to off‑the‑shelf white‑box servers, letting smaller cloud builders, research labs, and edge operators avoid the CPU bottleneck that starves accelerators during inference, checkpointing, and media‑heavy workloads. But for the millions of Windows users reading this, one fact needs to be stated up front: NVIDIA’s GPUDirect Storage, the software layer that makes the magic possible, remains a Linux‑and‑CUDA affair. That doesn’t mean these cards are useless in a Windows workstation—you’ll still get screaming‑fast NVMe arrays—but the direct GPU‑to‑storage path won’t be on the menu.

What Actually Arrived: A Family of Switched Adapters, Not a Single Card

HighPoint didn’t release just one product. The company unwrapped an entire matrix of PCIe Gen5 and Gen4 boards built around Broadcom’s PEX89048 (Gen5) and PEX88048 (Gen4) switch silicon. The headliner is the Rocket 1628A, a Gen5 x16 card that uses four internal MCIO 8i ports. By aggregating two of those ports through a companion MCIO‑to‑PCIe x16 bridge, builders can hang a full‑width GPU directly on the card, while the remaining ports feed up to 16 NVMe drives through a backplane—all on the same physical switch. That topology keeps storage‑to‑GPU traffic local to the adapter, bypassing motherboard PCIe hierarchies that often impose IOMMU or ACS restrictions.

Other Gen5 options include:
- Rocket 1608A: eight on‑card M.2 slots
- Rocket 1604A: four on‑card M.2 slots
- Rocket 1624A: four internal MCIO 4i ports

For environments where 32GB/s is plenty, the Gen4 lineup stays current:
- SSD7749M2: a dense 16‑slot M.2 card
- SSD7749M: eight M.2 slots
- Rocket 1508 and Rocket 1504: eight and four M.2 slots
- Rocket 1528D: four internal SlimSAS 8i cabled connections
- RocketStor 6542AW: eight‑bay U.2/U.3 external enclosure
- RocketStor 6541AW: four‑bay M.2/U.2 external enclosure

External PCIe 5.0 gets attention too. The Rocket 7638D and Rocket 7634D adapters use CopprLink cabling to drive expansion chassis like the RocketStor 8631 series—enclosures built to hold full‑size, multi‑slot GPUs outside the host server. That opens the door to modular systems where compute, storage, and accelerators live in separate boxes linked by native PCIe, not Ethernet or Fibre Channel.

What This Means for You—And Why Your OS Determines Everything

The practical impact of this hardware splits cleanly along the Windows‑vs‑Linux line.

Windows Home Users and Prosumers

If you’re running Windows 11 on a workstation and eyeing these cards for video editing, large databases, or local AI tinkering, you can absolutely use the switched NVMe density. The Rocket 1608A, for example, will appear as a multi‑drive storage controller under Windows, assuming HighPoint supplies signed drivers. You’ll get blazing sequential reads and the ability to pool several M.2 SSDs behind one slot—handy when your motherboard’s own M.2 count is limited. But the GPUDirect Storage (GDS) path that shunts data straight into GPU memory without staging in system RAM? That’s off the table. GDS relies on NVIDIA’s cuFile libraries, Linux kernel peer‑to‑peer DMA plumbing, and CUDA driver components that don’t exist on Windows. Your GPU and NVMe array will still talk, but every byte will detour through the CPU and main memory.

Power Users and IT Pros Running Linux

Here’s where the hardware earns its keep. On a supported Linux distribution with a compatible NVIDIA data‑center GPU and the correct CUDA/cuFile stack, you can cut the CPU out of data movement. That lowers latency, reduces CPU cycles burned on copy operations, and can keep an inference pipeline fed with batch data, vector indexes, or model checkpoints without accelerator stalls. The benefit is workload‑dependent: a purely compute‑bound model that fits entirely in GPU memory will see little change; storage‑intensive retrieval‑augmented generation or media processing will see more.

System Integrators and Regional Cloud Operators

This is the audience HighPoint is really chasing. Regional MSPs and small cloud providers rarely have the engineering muscle to design proprietary multi‑GPU storage fabrics. HighPoint’s cards let them drop a PCIe switch into a standard Supermicro or ASRock Rack server and build a repeatable, high‑bandwidth AI node. The ability to place both GPU and storage behind the same switch—topology number two in HighPoint’s playbook—means the performance‑critical path is defined by the add‑in card, not the server’s slot wiring. That reproducibility across different white‑box platforms could lower support headaches.

How We Got Here: The Data‑Path Problem Behind the AI Bottleneck

Modern AI servers look like they’re GPU‑limited on the surface. Dig deeper and you find accelerators idling because the storage pipeline can’t keep them fed. A typical I/O operation starts with an NVMe drive sending data into host memory; then the CPU or DMA engine copies it into a GPU‑accessible buffer; then the GPU finally scoops it up. That bounce through system RAM saturates DRAM bandwidth, burns CPU threads, and adds latency—exactly what you don’t want when an inference request needs embeddings from a terabyte‑scale vector database.

NVIDIA introduced GPUDirect Storage in 2019 to solve this. GDS creates a direct DMA channel between supported storage and GPU memory, with the CPU only involved in setup and file‑system metadata. But the software needs a hardware topology that physically allows peer‑to‑peer transactions. Most white‑box motherboards aren’t wired for it; their PCIe root complexes and ACS policies often force all traffic to the CPU. HighPoint’s adoption of Broadcom’s high‑lane‑count switches is a recognition that a software feature isn’t enough—you need a forgiving fabric underneath.

This isn’t the first PCIe switch on the market. Companies like Broadcom itself, Microchip, and others have offered switch chips for years. What’s new is the turnkey packaging: pre‑built cards, bridge adapters, external enclosures, and a compatibility matrix aimed at integrators who don’t want to design their own PCB. That lowering of barriers puts GDS within reach of a much broader market, provided the qualification and support hold up.

What to Do Now: A Practical Checklist Before You Buy

HighPoint’s announcement is a spec sheet, not a drop‑in guarantee. If you’re considering these cards for a real project, here’s how to evaluate them.

1. Decide whether your workload actually needs GDS

Run your AI pipeline and profile it. If GPU utilization is consistently below 90% and you see high CPU iowait during data loading, a direct path might help. If your model weights and working set fit comfortably in GPU HBM, you may not need it.

2. Map your server’s PCIe topology before ordering

Identify CPU sockets, root ports, NUMA domains, and any lanes shared with networking or onboard controllers. Dust off lspci -t and numactl so you know which physical slot feeds which CPU.

3. Pick the right HighPoint topology for your OS and virtualization plans

  • Motherboard‑routed storage feeders (Rocket 1608A, etc.) fit best when GPUs are in onboard slots and you just need denser storage. Works on Windows and Linux, but Windows won’t get the GDS shortcut.
  • Hardware‑isolated compute‑storage loops (Rocket 1628A hosting both GPU and NVMe) are the GDS gold standard because traffic stays on the card. However, this requires a dedicated GPU slot on the adapter, which may compete with other PCIe needs.
  • External bridges (Rocket 7638D) make sense when your server chassis can’t physically accommodate a GPU alongside dense storage. Remember: external PCIe 5.0 cables need careful handling—marginal connections can cause link retraining or device loss.

4. Verify software stack compatibility

For GDS, you need a known‑good combination of:
- Linux kernel (typically 5.x or later with peer‑to‑peer DMA support)
- NVIDIA data‑center driver (525+ depending on GPU)
- CUDA 11.4+ and cuFile
- A filesystem that supports GDS (e.g., ext4, XFS, or a supported parallel FS; avoid uncommon RAID setups without validation)
- No ACS or IOMMU enforcement that blocks peer‑to‑peer—which may conflict with virtualization security if you’re a multi‑tenant host

Windows users: focus on the NVMe storage aspect. Check HighPoint’s download page for signed Windows drivers (likely for the storage controller function) and confirm that your chosen SSDs are on their compatibility list.

5. Don’t trust the 64GB/s headline number until you test it

64GB/s is the theoretical ceiling for a PCIe 5.0 x16 link. Real applications see far less after accounting for encoding, small transfers, metadata operations, and SSD limitations. Benchmark your own workload with GDS enabled and with it disabled, measuring:
- Sustained read/write throughput
- 99th percentile latency
- GPU utilization
- CPU load and memory bandwidth consumption
- Temperatures, especially on dense M.2 cards

6. Plan for cooling and serviceability

An eight‑drive M.2 card packed into one slot generates significant heat. In an AI server already dissipating 300W from each GPU, ambient temps can climb fast. Factor in chassis airflow, fan curves, and whether you can replace a single failed SSD without removing the entire card. Cabled solutions (MCIO, SlimSAS) give more thermal flexibility and easier service.

7. Validate failure modes before production

Pull a drive, disconnect a cable, unload the GDS driver, rack up 72 hours of mixed reads and writes. See how the system degrades. A single switch card failure could take out both storage and an attached GPU, so redundancy matters—though at these price tiers, redundancy may be sacrificed for density.

What to Watch Next: Real‑World Benchmarks and a Windows Driver Surprise?

HighPoint’s product matrix looks comprehensive, but the company’s track record with the white‑box AI crowd is still unproven. The first independent reviews will be critical. Look for testers who dare to benchmark the Rocket 1628A in a variety of scenarios: small‑file random reads during inference requests, simultaneous capture‑and‑analyze workloads at the edge, and straight‑line throughput with eight Gen5 SSDs hammering a single GPU. Results from one carefully tuned sequential‑read test won’t predict real‑world behavior.

Equally important will be HighPoint’s published compatibility lists. A $600 adapter becomes a liability if you can’t find a supported SSD, GPU, or cable at your preferred distributor. Watch for reference configurations that name specific server models (Dell PowerEdge XR, Supermicro BigTwin, ASRock Rack GPU nodes) so smaller providers can buy with confidence.

And for Windows users, there’s a faint hope: Microsoft has been quietly exploring DirectStorage for GPUs in the gaming and content‑creation space. While that’s a different API with different goals, it’s possible that future Windows Server or workstation releases could enable some form of direct NVMe‑to‑GPU path without a full Linux stack. For now, HighPoint’s cards will give Windows workstations exceptional storage speed, but the AI crowd will be booting Ubuntu.