NVIDIA H20 NVL16 vs NVIDIA Rubin GPU Comparison

Head-to-Head Benchmarks

The database records no direct benchmark scores for either the NVIDIA H20 NVL16 or the NVIDIA Rubin GPU. Both entries show an average benchmark score of zero, and the head-to-head benchmark table is empty. Without measured performance data, the comparison must rely entirely on the recorded hardware specifications and the derived capabilities those specifications imply. This is a case where the raw silicon characteristics tell the story, and they tell a dramatic one.

The most decisive advantage for the Rubin GPU lies in raw compute throughput. The FP32 performance of the Rubin GPU is recorded at 130.0 TFLOPS, while the H20 NVL16 delivers 39.54 TFLOPS. That is a 3.29x difference in single-precision floating-point work. In FP16, the gap widens further: the Rubin GPU posts 260.0 TFLOPS (2:1) against the H20 NVL16’s 79.07 TFLOPS (2:1), a 3.29x advantage as well. The ratio stays consistent because both parts use the same 2:1 FP16 to FP32 relationship, but the magnitude of the Rubin GPU’s execution units is far larger.

Texture throughput follows the same pattern. The Rubin GPU achieves 2,031.2 GTexel/s, while the H20 NVL16 manages 617.8 GTexel/s. This is a 3.29x lead, which aligns exactly with the FP32 and FP16 ratios. The pixel rate tells a different story, however. The H20 NVL16 posts 47.52 GPixel/s, and the Rubin GPU posts 54.41 GPixel/s. That is a much smaller advantage of roughly 1.15x, indicating that the Rubin GPU’s render output stage is not scaled to the same degree as its shader and texture units. Both cards list 24 ROPs, so the pixel rate difference comes entirely from the higher boost clock of the Rubin GPU.

Clock speeds are an area where the H20 NVL16 actually leads on paper. The H20 NVL16 has a base clock of 1830 MHz and a boost clock of 1980 MHz. The Rubin GPU has a base clock of just 700 MHz but a boost clock of 2267 MHz. The H20 NVL16’s base clock is 2.61x higher than the Rubin GPU’s base clock, but the Rubin GPU’s boost clock is 1.14x higher than the H20 NVL16’s boost clock. This inverted relationship shows that the Rubin GPU is designed to idle very low and ramp aggressively under load, while the H20 NVL16 runs at a consistently higher floor.

Memory bandwidth is another massive win for the Rubin GPU. The H20 NVL16 uses 96 GB of HBM3 on a 6144-bit bus, yielding 4.03 TB/s. The Rubin GPU uses 288 GB of HBM4 on a 16384-bit bus, yielding 22.1 TB/s. That is a 5.48x bandwidth advantage and a 3x capacity advantage. The memory clock also differs: the H20 NVL16 runs at 1313 MHz (5.3 Gbps effective), while the Rubin GPU runs at 2695 MHz (10.8 Gbps effective). The Rubin GPU’s effective memory speed is more than double the H20 NVL16’s.

The Verdict

The data points to a straightforward conclusion: the NVIDIA Rubin GPU is in a completely different performance class from the NVIDIA H20 NVL16. Every major compute metric, FP32, FP16, texture rate, memory bandwidth, and memory capacity, favors the Rubin GPU by a wide margin. The only specification where the H20 NVL16 shows a relative strength is its base clock speed, which is higher, and its pixel rate, which is only slightly lower despite the Rubin GPU’s much higher boost clock.

For workloads that depend on shader compute, tensor operations, or memory bandwidth, the Rubin GPU is the clear choice. Its 3.29x FP32 lead, 3.29x FP16 lead, and 5.48x memory bandwidth advantage mean that any data-parallel workload, AI training run, or large-scale simulation will finish dramatically faster on the Rubin GPU. The 288 GB memory capacity also allows larger models and datasets to reside entirely on the GPU, avoiding the need for memory swapping or host-side staging.

