Model reference · open weights

moworld

Video moworld1 · community Image→video 1 build Licence not stated 8k dl/mo

moworld is an open-weight video model from moworld1. moworld_base (BF16) weighs 59.2 GB; the smallest configuration that runs it is H100 80 GB.

What it is

Released bymoworld1
TypeVideo models
TaskImage→video
Released2026-09-20
Popularity8k downloads / month
Weights59.2 GB (moworld_base (BF16), file size)
LicenceLicence not stated

What it runs on

Memory and cards for moworld_base (BF16)

Weights 59.2 GB (file size) · overhead about 537 MB.

CardThe weightsCounted
memory
RTX 3060 12 GB … L40S 48 GBdoes not fit
A100 80 GBfits78.2 GB
H100 80 GBfits78.1 GB
RTX PRO 6000 Blackwell 96 GBfits93.8 GB
DGX Spark (GB10) 128 GB unifiedfits107 GB
H200 141 GBfits138 GB
B200 180 GBfits176 GB

Estimates, not measurements: the weights are the build's file size; a video's working memory grows with its resolution and length and is not estimated yet. diffusers can also place a pipeline's parts on separate cards (device_map) — not estimated here. Counted memory is 92 % of what CUDA reports for the card.

From the model card

What moworld1 says about moworld

MoWorld checkpoints for camera-controlled video generation, loaded through the project's custom PyTorch pipeline.

Read the full model card

Checkpoint layout

.
├── config.json
├── run_inference.py
├── high_noise_model.safetensors
├── low_noise_model.safetensors
├── high_noise_model/
│   └── config.json
├── low_noise_model/
│   └── config.json
├── configuration.json
├── Wan2.1_VAE.pth
├── models_t5_umt5-xxl-enc-bf16.pth
└── google/
    └── umt5-xxl/
        ├── special_tokens_map.json
        ├── spiece.model
        ├── tokenizer.json
        └── tokenizer_config.json

config.json is the checkpoint manifest used by run_inference.py: it maps each expert to its weight file and configuration. The launcher reads this manifest, validates the paths and configuration JSON, and sets TRAIN_HIGH_MODEL_PATH and TRAIN_LOW_MODEL_PATH before calling the MoWorld source launcher. It does not change the underlying architecture configuration lookup.

The two expert weights are at the repository root. Their configuration files remain in the corresponding expert directories.

⚙️ Quick Start

Prepare a Linux environment with Python 3.10+, PyTorch 2.7.1, and compatible CANN, torch_npu, and TorchAir packages; see the setup guide.

Code availability: As of September 21, 2026, the public GitHub repository contains only a README. The installation, inference, and training commands below require the full MoWorld source tree and its submodules. Model weights can be downloaded independently. The linked GitCode guides could not be verified during preparation of this model card.

Installation

Once the full source is available, clone the repository:

git clone --recursive https://github.com/Moxin-Tech/moworld1.0.git
cd moworld1.0
export MOWORLD_ROOT="$PWD"

Install dependencies in your Ascend environment:

python -m pip install -e ./MindSpeed
git clone --branch core_v0.12.1 https://github.com/NVIDIA/Megatron-LM.git ../Megatron-LM
export PYTHONPATH="$(cd ../Megatron-LM && pwd):${PYTHONPATH:-}"
python -m pip install -e "./moworld[realtime]"

Download the model with the Hugging Face CLI:

python -m pip install -U huggingface_hub
export MOWORLD_WEIGHTS="$MOWORLD_ROOT/models/moworld"
hf download moworld1/moworld_1.0_checkpoint --local-dir "$MOWORLD_WEIGHTS"

To download the weights before the source code is available, choose an explicit local directory:

hf download moworld1/moworld_1.0_checkpoint --local-dir ./models/moworld

Prepare the base weights, T5, VAE, and tokenizer under models/base/ following the asset layout. This checkpoint repository includes models_t5_umt5-xxl-enc-bf16.pth, Wan2.1_VAE.pth, and google/umt5-xxl/; downloading them into MOWORLD_WEIGHTS does not automatically populate models/base/. Arrange these assets and any additional base checkpoints according to the source code's asset guide.

Run the commands below from moworld/:

export MODEL_PATH="$MOWORLD_ROOT/models/base"
export MINDSPEED_PATH="$MOWORLD_ROOT/MindSpeed"
cd "$MOWORLD_ROOT/moworld"

Inference

Run camera-controlled autoregressive generation on 16 NPUs with the matching four-step MoWorld weights:

IMAGE_PATH="examples/moworld/realtime_assets/test.png" \
SINGLE_PROMPT="A tranquil landscape viewed by a camera moving slowly forward." \
CAMERA_MOTION="In-3,Left-2,Right-2" \
OUTPUT_PATH="$MOWORLD_ROOT/outputs/realtime" \
python "$MOWORLD_WEIGHTS/run_inference.py" --moworld-root "$MOWORLD_ROOT"

The default launcher uses 15 DiT processes and one VAE worker. For parallelism settings, bidirectional inference, and DCP inference, see the inference guide.

The configuration paths are $MOWORLD_WEIGHTS/high_noise_model/config.json and $MOWORLD_WEIGHTS/low_noise_model/config.json. If your source version resolves a configuration relative to its weight file, update that lookup to these paths. End-to-end inference with this repository layout has not yet been verified.

Training

Prepare your feature data and examples/moworld/local_data/train_data.json using the data preparation guide. Convert compatible base checkpoints, then train the high- and low-noise experts:

bash examples/moworld/convert_weights.sh

export MM_DATA="$PWD/examples/moworld/local_data/train_data.json"
export TRAIN_ITERS=10 SAVE_INTERVAL=10
bash examples/moworld/pretrain_high.sh
bash examples/moworld/pretrain_low.sh

These are short pretraining runs on 16 NPUs. Checkpoints are saved under checkpoints/train/. See the training guide for configuration and the export instructions for safetensors conversion.

Deployment

An HTTP API or web UI requires a separate service layer. See deployment details.

Validate the downloaded checkpoint layout

python "$MOWORLD_WEIGHTS/run_inference.py" --check

This checks file paths and JSON syntax without loading weights or starting NPU inference. Download the full repository, including config.json and run_inference.py, using the command above.

Quoted from the model card on Hugging Face — the full card is behind the Hugging Face link above.

Running it yourself

Run it on a rented GPU

Rent a machine by the hour — ComfyUI is installed on it. Open ComfyUI through the tunnel and load the workflow from the model's card on Hugging Face; choose this model's file in its loader.

# on your rented machine (the ssh line is on its page in the console)
# get REPO FILE FOLDER: one file into /workspace/models/FOLDER, where ComfyUI loads it from
get() { hf download "$1" "$2" --local-dir /workspace/hf-files && mkdir -p "/workspace/models/$3" && mv "/workspace/hf-files/$2" "/workspace/models/$3/$4"; }

# the model (55.1 GB)
get moworld1/moworld_base high_noise_model.safetensors diffusion_models

start-comfyui
Renting a GPU — connect, tunnels, ComfyUI
# on your computer, in a second terminal: ComfyUI in your browser at http://localhost:8188
# HOST and PORT are your machine's, from its page in the console
ssh -L 8188:localhost:8188 dev@HOST -p PORT
© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms