Xiaohongshu Open-Sources BigMac, Challenging the Multimodal Training Tradeoff

Xiaohongshu open-sources BigMac with a striking claim: its new training pipeline runs multimodal workloads 1.08 to 1.9 times faster than tested baselines without letting activation memory grow with batch size. The system targets a stubborn conflict in multimodal model training. Teams usually gain speed by retaining more intermediate data, or conserve memory by accepting more idle GPU time and communication.

BigMac does not introduce a new foundation model. It changes how an existing multimodal model's components are scheduled across an accelerator cluster. Xiaohongshu's researchers place encoder and generator operations inside the language model pipeline while preserving their dependencies. They call the result a dependency-safe nested pipeline.

That distinction matters because previous systems attacked different halves of the problem. Optimus focused on filling idle periods inside the language model pipeline. DistTrain separated heterogeneous components so each could use a more suitable parallel configuration. BigMac attempts to combine high utilization with bounded activation memory, making the real contest compute-efficient scheduling versus memory-efficient scheduling.

The results are promising, but they remain author-reported. BigMac's paper is a preprint, and its broadest production claims have not received independent, large-cluster replication. Its significance therefore rests on two questions. Can outside teams reproduce the gains, and can they integrate the scheduler without rebuilding their training stack?

Xiaohongshu Open-Sources BigMac for a Different Kind of Bottleneck

BigMac treats multimodal training as a scheduling problem before treating it as a hardware problem.

A multimodal large language model combines a language model with modality-specific components. A vision encoder, for example, converts images into representations the language model can process. A generator can turn the language model's output into images, video, audio, or another nontext format.

Those components rarely consume compute in the same way. A language model may consist of many relatively uniform transformer layers. A vision encoder can have a different parameter count, sequence structure, and parallelization sweet spot. A diffusion-based generator introduces another computational pattern and another set of dependencies.

The resulting model resembles a production line whose stations operate at different speeds. GPUs assigned to one component can finish early and wait for another. These idle intervals are commonly called pipeline bubbles, periods when an accelerator has no useful operation because required data has not arrived.

The BigMac researchers argue that existing solutions often exchange one scarce resource for another. A scheduler can keep more work in flight and reduce bubbles, but retaining that work increases activation memory. Activations are intermediate values saved during the forward pass because backpropagation needs them later.

Alternatively, a system can release activations sooner or divide model components more aggressively. That approach lowers memory pressure but can add communication, synchronization, or idle time. The paper frames these choices as a Pareto frontier, where improving compute efficiency tends to worsen memory efficiency.

BigMac's central move is to keep the original language model pipeline as the scheduling backbone. Encoder and generator operations are then nested into that backbone only when their dependencies permit execution. The scheduler does not arbitrarily reorder mathematical operations to find empty GPU cycles.

The research team describes this structure in the BigMac preprint, posted on May 25, 2026. The paper names 11 authors and evaluates both multimodal understanding and generation workloads. Xiaohongshu later presented the system through its technical publication as an open-source component used by the dots model team.

The reported performance range needs context. BigMac was 1.08 to 1.1 times faster than Optimus in tested settings, according to a detailed analysis of the results. Against the more memory-conscious Megatron-DistTrain baseline, the reported advantage ranged from 1.5 to 1.9 times.

These comparisons do not mean every training job becomes 90 percent faster. The larger numbers come from specific baseline and workload combinations. Hardware topology, model architecture, batch composition, pipeline depth, and communication bandwidth can all change the result.

What changed is still meaningful. Xiaohongshu has released a systems technique that targets understanding models and models with generative components. It also says BigMac has moved beyond laboratory testing into the production training path for its dots multimodal models.

Why Multimodal Training Forces GPUs Into Bad Choices

The pressure comes from model heterogeneity, not simply from models becoming larger.

Scaling a text-only transformer already requires teams to coordinate data parallelism, tensor parallelism, pipeline parallelism, and memory management. Multimodal training adds components that do not divide cleanly under one shared strategy.