The H20 NVL16 is not without merit, but its merits are relative to its own generation. It offers 96 GB of HBM3 memory and 4.03 TB/s bandwidth, which is substantial for a server part. Its 1980 MHz boost clock is respectable, and its 39.54 TFLOPS FP32 performance is far from trivial. However, when placed directly against the Rubin GPU, the H20 NVL16 is outclassed in every meaningful performance dimension. The percentile data shows both cards at the 50th percentile against all GPUs in the database, but that metric is based on an average benchmark score of zero for both, so it does not differentiate between them.

Architecture Differences

The two GPUs come from different architectural generations. The H20 NVL16 uses the GH100 chip, built on the Hopper architecture, and belongs to the Server Hopper (Hxx) generation. The Rubin GPU uses the GR100 chip, built on the Rubin architecture, and belongs to the Server Rubin (Rxx) generation. The process nodes differ as well: the H20 NVL16 is fabricated on TSMC’s 5 nm process, while the Rubin GPU uses TSMC’s 3 nm process. The die sizes reflect the generational leap: the H20 NVL16 has a die size of 814 mm², while the Rubin GPU has a die size of 1456 mm². Transistor counts scale even more aggressively. The H20 NVL16 packs 80,000 million transistors, while the Rubin GPU contains 336,000 million transistors. That is a 4.2x increase in transistor count, which explains the Rubin GPU’s massive execution unit counts.

Transistor density also improves. The H20 NVL16 has a density of 98.3M transistors per mm², while the Rubin GPU achieves 230.8M transistors per mm². The Rubin GPU’s density is 2.35x higher, which is consistent with the move from 5 nm to 3 nm. The shading unit count jumps from 9984 on the H20 NVL16 to 28672 on the Rubin GPU, a 2.87x increase. Texture mapping units go from 312 to 896, a 2.87x increase. Tensor cores follow the same ratio: 312 on the H20 NVL16 versus 896 on the Rubin GPU. Both cards have 24 ROPs, which is a notable architectural choice, it means the render output stage is identical even though the rest of the chip has scaled massively.

Memory architecture also differs. The H20 NVL16 uses HBM3 with a 6144-bit bus, while the Rubin GPU uses HBM4 with a 16384-bit bus. The memory clock is higher on the Rubin GPU, and the effective data rate is 10.8 Gbps versus 5.3 Gbps. The bus interface also advances: the H20 NVL16 uses PCIe 5.0 x16, while the Rubin GPU uses PCIe 6.0 x16. Both cards are SXM modules with no display outputs, meaning they are designed exclusively for server use. The API support is marked as N/A for DirectX, OpenGL, and Vulkan on both parts, which confirms they are compute-focused accelerators rather than graphics cards.

FAQ

Q: Which GPU has higher FP32 performance?

A: The NVIDIA Rubin GPU delivers 130.0 TFLOPS FP32, which is 3.29x higher than the NVIDIA H20 NVL16’s 39.54 TFLOPS.

Q: How do the memory capacities compare?

A: The Rubin GPU has 288 GB of HBM4 memory, while the H20 NVL16 has 96 GB of HBM3 memory. The Rubin GPU offers 3x the capacity.

Q: What is the memory bandwidth difference?

A: The Rubin GPU provides 22.1 TB/s of bandwidth, while the H20 NVL16 provides 4.03 TB/s. The Rubin GPU has a 5.48x bandwidth advantage.

Q: Do both GPUs have the same number of ROPs?

A: Yes, both the H20 NVL16 and the Rubin GPU have 24 ROPs. The pixel rate differs slightly because the Rubin GPU’s boost clock is 2267 MHz versus 1980 MHz on the H20 NVL16.

Q: What process nodes are used?

A: The H20 NVL16 is built on TSMC’s 5 nm process, while the Rubin GPU is built on TSMC’s 3 nm process.

Q: How do the boost clocks compare?

A: The Rubin GPU has a boost clock of 2267 MHz, which is higher than the H20 NVL16’s boost clock of 1980 MHz. However, the H20 NVL16 has a higher base clock of 1830 MHz versus 700 MHz on the Rubin GPU.

Where Each One Wins

The H20 NVL16 wins in base clock speed. Its 1830 MHz base clock is 2.61x higher than the Rubin GPU’s 700 MHz base clock. This means the H20 NVL16 maintains a higher idle and low-load operating frequency, which could translate to more consistent latency for lightly threaded or latency-sensitive workloads that do not scale with raw parallel throughput. The H20 NVL16 also has a lower power envelope, with a TDP of 400 W versus the Rubin GPU’s 2300 W. It also suggests a lower PSU requirement, 800 W versus 2700 W, which could simplify system integration in power-constrained racks.

The Rubin GPU wins in every high-throughput metric. FP32 compute is 3.29x higher, FP16 compute is 3.29x higher, texture rate is 3.29x higher, and memory bandwidth is 5.48x higher. The Rubin GPU also has 3x the memory capacity, which is critical for large AI models, massive datasets, or in-memory databases. Its boost clock is 1.14x higher, and its pixel rate is 1.15x higher. The Rubin GPU also uses a newer PCIe 6.0 x16 interface versus PCIe 5.0 x16, which gives it more host-side bandwidth potential.

For deep learning training, inference at scale, scientific simulation, or any workload that saturates compute units and memory bandwidth, the Rubin GPU is the only rational choice. For workloads that are latency-bound, run at low occupancy, or are constrained by power delivery, the H20 NVL16 offers a more modest footprint. The H20 NVL16’s higher base clock could help in scenarios where the GPU is not fully loaded but still needs to respond quickly, though the Rubin GPU’s much higher boost clock means it will pull ahead as soon as the load increases.

Specification Differences

The two GPUs differ in nearly every recorded specification. The chip names are GH100 for the H20 NVL16 and GR100 for the Rubin GPU. The architectures are Hopper versus Rubin. The generations are Server Hopper (Hxx) versus Server Rubin (Rxx). The process nodes are 5 nm versus 3 nm. The transistor counts are 80,000 million versus 336,000 million. The die sizes are 814 mm² versus 1456 mm². The transistor densities are 98.3M per mm² versus 230.8M per mm².

Base clocks are 1830 MHz versus 700 MHz. Boost clocks are 1980 MHz versus 2267 MHz. Memory clocks are 1313 MHz (5.3 Gbps effective) versus 2695 MHz (10.8 Gbps effective). Memory sizes are 96 GB versus 288 GB. Memory types are HBM3 versus HBM4. Bus widths are 6144 bit versus 16384 bit. Memory bandwidths are 4.03 TB/s versus 22.1 TB/s.

Shading units are 9984 versus 28672. TMUs are 312 versus 896. ROPs are the same at 24. Tensor cores are 312 versus 896. Pixel rates are 47.52 GPixel/s versus 54.41 GPixel/s. Texture rates are 617.8 GTexel/s versus 2,031.2 GTexel/s. FP32 performance is 39.54 TFLOPS versus 130.0 TFLOPS. FP16 performance is 79.07 TFLOPS (2:1) versus 260.0 TFLOPS (2:1).

TDP is 400 W versus 2300 W. Suggested PSU is 800 W versus 2700 W. Bus interfaces are PCIe 5.0 x16 versus PCIe 6.0 x16. Both are SXM modules with no display outputs and no supported graphics APIs. The H20 NVL16 lists its predecessor as Server Ada and its successor as Server Blackwell. The Rubin GPU lists its predecessor as Server Blackwell and has no recorded successor. Release dates are 2025-09-01 for the H20 NVL16 and 2025-12-31 for the Rubin GPU. Both are marked as Active in production status. Neither has a launch MSRP recorded in the database.