SolarWM Trains on Five-Second Clips, Then Runs for an Hour Without Breaking

Every video world model you can currently sit down and play (Genie's demos, Oasis, the various Minecraft clones making the rounds) was trained the same way: on short clips, then asked at inference time to keep going for far longer than it ever saw during training. That mismatch is where things fall apart. Doors reopen. Objects swap identity. A scene that was coherent for the first thirty seconds turns into something closer to a fever dream by the two-minute mark, because the model is now generating frames conditioned on its own earlier mistakes instead of on clean ground truth, and those mistakes compound.

A large academic and industry consortium spanning nine institutions across Hong Kong, Shenzhen, Singapore, Los Angeles, and Microsoft Research Asia just published a system called SolarWM that was also trained exclusively on five-second clips. The claim is that it holds together for rollouts running from minutes to hours anyway. That's a strange enough claim to be worth checking, and the paper's actual answer to "how" turns out to be less about scale and more about a specific, fixable mismatch in how these models are usually trained.

Who actually built this

The paper, titled "SolarWM: Open Data and Scalable Training for Long-Horizon Video World Models," went up on arXiv on September 2, 2026, with code, the full dataset, and model weights following the next day. Eighteen authors are credited, led by Junchao Huang, spanning the Chinese University of Hong Kong, Shenzhen (CUHK-SZ), the Shenzhen Loop Area Institute (SLAI), the National University of Singapore, CUHK's Hong Kong campus, HKUST and its Guangzhou campus, NVIDIA, UCLA, and Microsoft Research Asia. Li Jiang, a professor at CUHK-SZ's School of Data Science working on 3D scene understanding, and Mike Zheng Shou, who runs NUS's Show Lab and has a long publication history in video generation and understanding, are the two most senior names on the author list. It's a genuinely large, credible, multi-institution research effort, not a lone GitHub project dressed up with a slick landing page, and it's worth being precise about that given how easy it is for a project-page URL alone to look like either.

One name worth clearing up before it causes confusion: this is not the same thing as Meta FAIR's CWM, a 32-billion-parameter open-weights model released in September 2025 that also uses "world model" in its framing but is built for predicting the outcome of running code, not for generating interactive video. It's also a different project from the Code World Model out of Westlake University's AGI Lab [check_internal_link], which does work on interactive video but takes a completely different approach, more on that below. Three unrelated projects, two of them sharing a near-identical name, all published within about a year of each other. Worth double-checking which one a given headline is actually about.

The actual fix, and why five seconds turns out to be enough

The standard way to train a video model that predicts the next frame from the frames before it is called teacher forcing: during training, the model always sees real, correct history, because you have the ground-truth video sitting right there. The problem shows up at inference time, when there's no more ground truth. The model has to condition on the frames it just generated itself, and if any of those frames were slightly wrong, the model is now extending a mistake rather than correcting one. Researchers call this exposure bias, and it's the actual mechanical reason a five-second training clip doesn't automatically buy you a five-minute usable rollout: the model was never once shown its own errors during training, so it never learned what to do about them.

SolarWM's three-stage recipe is built specifically around closing that gap, and it's clean enough to explain without hand-waving. Stage0.5, which the team calls Bid-Cam, takes an existing off-the-shelf bidirectional video model (one that sees a whole clip at once rather than frame by frame) and teaches it to also condition on camera trajectory, text, and other control signals, while keeping its full, unrestricted view of the clip. Stage1, TF-AnyFlow, is still teacher-forced, but adds what the paper calls an AnyFlow loss, training the model to denoise a frame in a flexible, small number of steps rather than the several dozen a typical diffusion model needs, which is the groundwork for actually running the thing fast later. Stage2, called SGF, for self-gradient forcing, is where the exposure-bias fix actually happens. A frozen copy of the bidirectional teacher model stands in for "what real video distributions look like." A second, trainable model, the "fake-distribution" critic, is continuously updated to track whatever the student model's own generated rollouts currently look like, drift and all. The student is then trained to make its own output match the frozen teacher's distribution, using the critic as the yardstick for how far off it currently is. This is a version of distribution matching distillation, a technique with roots in fast image-diffusion distillation, adapted here to a sequential rollout setting. The practical effect is that the model is trained against its own accumulating errors instead of only ever against pristine history, which is precisely the thing Stage1 alone can't do.

The project page labels its lead demo "Generated by the SolarWM-Wan-5B Causal Student (4 steps)," which is the concrete payoff of that AnyFlow work: the deployed model generates each frame in roughly four denoising steps instead of dozens, which is where the "real-time" half of "real-time interactive" actually comes from. It's a genuinely elegant piece of engineering, training-time fix for an inference-time problem, and it's the part of this release I'd flag as the most technically interesting, independent of whatever else the paper is trying to sell.

What it actually is: infrastructure first, model second

Here's the framing worth sitting with, because it changes what kind of release this actually is. SolarWM isn't proposing one new architecture. It's a shared data engine and training recipe applied to four existing video backbones: Wan2.2 at 5B and 14B parameters, LTX-2.5 at 22B, and MiniMax-H3 at 33B. The paper's own comparison, Table 1, isn't a quality benchmark against Genie or Oasis at all. It's an openness scorecard, checking off whether each system in the field ships public weights, inference code, training code, raw data, and a fully documented recipe, against prior interactive-world work like Genie, GameNGen, DIAMOND, MineWorld, and the Matrix-Game series. SolarWM checks every box. That's a deliberate choice of what to compete on, and it's the same reading an outside writeup landed on independently: the infrastructure, not any single model, is arguably the actual contribution here.

The dataset backing that claim is the 1.43 million canonical clips, roughly 25 terabytes, that the project page advertises. Those clips come from ten named source datasets, ABOT-World, DL3DV, MiraData, RealCam, SpatialVID, Sekai-Game and Sekai-Walking, MIND, MultiCamVideo, and OmniWorld, unified into one frame-aligned format with camera geometry, captions, and quality metadata attached to every clip. One outside summary flagged an apparent contradiction, the abstract says ten datasets while the README says fourteen, as worth double-checking. It resolves cleanly: ten are the actual source datasets, but three of them get split at the "owner" level (DL3DV divides into a 10-second and a 60-second temporal variant, and three additional clean-plate derivatives come off MiraData, Sekai-Walking, and SpatialVID), which yields fourteen processing partitions from the same ten underlying sources. Not a red flag, just a detail worth actually reading rather than flagging on sight, which is exactly the kind of methodology-section check this beat rewards doing.

What "interactive" means here, honestly

It's worth being precise about this, because the word does real work in the paper's title. SolarWM's models take camera motion, player-style action tokens, and semantic text instructions as conditioning inputs during generation, which is what makes the rollouts steerable rather than fixed clips. What I could not find, after checking the project page, the GitHub repo, and the Hugging Face collection, is a public, playable, browser-based demo where a reader could actually grab a keyboard and steer a live session, the way Oasis or Runway's GWM Worlds 2 [check_internal_link] offer. This is a code-and-weights research release: the interactivity is real in the sense that the model architecture supports it and the released checkpoints will respond to control signals if you run them yourself, but there's no hosted experience to click into today, and no published fps or latency numbers accompanying the "real-time" claim. That's a meaningfully different bar than a company shipping a live demo alongside a press cycle, and readers should weigh the claim accordingly.

The project page's own per-backbone comparison section, four different base architectures running the same camera-and-text control interface.

Where this sits next to the field's other fixes

Every serious attempt at long-horizon interactive world models right now is solving the same drift problem from a different angle. Google DeepMind's Genie 3 holds together for "several minutes" at 720p and 24fps but remains a closed research preview with no public weights and documented physics glitches on longer sessions. Runway's GWM Worlds 2 [check_internal_link] removes the fixed session-length ceiling entirely and adds native synchronized audio, but its own limitations section admits "imperfect" long-term memory in its real-time mode, the same underlying symptom. Westlake's Code World Model [check_internal_link] takes the most structurally different route of the group: it doesn't try to fix the video model's memory at all, it hands state-tracking to a separate coding agent writing actual deterministic code, and only asks the video model to render whatever that code says is true. SolarWM's fix sits at the opposite end of that spectrum from CWM: no external symbolic ledger, no second reasoning system, just a training-time correction that teaches the video model itself to stop trusting its own drifting output. Both are legitimate answers to the same well-documented problem. Neither has been tested against the other under matched conditions, and neither has been benchmarked head-to-head against Genie 3 or Oasis by anyone outside the team that built it.

The caveat that actually matters here

The headline claim, hour-scale rollouts from five-second training, is currently only fully demonstrated on the smallest model in the family. Checking the Hugging Face collection directly: the 5B Wan2.2 variant is the only one with all three training stages released and available to run end to end. The 14B Wan2.2, the 22B LTX-2.5, and the 33B MiniMax-H3 checkpoints each ship with only Stage0.5, the camera-conditioning stage, publicly available; the repository marks their Stage1 and Stage2 releases as "coming soon." That means the specific, most impressive part of the paper's claim, the distillation stage that actually fixes exposure bias and unlocks long, stable rollouts, is proven on one 5-billion-parameter model today, not on the three larger and presumably more capable ones the paper also announces. It's an honest, clearly labeled partial rollout rather than a bait-and-switch, the README says exactly what's available and what isn't, but it's worth being clear that "SolarWM can do hour-scale rollouts" and "the fully open, largest version of SolarWM can do hour-scale rollouts" are not currently the same sentence.

The paper is also four days old as of this writing, sitting at 141 upvotes on its Hugging Face papers page, which measures attention, not correctness. The two independent writeups that exist so far, from CCTest and a smaller aggregator, both stick to summarizing the release rather than running or scrutinizing it, and CCTest says as much directly: proving stable object identity and physical consistency over long rollouts "require[s] the full paper, released checkpoints, and systematic evaluations," which haven't happened yet from anyone outside the author list. Everything in this piece describing SolarWM's rollout stability is the team's own reported result. That's not a reason to dismiss it. A three-stage recipe built specifically to address exposure bias, applied across four real architectures with full data provenance published alongside it, is a more falsifiable, more inspectable claim than most world-model announcements manage. It's just not yet a claim anyone but the people who made it has checked.

What makes SolarWM worth a dedicated piece rather than a line in someone else's roundup is that it's arguing for a different kind of progress than the rest of this field is currently chasing. Genie, GWM Worlds 2, and the assorted Minecraft clones are all racing to make one flashy demo hold together a little longer. SolarWM is betting that the actual bottleneck on the field is that nobody else can even attempt the experiment, because rebuilding a million-clip, camera-annotated training corpus from scratch prices most labs out before they get anywhere near testing a fix like self-gradient forcing. Publishing the data engine, the recipe, and the checkpoints, warts, partial releases, and all, is a bet that the next real improvement in long-horizon world models comes from someone else building on this rather than from SolarWM's own next paper. That's a more interesting kind of ambition than another highlight reel, and it's the one worth actually watching over the next few months, once someone outside CUHK-SZ has had a chance to run it.