Pipeline parallelism assigns consecutive groups of model layers to different devices. Microbatches move through those stages like items through a factory. It can distribute a large model efficiently, but the pipeline must be carefully filled and drained.

A vision encoder may finish its portion before the relevant language model stage can consume the result. A generator must wait until the language model produces suitable outputs. During backward propagation, gradients must return through those components in the correct order.

A simple scheduler can execute the encoder early and store its activations. That keeps inputs ready for the language model, but stored activations accumulate as more microbatches enter the pipeline. Increasing the global batch size then raises peak memory use.

This pattern creates a practical ceiling. A team may have enough arithmetic capacity for a larger batch, yet lack the memory needed to retain every intermediate state. Reducing the batch or checkpointing more activations can restore feasibility, but both choices can lower effective throughput.

Optimus attacked idle time directly. Its researchers observed that encoder kernels could occupy bubbles in the language model schedule. The published Optimus system reported 20.5 to 21.3 percent faster training for a ViT-22B and GPT-175B combination across 3,072 GPUs.

That approach established an important principle: heterogeneous components do not always need separate, sequential execution windows. Useful encoder work can be inserted into otherwise idle time.

However, filling bubbles does not automatically control how long activations remain live. If an encoder runs far ahead of the corresponding backward operation, the system retains more intermediate data. Compute utilization improves while memory pressure rises.

DistTrain approached heterogeneity through disaggregation. It gave model components separate resource and parallelization plans, then reorganized data to reduce imbalance across modalities. Its DistTrain research reported 54.7 percent model FLOPs utilization for a 72-billion-parameter multimodal model on 1,172 GPUs.

The same work reported up to 2.2 times the throughput of Megatron-LM in its evaluated settings. Yet disaggregation can introduce communication and orchestration costs. A system that protects memory and accommodates different components can still leave performance on the table.

BigMac pressures both routes by claiming teams no longer need to choose between them. Its direct opponent is not one company or framework. It is the assumption that compute-efficient multimodal scheduling must consume growing activation memory.

This pressure extends to platform teams building around general training frameworks. NVIDIA's Megatron Core provides distributed training components for large transformer and multimodal workloads. Teams using such foundations still need a schedule that reflects the dependencies of their particular architecture.

For large AI labs, a scheduling improvement can affect more than benchmark speed. Higher throughput reduces the elapsed time between experiments. Bounded memory can permit larger batches, longer sequences, heavier encoders, or larger generators on an existing cluster.

The value is less direct for application developers who only call model APIs. Still, training efficiency influences which multimodal capabilities reach production. It can determine whether a model team can afford another data run, architecture test, or higher-resolution training stage.

BigMac Nests Work Without Letting Activations Pile Up

The mechanism depends on controlling when operations become eligible, not merely squeezing more kernels into empty time.

BigMac begins with an interleaved language model pipeline. Interleaving assigns multiple virtual model segments to a physical pipeline stage, allowing forward and backward operations to alternate more tightly. The language model's established schedule remains the main clock.

The scheduler decomposes the encoder workload into units associated with language model inputs. It then places a limited number of encoder forward units ahead of consumption. The paper's analyzed schedule uses a constant lookahead rather than allowing the encoder to run across the entire batch.

This bounded lead is central to the memory claim. An encoder activation only needs to survive until the language model consumes its output and backpropagation returns the corresponding gradient. BigMac schedules the encoder's backward operation as soon as that dependency is satisfied.

Under the paper's interleaved schedule, only a constant number of encoder units must remain active at once. The researchers describe the encoder's activation memory complexity as O(1). In plain terms, the relevant memory does not grow in proportion to the number of microbatches.

O(1) does not mean zero memory. It means the number of simultaneously retained encoder activation units stays bounded under the stated schedule. Actual memory use still depends on encoder size, image resolution, sequence length, precision, and implementation details.

The generator follows a related pattern. Its forward computation begins when the language model produces the required output. BigMac places the generator's backward work immediately after the necessary forward dependency, preventing generator activations from accumulating across many microbatches.

That scheduling choice is especially relevant for multimodal generation. A large diffusion transformer or similar generator can consume substantial memory. Running several generator forwards before their backward passes can exhaust accelerator memory even when the language model itself fits.

Dependency safety provides the guardrail. Every nested operation must respect the model's forward and backward graph. The scheduler cannot fill an attractive gap if doing so would consume unavailable data or overwrite information required later.

The researchers also claim the nested work does not add bubbles to the original language model schedule. That is the compute side of the argument. BigMac aims to preserve the efficiency of a hypothetical schedule with enough memory to retain every activation, while avoiding that schedule's growing memory footprint.

Its reported tests used an understanding configuration built around a Qwen3-30B-A3B language model and a 1.3-billion-parameter vision transformer. The generation workload added a 20-billion-parameter multimodal diffusion transformer generator.

Across those evaluated workloads, BigMac reportedly produced the lowest iteration time. It maintained stable peak memory as batch size increased, while the compute-focused baseline's memory rose and eventually triggered out-of-memory failures in some generation settings.

The paper also examines context parallelism, which splits long sequences across devices. Different multimodal components may benefit from different context-parallel group sizes. BigMac's decoupled configuration reportedly reached up to 1.45 times the speed of a homogeneous setup.

Another experiment changed communication for fully sharded data parallelism. Fully sharded data parallelism distributes parameters, gradients, and optimizer states across workers to lower per-device memory. BigMac replaced a standard collective gathering pattern with a one-sided pull mechanism and reported an improvement of up to 1.03 times.

Those secondary gains are smaller than the headline range, but they reveal the design's ambition. BigMac is not only inserting encoder kernels into empty slots. It is trying to coordinate pipeline scheduling, component-specific parallelism, and parameter movement under one dependency model.

The team also reports numerical checks across 128 iterations. Average absolute loss differences remained below 0.001 in its comparison, according to the paper's results. That test supports semantic consistency, but it does not establish universal reproducibility across models or software environments.

The Production Claim Is Stronger Than the Public Evidence

BigMac's most important result is its production scale, and that is also the result outsiders can least easily verify.

Xiaohongshu says BigMac has trained a 345-billion-parameter multimodal model on 1,536 NVIDIA Hopper GPUs. The reported run continued for more than 18,000 iterations with decreasing loss and bounded gradient norms.

That deployment moves the project beyond a simulator or small laboratory cluster. Scheduling systems can behave differently at scale because network contention, hardware failures, data imbalance, and collective communication become harder to hide.

Yet the production evidence remains controlled by the authors. The preprint provides measurements and implementation details, but an outside team has not publicly reproduced the 345-billion-parameter run. The trained production model and full operational environment are not equivalent to a portable benchmark.

Open-sourcing a scheduler also does not erase integration work. Training stacks contain custom data loaders, checkpoint formats, parallel group management, mixed-precision logic, failure recovery, and monitoring. A dependency-safe schedule must interact correctly with all of them.

The current design also assumes a suitable interleaved pipeline structure. The paper's constant encoder lookahead relies on scheduling properties associated with virtual pipeline parallelism. Teams using different pipeline schedules may not inherit the same memory bound without adaptation.

Workload balance creates another uncertainty. Multimodal batches rarely contain uniform images, videos, audio segments, or text lengths. A schedule that looks dense under controlled shapes can develop gaps when real examples require different amounts of computation.

Data-aware packing could help, but packing introduces its own constraints. Samples must be grouped efficiently without changing optimization semantics or creating excessive padding. The paper identifies broader scheduling support and data-aware packing as future directions.

BigMac also optimizes systems efficiency, not model quality. Faster iterations do not guarantee better reasoning, visual understanding, image generation, or alignment. They give researchers more usable compute, but the resulting model still depends on data, objectives, architecture, and evaluation.

The comparison with Optimus deserves similar care. BigMac's 1.08 to 1.1 times advantage over the compute-efficient baseline is useful, but far smaller than the top-line 1.9 times figure. Readers should not blend results against different baselines into one universal acceleration claim.

