NVIDIA Reshard Release: 2.7x to 5.7x Faster RL Refit

NVIDIA · ax-trend issue #3877 · NVIDIA announcement published November 6, 2026

Title card: NVIDIA Reshard, faster reinforcement learning weight refit

NVIDIA published the Reshard collective on November 6, 2026, targeting the weight refit step in reinforcement learning post-training, where updated weights move from training GPUs to inference GPUs after each policy update. In NVIDIA's NeMo RL measurements, refits with Reshard ran 2.7x to 5.7x faster than the previous approach. On a DGX H100 system, a DeepSeek v3 671B refit dropped from 14.9 seconds to 2.6 seconds, and a dedicated microbenchmark for a 2.4 trillion parameter model finished a refit in 4.3 seconds.

The first reference implementation, NCCL M2N Reshard, is open source in the NVIDIA/nccl-extensions repository. Teams already running NeMo RL can test it with a single configuration change, which makes this a practical release to evaluate rather than a research preview. The catch sits in the evidence base: every number in the announcement is NVIDIA's own measurement, with no independent replication published yet.

Refit as a DTensor-to-DTensor Problem

In a disaggregated RL setup, training and inference run in parallel on separate GPU resources, and only the training side updates the policy. The inference side therefore needs the newest weights at every step. The problem is that the two sides split the model differently, so the weight tensors sit in different parallel layouts and a plain copy cannot work. As models grow, the transfer itself starts to consume a large share of step time.

Reshard reframes that transfer as a problem of moving from one DTensor layout to another. It computes which parts of the source and destination layouts overlap and sends only those overlapping shards directly between the GPUs that hold and need them. That avoids the gather-and-broadcast pattern, where the full tensor is first collected and then redistributed, moving far more data than the destination layout actually requires.

Direct shard-to-shard transfer diagram: two training GPUs hold row blocks of a tensor and four inference GPUs each receive the column blocks they need
Direct shard-to-shard transfer in the Reshard example: training GPU T0 holds rows 0 to 3 and sends a 4 by 2 block to each of the four inference GPUs, while T1 does the same for rows 4 to 7. (Photo: NVIDIA Developer Blog)

Framing refit as one collective operation, callable from DTensor descriptions alone, also changes who owns the problem. Each RL framework previously had to implement its own refit logic for its own layout choices. A single operation defined over source and destination DTensor layouts gives other frameworks the same abstraction to adopt, instead of another round of framework-specific transfer code.

Measured Refit Times Across Four Setups

NVIDIA reports four NeMo RL comparisons, covering two models on DGX H100 systems and two on DGX GB200 systems:

Bar chart of DeepSeek v3 671B refit time on DGX H100: 14.9 seconds with gather and broadcast, 2.6 seconds with Reshard
DeepSeek v3 671B refit time on DGX H100 in NVIDIA NeMo RL measurements: 14.9 seconds for gather and broadcast, 2.6 seconds for Reshard.

The spread between 2.7x and 5.7x is itself informative. The gain depends on the model and the hardware, which means the refit share of step time and the layout mismatch differ per setup. A team evaluating Reshard should expect a gain inside this range only if its own layout pairing resembles one of these four cases, and the honest way to find out is to measure its own refit before and after the switch.

Trillion-Parameter Scale and the Payload Problem

NVIDIA sizes the problem with two current frontier models. Kimi K3 has 2.8 trillion parameters and Qwen 3.8 2.4T A95B has 2.4 trillion parameters. At BF16 precision, the weights alone come to about 5.6 TB and 4.8 TB respectively. Combining gather and broadcast, NVIDIA estimates the refit payload at roughly 11.2 TB for Kimi K3 and 9.6 TB for Qwen 3.8.

Those payload estimates explain why a layout-aware transfer matters more as models scale. A gather-and-broadcast refit moves close to twice the weight size per step, and that cost repeats at every policy update for the entire RL run. Cutting the moved data to only the overlapping shards attacks the term that grows directly with parameter count, rather than a fixed overhead that scale would eventually hide.

