NVIDIA Reshard Release: 2.7x to 5.7x Faster RL 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.
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:
- Qwen 3 235B on DGX H100: 6.4 seconds down to 1.9 seconds
- DeepSeek v3 671B on DGX H100: 14.9 seconds down to 2.6 seconds
- DeepSeek v3 671B on DGX GB200: 6.1 seconds down to 2.3 seconds
- Nemotron Ultra v3 on DGX GB200: 8.2 seconds down to 2.3 seconds
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
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.