The 1.5 to 1.9 times range against Megatron-DistTrain reflects another tradeoff. That baseline emphasizes stable memory through disaggregated execution. BigMac's larger advantage suggests nested scheduling can recover performance lost to conservative orchestration, at least under the tested conditions.

There is also a naming hazard. Another unrelated AI project uses BigMac for a communication-efficient mixture-of-experts architecture. Xiaohongshu's BigMac is a multimodal training pipeline, not that MoE model structure. Teams evaluating the release should verify that documents and repositories refer to the 2026 pipeline paper.

Independent replication should therefore measure more than raw iteration time. A credible evaluation would report peak memory, accelerator utilization, communication volume, convergence, failure recovery, and engineering changes required for integration.

It should also compare equal training semantics. Batch composition, activation checkpointing, numerical precision, and effective token counts must match. Otherwise, an apparently faster schedule might be performing less work or retaining less information.

The open-source release makes those tests possible, but it does not predetermine their outcome. BigMac's strongest interpretation remains a company-backed systems result with unusually large production evidence. Its weakest interpretation is a specialized schedule whose gains narrow outside Xiaohongshu's stack.

The likely answer sits between those extremes. The mechanism is concrete, and it directly addresses a known systems conflict. The remaining question is how broadly the implementation transfers across architectures, clusters, and training frameworks.

Three Signals Will Show Whether BigMac Changes Multimodal Training

The next stage is about adoption and replication, not another headline benchmark.

The first signal is an independent benchmark against Optimus and DistTrain-style configurations. A credible reproduction should use at least one understanding workload and one workload with a large generator. It should publish iteration time and peak memory across increasing batch sizes.

If that test preserves BigMac's stable memory curve and most of its speed advantage, the paper's central judgment becomes stronger. If gains disappear after matching software versions and parallel settings, the result looks more environment-specific.

The second signal is support for additional language model pipeline schedules. Many organizations cannot replace their established schedule simply to adopt one multimodal optimization. Compatibility with noninterleaved configurations, different virtual pipeline sizes, and dynamic workloads would widen the addressable user base.

Broader schedule support would show that dependency-safe nesting is a general abstraction rather than a carefully tuned production recipe. Persistent constraints around one pipeline pattern would weaken that interpretation, even if Xiaohongshu continues using it internally.

The third signal is visible adoption in an external training framework or model project. A maintained integration, reproducible configuration, and public issue history would reveal how difficult the system is to operate. Download counts or repository attention alone would say little.

A successful integration should expose whether users can specify encoder, language model, and generator dependencies without rewriting the scheduler. It should also show how BigMac handles checkpoint recovery, uneven batches, and hardware faults.

These signals matter because multimodal training is becoming structurally more complicated. Models increasingly combine vision encoders, language backbones, diffusion generators, audio modules, and routing mechanisms. Adding hardware cannot eliminate the dependencies between those parts.

Xiaohongshu open-sources BigMac at a moment when efficiency work is shifting from isolated kernels toward whole-system orchestration. Faster matrix multiplication still matters, but idle accelerators and long-lived activations can waste those kernel-level gains.

For AI infrastructure teams, the immediate action is straightforward. Treat BigMac as a scheduling design worth benchmarking, not as a guaranteed multiplier. Reproduce its memory curve first, then measure speed under the architecture and data distribution that matter to your organization.

For model builders, watch whether the scheduler remains stable when inputs vary. High-resolution images, long videos, and mixed understanding-generation batches will test its assumptions more severely than uniform microbenchmarks.

For everyone else, the larger lesson is that future multimodal gains will not come only from bigger models. They will also come from deciding exactly when each component runs, where its intermediate state lives, and how quickly that state can be released.

Will independent teams reproduce BigMac's claimed balance, or discover that its best results depend on Xiaohongshu's production stack? That answer will determine whether this release becomes a reusable training pattern or an impressive, specialized systems result.