The dedicated microbenchmark points in the same direction. For a Qwen3.8 2.4T BF16 model, a Reshard refit took 4.3 seconds. NVIDIA presents this as a refit-only microbenchmark, so it shows the transfer mechanism holding up at trillion-parameter scale, not a full training step time.

Hybrid Path for Feed-Forward Weights

Timeline diagram: training updates the policy, inference needs new weights, layouts differ, only overlapping shards move directly, small weights keep the old path
How Reshard replaces the refit: the layout problem, direct shard transfer for the bulk of the weights, and the older path retained for small weights.

The shipped implementation is hybrid rather than pure. NVIDIA bases the split on the observation that feed-forward projection weights account for about 95 percent of all parameters. Only that dominant portion takes the Reshard path. The remaining smaller weights still travel through the existing gather-and-broadcast path.

That split is a pragmatic engineering choice. The Reshard machinery earns its complexity where the data volume is, in the feed-forward projections, while the long tail of small tensors keeps a simpler path whose absolute cost is minor. It also means the reported speedups already include this compromise, since the measurements come from the hybrid implementation rather than from an idealized all-Reshard variant.

Enabling Reshard in NeMo RL

For NeMo RL users, adoption is a configuration change. NVIDIA documents two settings:

refit_transport: nccl_reshard
policy.generation.colocated.enabled: false

The low adoption cost matters for how this release will spread. RL infrastructure teams rarely rewrite a transfer layer mid-project, but flipping a transport setting for a measured comparison is an afternoon of work. If independent runs reproduce even the lower end of the reported range, the setting becomes an easy default for disaggregated RL setups on NVIDIA hardware.

The refit is reframed as a single operation defined over DTensor layouts, so frameworks no longer need to hand-roll weight transfer for each layout pairing.

The open-source release supports that spread. NCCL M2N Reshard lives in the NVIDIA/nccl-extensions repository, so framework maintainers outside the NeMo RL stack can read the reference implementation and judge how the DTensor abstraction maps onto their own layout machinery.

Limits in the Published Numbers

Three limits should travel with the headline speedup. First, all figures are NVIDIA's own measurements and no independent replication exists yet. Second, the announcement gives refit latency only. The share of refit in total RL step time varies by configuration, so reading 2.7x to 5.7x as a whole-training speedup would overstate the result. Third, the post reports no repetition counts or variance, so the stability of these timings across runs is unconfirmed.

There is also an operational caveat around failure recovery. When layouts change at runtime, the current NeMo RL approach destroys and recreates the communication groups. NVIDIA says a future update will use the NCCL shrink and grow APIs instead. Teams running long RL jobs with elastic or failure-prone clusters should treat that roadmap item as part of the evaluation, since refit speed matters most exactly in the large, long-running setups where layout changes happen.

Related Reading

NVIDIA has been publishing the tooling around distributed AI training failures and performance in the same line of work. See the coverage of NVIDIA Attribution, its open-source tool for tracing the root cause of distributed AI failures, which addresses the debugging side of the same large-scale training setups that Reshard speeds up.

FAQ

What is NVIDIA Reshard?

Reshard is a collective communication method for the weight refit step in reinforcement learning post-training. It reframes the refit as a DTensor-to-DTensor problem and sends only the overlapping parts between the source and destination layouts, instead of gathering the full tensor and broadcasting it again.

How much faster is refit with Reshard?

In NVIDIA NeMo RL measurements, Reshard refits ran 2.7x to 5.7x faster than the previous method. On DGX H100, DeepSeek v3 671B dropped from 14.9 seconds to 2.6 seconds, and Qwen 3 235B dropped from 6.4 seconds to 1.9 seconds. All figures are NVIDIA's own measurements.

How is Reshard enabled in NeMo RL?

In NeMo RL, enabling Reshard takes one setting: set refit_transport to nccl_reshard and keep policy.generation.colocated.enabled set to false. The first reference implementation, NCCL M2N Reshard, is open source in the NVIDIA/nccl-extensions repository.

Does Reshard move every weight the same way?

No. The implementation is hybrid, based on the observation that feed-forward projection weights make up about 95 percent of all parameters. Only that portion takes the Reshard path, while the remaining smaller weights still use the existing gather-and-broadcast path.

Sources

AI InfrastructurePerformanceAX Trend