Here we provide an efficient MindSpore implementation of OpenSora, an open-source project that aims to foster innovation, creativity, and inclusivity within the field of content creation.

This repository is built on the models and code released by HPC-AI Tech. We are grateful for their exceptional work and generous contribution to open source.

The following videos are generated based on MindSpore and Ascend Atlas 800T A2 machines.

Demo

Text-to-Video

16x256x720	16x640x360
Snow falling over multiple houses and trees on winter landscape against night sky. christmas festivity and celebration concept	Snow falling over multiple houses and trees on winter landscape against night sky. christmas festivity and celebration concept
Time-Lapse Milky Way above the Mountain	Time-Lapse Milky Way above the Mountain
Time Lapse of the rising sun over a tree in an open rural landscape, with clouds in the blue sky beautifully playing with the rays of light	A large orange octopus is seen resting on the bottom of the ocean floor, blending in with the sandy and rocky terrain. Its tentacles are spread out around its body, and its eyes are closed. The octopus is unaware of a king crab that is crawling towards it from behind a rock, its claws raised and ready to attack. The crab is brown and spiny, with long legs and antennae. The scene is captured from a wide angle, showing the vastness and depth of the ocean. The water is clear and blue, with rays of sunlight filtering through. The shot is sharp and crisp, with a high dynamic range. The octopus and the crab are in focus, while the background is slightly blurred, creating a depth of field effect.
This close-up shot of a Victoria crowned pigeon showcases its striking blue plumage and red chest. Its crest is made of delicate, lacy feathers, while its eye is a striking red color. The bird’s head is tilted slightly to the side, giving the impression of it looking regal and majestic. The background is blurred, drawing attention to the bird’s striking appearance.

Image-to-Video

Input	Output
a brown bear in the water with a fish in its mouth
a group of statues on the side of a building, camera pans right

Frame Interpolation

Start Frame	End Frame	Caption	Output
		A breathtaking sunrise scene.

Video Editing

Input	Output
a snowy forest

Text-to-Image

Caption	Output
Bright scene, aerial view,ancient city, fantasy, gorgeous light, mirror reflection, high detail, wide angle lens.
A small cactus with a happy face in the Sahara desert.

Demo

2s 512×512	2s 512×512	2s 512×512
A serene night scene in a forested area. [...] The video is a time-lapse, capturing the transition from day to night, with the lake and forest serving as a constant backdrop.	A soaring drone footage captures the majestic beauty of a coastal cliff, [...] The water gently laps at the rock base and the greenery that clings to the top of the cliff.	The majestic beauty of a waterfall cascading down a cliff into a serene lake. [...] The camera angle provides a bird's eye view of the waterfall.
A bustling city street at night, filled with the glow of car headlights and the ambient light of streetlights. [...]	The vibrant beauty of a sunflower field. The sunflowers are arranged in neat rows, creating a sense of order and symmetry. [...]	A serene underwater scene featuring a sea turtle swimming through a coral reef. The turtle, with its greenish-brown shell [...]

Videos are downsampled to .gif for display. Click for original videos. Prompts are trimmed for display, see here for full prompts.

• 📍 Open-Sora 2.0 released. Model weights are available here. See report 1.2 for more details.

  • ✅ New backbone that is based on Flux.
  • ✅ Uses reduced patch size of 1 for better training stability and finer details in video generation.
  • ✅ Employs full attention and 3D RoPE.
  • ✅ Uses Deep Compression Autoencoder (DC-AE) for increased spatial compression of 32x with an increased number of 128 latent channels.
  • ✅ Employs two text encoders: T5, which captures complex textual semantics, and CLIP-Large, which improves alignment between text and visual concepts.

• 📍 Open-Sora 1.2 released. Model weights are available here. See report 1.2 for more details.

  • ✅ Support rectified flow scheduling.
  • ✅ Support more conditioning including fps, aesthetic score, motion strength and camera motion.
  • ✅ Trained our 3D-VAE for temporal dimension compression.

• 📍 Open-Sora 1.1 with the following features

  • ✅ Improved ST-DiT architecture includes Rotary Position Embedding (RoPE), QK Normalization, longer text length, etc.
  • ✅ Support image and video conditioning and video editing, and thus support animating images, connecting videos, etc.
  • ✅ Support training with any resolution, aspect ratio, and duration.

• 📍 Open-Sora 1.0 with the following features

  • ✅ Text-to-video generation in 256x256 or 512x512 resolution and up to 64 frames.
  • ✅ Three-stage training: i) 16x256x256 video pretraining, ii) 16x512x512 video fine-tuning, and iii) 64x512x512 videos
  • ✅ Optimized training recipes for MindSpore+Ascend framework (see configs/opensora/train/xxx_ms.yaml)
  • ✅ Acceleration methods: flash attention, recompute (gradient checkpointing), data sink, mixed precision, and graph compilation.
  • ✅ Data parallelism + Optimizer parallelism, allow training on 300x512x512 videos

• Installation
• Model Weights
• Inference
• Data Processing
• Training
• Evaluation
• VAE Training & Evaluation
• Long sequence training and inference (sequence parallel)
• Contribution
• Acknowledgement

Other useful documents and links are listed below.

• Repo structure: structure.md

1. Please install MindSpore 2.7.0 according to the MindSpore official website and install CANN 8.1.RC1 as recommended by the official installation website.

2. Install requirements

cd examples/opensora_hpcai
pip install -r requirements.txt

In case decord package is not available, try pip install eva-decord. For EulerOS, instructions on ffmpeg and decord installation are as follows.

1. install ffmpeg 4, referring to https://ffmpeg.org/releases
    wget https://ffmpeg.org/releases/ffmpeg-4.0.1.tar.bz2 --no-check-certificate
    tar -xvf ffmpeg-4.0.1.tar.bz2
    mv ffmpeg-4.0.1 ffmpeg
    cd ffmpeg
    ./configure --enable-shared         # --enable-shared is needed for sharing libavcodec with decord
    make -j 64
    make install
2. install decord, referring to https://github.com/dmlc/decord?tab=readme-ov-file#install-from-source
    git clone --recursive https://github.com/dmlc/decord
    cd decord
    rm build && mkdir build && cd build
    cmake .. -DUSE_CUDA=0 -DCMAKE_BUILD_TYPE=Release
    make -j 64
    make install
    cd ../python
    python3 setup.py install --user

You can download the above models automatically using the following command:

python tools/download_convert_st.py "hpcai-tech/Open-Sora-v2"

If you encounter a certificate verify failed error, you can set --disable_ssl_verify to True.

python tools/convert_pt2ms.py --src /path/to/OpenSora-STDiT-v3/model.safetensors --target models/opensora_stdit_v3.ckpt

python tools/convert_vae_3d.py --src /path/to/OpenSora-VAE-v1.2/model.safetensors --target models/OpenSora-VAE-v1.2/model.ckpt

python tools/convert_pt2ms.py --src /path/to/OpenSora-STDiT-v2-stage3/model.safetensors --target models/opensora_v1.1_stage3.ckpt

First, you will need to generate text embeddings with:

# CLIP-Large
TRANSFORMERS_OFFLINE=1 python scripts/v2.0/text_embedding.py \
--model.from_pretrained="DeepFloyd/t5-v1_1-xxl" \
--model.max_length=512 \
--prompts_file=YOUR_PROMPTS.txt \
--output_path=assets/texts/t5_512
# T5
TRANSFORMERS_OFFLINE=1 python scripts/v2.0/text_embedding.py \
--model.from_pretrained="openai/clip-vit-large-patch14" \
--model.max_length=77 \
--prompts_file=YOUR_PROMPTS.txt \
--output_path=assets/texts/clip_77

Repeat the same for negative prompts.

Then, you can generate videos by running the following command:

python scripts/v2.0/inference_v2.py --config=configs/opensora-v2-0/inference/256px.yaml \
text_emb.t5_dir=assets/texts/t5_512 \
text_emb.neg_t5_dir=assets/texts/t5_512_neg \
text_emb.clip_dir=assets/texts/clip_77 \
text_emb.neg_clip_dir=assets/texts/clip_77_neg

We evaluate the inference performance of text-to-video generation by measuring the average sampling time per step and the total sampling time of a video.

Experiments are conducted on Ascend Atlas 800T A2 machines with MindSpore >=2.6.0 in PyNative mode.

# OSv1.2
python scripts/inference.py --config configs/opensora-v1-2/inference/sample_iv2v.yaml --ckpt_path /path/to/your/opensora-v1-2.ckpt
# OSv1.1
python scripts/inference.py --config configs/opensora-v1-1/inference/sample_iv2v.yaml --ckpt_path /path/to/your/opensora-v1-1.ckpt

python scripts/inference.py --config configs/opensora-v1-1/inference/sample_t2v.yaml --ckpt_path /path/to/your/opensora-v1-1.ckpt

# Sample 16x256x256 videos
python scripts/inference.py --config configs/opensora/inference/stdit_256x256x16.yaml --ckpt_path models/OpenSora-v1-HQ-16x256x256.ckpt --prompt_path /path/to/prompt.txt

# Sample 16x512x512 videos
python scripts/inference.py --config configs/opensora/inference/stdit_512x512x16.yaml --ckpt_path models/OpenSora-v1-HQ-16x512x512.ckpt --prompt_path /path/to/prompt.txt

# Sample 64x512x512 videos
python scripts/inference.py --config configs/opensora/inference/stdit_512x512x64.yaml --ckpt_path /path/to/your/opensora-v1.ckpt --prompt_path /path/to/prompt.txt

⚠️ Note: When running parallel inference scripts under scripts/run/ on ModelArts, please unset RANK_TABLE_FILE before the inference starts.

Currently, we are developing the complete pipeline for data processing from raw videos to high-quality text-video pairs. We provide the data processing tools as follows.

.
├── video_caption.csv
├── video_folder
│   ├── part01
│   │   ├── vid001.mp4
│   │   ├── vid002.mp4
│   │   └── ...
│   └── part02
│       ├── vid001.mp4
│       ├── vid002.mp4
│       └── ...

video,caption
video_folder/part01/vid001.mp4,a cartoon character is walking through
video_folder/part01/vid002.mp4,a red and white ball with an angry look on its face

python scripts/infer_t5.py \
    --csv_path /path/to/video_caption.csv \
    --output_path /path/to/text_embed_folder \
    --model_max_length 300     # 300 for OpenSora v1.2, 200 for OpenSora v1.1, 120 for OpenSora 1.0

python scripts/infer_vae.py \
    --csv_path /path/to/video_caption.csv  \
    --video_folder /path/to/video_folder  \
    --output_path /path/to/video_embed_folder  \
    --vae_checkpoint models/sd-vae-ft-ema.ckpt \
    --image_size 512 \

.
├── video_caption.csv
├── video_folder
│   ├── part01
│   │   ├── vid001.mp4
│   │   ├── vid002.mp4
│   │   └── ...
│   └── part02
│       ├── vid001.mp4
│       ├── vid002.mp4
│       └── ...
├── text_embed_folder
│   ├── part01
│   │   ├── vid001.npz
│   │   ├── vid002.npz
│   │   └── ...
│   └── part02
│       ├── vid001.npz
│       ├── vid002.npz
│       └── ...
├── video_embed_folder  # optional
│   ├── part01
│   │   ├── vid001.npz
│   │   ├── vid002.npz
│   │   └── ...
│   └── part02
│       ├── vid001.npz
│       ├── vid002.npz
│       └── ...

video_embed_folder
   ├── latent_576x1024
   │   ├── vid001.npz
   │   ├── vid002.npz
   │   └── ...
   └── latent_1024x576
       ├── vid001.npz
       ├── vid002.npz
       └── ...

Once you prepare the data in a csv file, you may run the following commands to launch training on a single card.

# standalone training for stage 2
export MS_DEV_ENABLE_KERNEL_PACKET=on

python scripts/train.py --config configs/opensora-v1-2 /train/train_stage2.yaml \
    --csv_path /path/to/video_caption.csv \
    --video_folder /path/to/video_folder \
    --text_embed_folder /path/to/text_embed_folder \

text_embed_folder is required and used to speed up the training. You can find the instructions on how to generate T5 embeddings here.

For parallel training, use msrun and along with --use_parallel=True:

# distributed training for stage 2
export MS_DEV_ENABLE_KERNEL_PACKET=on

msrun --worker_num=8 --local_worker_num=8 --log_dir=$output_dir  \
    python scripts/train.py --config configs/opensora-v1-2/train/train_stage2.yaml \
    --csv_path /path/to/video_caption.csv \
    --video_folder /path/to/video_folder \
    --text_embed_folder /path/to/text_embed_folder \
    --use_parallel True

You can modify the training configuration, including hyper-parameters and data settings, in the yaml file specified by the --config argument.

OpenSora v1.2 supports training with multiple resolutions, aspect ratios, and frames based on the bucket method.

To enable dynamic training for STDiT3, please set the bucket_config to fit your datasets and tasks at first. An example (from configs/opensora-v1-2/train/train_stage2.yaml) is

bucket_config:
  # Structure: "resolution": { num_frames: [ keep_prob, batch_size ] }
  "144p": { 1: [ 1.0, 475 ], 51: [ 1.0, 51 ], 102: [ [ 1.0, 0.33 ], 27 ], 204: [ [ 1.0, 0.1 ], 13 ], 408: [ [ 1.0, 0.1 ], 6 ] }
  "256": { 1: [ 0.4, 297 ], 51: [ 0.5, 20 ], 102: [ [ 0.5, 0.33 ], 10 ], 204: [ [ 0.5, 1.0 ], 5 ], 408: [ [ 0.5, 1.0 ], 2 ] }
  "240p": { 1: [ 0.3, 297 ], 51: [ 0.4, 20 ], 102: [ [ 0.4, 0.33 ], 10 ], 204: [ [ 0.4, 1.0 ], 5 ], 408: [ [ 0.4, 1.0 ], 2 ] }
  "360p": { 1: [ 0.5, 141 ], 51: [ 0.15, 8 ], 102: [ [ 0.3, 0.5 ], 4 ], 204: [ [ 0.3, 1.0 ], 2 ], 408: [ [ 0.5, 0.5 ], 1 ] }
  "512": { 1: [ 0.4, 141 ], 51: [ 0.15, 8 ], 102: [ [ 0.2, 0.4 ], 4 ], 204: [ [ 0.2, 1.0 ], 2 ], 408: [ [ 0.4, 0.5 ], 1 ] }
  "480p": { 1: [ 0.5, 89 ], 51: [ 0.2, 5 ], 102: [ 0.2, 2 ], 204: [ 0.1, 1 ] }
  "720p": { 1: [ 0.1, 36 ], 51: [ 0.03, 1 ] }
  "1024": { 1: [ 0.1, 36 ], 51: [ 0.02, 1 ] }
  "1080p": { 1: [ 0.01, 5 ] }
  "2048": { 1: [ 0.01, 5 ] }

Knowing that the optimal bucket config can varies from device to device, we have tuned and provided bucket config that are more balanced on Ascend + MindSpore in configs/opensora-v1-2/train/{stage}_ms.yaml. You may use them for better training performance.

More details on the bucket configuration can be found in Multi-resolution Training with Buckets.

The instruction for launching the dynamic training task is smilar to the previous section. An example running script is scripts/run/run_train_os1.2_stage2.sh.

# standalone training for stage 1
python scripts/train.py --config configs/opensora-v1-1/train/train_stage1.yaml \
    --csv_path /path/to/video_caption.csv \
    --video_folder /path/to/video_folder \
    --text_embed_folder /path/to/text_embed_folder \
    --vae_latent_folder /path/to/video_embed_folder

# distributed training for stage 1
msrun --master_port=8200 --worker_num=8 --local_worker_num=8 --log_dir=$output_dir  \
    python scripts/train.py --config configs/opensora-v1-1/train/train_stage1.yaml \
    --csv_path /path/to/video_caption.csv \
    --video_folder /path/to/video_folder \
    --text_embed_folder /path/to/text_embed_folder \
    --vae_latent_folder /path/to/video_embed_folder \
    --use_parallel True

# standalone training, 16x256x256
python scripts/train.py --config configs/opensora/train/stdit_256x256x16_ms.yaml \
    --csv_path /path/to/video_caption.csv \
    --video_folder /path/to/video_folder \
    --text_embed_folder /path/to/text_embed_folder \

# 8 NPUs, 64x512x512
msrun --master_port=8200 --worker_num=8 --local_worker_num=8 --log_dir=$output_dir  \
    python scripts/train.py --config configs/opensora/train/stdit_512x512x64_ms.yaml \
    --csv_path /path/to/video_caption.csv \
    --video_folder /path/to/video_folder \
    --text_embed_folder /path/to/text_embed_folder \
    --use_parallel True \

To train in bfloat16 precision, please parse --global_bf16=True

For more usage, please check python scripts/train.py -h. You may also see the example shell scripts in scripts/run for quick reference.

Open-Sora 1.2 based on MindSpore and Ascend Atlas 800T A2 machines supports 0s~16s, 144p to 720p, various aspect ratios video generation. The supported configurations are listed below.

Here ✅ means that the data is seen during training, and 🆗 means although not trained, the model can inference at that config. Inference for 🆗 requires sequence parallelism.

We evaluate the training performance of Open-Sora v1.2 on the MixKit dataset with high-resolution videos (1080P, duration 12s to 100s).

All experiments are tested on Ascend Atlas 800T A2 machines with mindspore 2.7.0 graph mode.

Note that the step time of dynamic training can be influenced by the resolution and duration distribution of the source videos.

To reproduce the above performance, you may refer to scripts/run/run_train_os1.2_720x1280x51.sh and scripts/run/run_train_os1.2_stage2.sh.

Below are some generation results after fine-tuning STDiT3 with Stage 2 bucket config on a mixkit subset, which contains 100 text-video pairs. The training set contains 80 1080P videos consisting of natural scenes, flowers, and pets. Here we show the text-to-video generation results on the test set.

A 3D-VAE pipeline consisting of a spatial VAE followed by a temporal VAE is trained in OpenSora v1.1. For more details, refer to VAE Documentation.

• Download pretained VAE-2D checkpoint from PixArt-alpha/pixart_sigma_sdxlvae_T5_diffusers if you aim to train VAE-3D from spatial VAE initialization.

  Convert to ms checkpoint:

  python tools/convert_vae1.2.py --src /path/to/pixart_sigma_sdxlvae_T5_diffusers/vae/diffusion_pytorch_model.safetensors --target models/sdxl_vae.ckpt --from_vae2d
  

• Downalod pretrained VAE-3D checkpoint from hpcai-tech/OpenSora-VAE-v1.2 if you aim to train VAEA-3D from the VAE-3D model pre-trained with 3 stages.

  Convert to ms checkpoint:

  python tools/convert_vae1.2.py --src /path/OpenSora-VAE-v1.2/models.safetensors --target models/OpenSora-VAE-v1.2/sdxl_vae.ckpt
  

• Download lpips mindspore checkpoint from here and put it under 'models/'

Before VAE-3D training, we need to prepare a csv annotation file for the training videos. The csv file list the path to each video related to the root video_folder. An example is

video
dance/vid001.mp4
dance/vid002.mp4
...

Taking UCF-101 for example, please download the UCF-101 dataset and extract it to datasets/UCF-101 folder. You can generate the csv annotation by running python tools/annotate_vae_ucf101.py. It will result in two csv files, datasets/ucf101_train.csv and datasets/ucf101_test.csv, for training and testing respectively.

# stage 1 training, 8 NPUs
msrun --worker_num=8 --local_work_num=8 \
python scripts/train_vae.py --config configs/vae/train/stage1.yaml --use_parallel=True --csv_path datasets/ucf101_train.csv --video_folder datasets/UCF-101

# stage 2 training, 8 NPUs
msrun --worker_num=8 --local_work_num=8 \
python scripts/train_vae.py --config configs/vae/train/stage2.yaml --use_parallel=True --csv_path datasets/ucf101_train.csv --video_folder datasets/UCF-101

# stage 3 training, 8 NPUs
msrun --worker_num=8 --local_work_num=8 \
python scripts/train_vae.py --config configs/vae/train/stage3.yaml --use_parallel=True --csv_path datasets/ucf101_train.csv --video_folder datasets/UCF-101

You can change the csv_path and video_folder to train on your own data.

To evaluate the VAE performance, you need to run VAE inference first to generate the videos, then calculate scores on the generated videos:

# video generation and evaluation
python scripts/inference_vae.py --ckpt_path /path/to/you_vae_ckpt --image_size 256 --num_frames=17 --csv_path datasets/ucf101_test.csv --video_folder datasets/UCF-101

You can change the csv_path and video_folder to evaluate on your own data.

Here, we report the training performance and evaluation results on the UCF-101 dataset.

All experiments are tested on Ascend Atlas 800T A2 machines with mindspore 2.3.1 graph mode.

Note that we train with mixed video ang image strategy i.e. --mixed_strategy=mixed_video_image for stage 3 instead of random number of frames (mixed_video_random). Random frame training will be supported in the future.

We support training with the OpenSora v1.2 model using SP (Sequence Parallel) and DSP (Dynamic Sequence Parallel), handling up to 408 frames (~16 seconds) on 4 NPU* cards. Additionally, we have optimized the training speed by implementing micro-batch parallelism in the VAE’s spatial and temporal domains, achieving approximately a 20% speed boost. We evaluate the training performance using the MixKit dataset, which includes high-resolution videos (1080P, duration 12s to 100s). The training performance results are reported below.

All experiments are tested on Ascend Atlas 800T A2 machines with mindspore 2.4.0 graph mode.

To prevent the system from running out of memory, ensure you launch the training job on a server with sufficient memory. For 4P training, at least 400GB of memory is required.

We evaluate the inference performance of text-to-video generation by measuring the average sampling time per step and the total sampling time of a video.

All experiments are tested on Ascend Atlas 800T A2 machines with mindspore 2.4.0 graph mode.

python script/infer_vae.py \
    --csv_path /path/to/video_caption.csv  \
    --video_folder /path/to/video_folder  \
    --output_path /path/to/video_embed_folder  \
    --vae_checkpoint models/sd-vae-ft-ema.ckpt \
    --image_size 512 \
    --resize_by_max_value True \
    --vae-micro-batch-size 1
    --mode 1

msrun --worker_num=8 --local_worker_num=8  \
    scripts/train.py --config configs/opensora-v1-1/train/train_stage1_fit.yaml \
    --csv_path /path/to/video_caption.csv \
    --video_folder /path/to/video_folder \
    --text_embed_folder /path/to/text_embed_folder \
    --vae_latent_folder /path/to/video_embed_folder \
    --use_parallel True \
    --max_image_size 512 \

python scripts/inference_i2v.py --config configs/opensora-v1-1/inference/t2v_fit.yaml \
    --ckpt_path /path/to/your/opensora-v1-1.ckpt \
    --prompt_path /path/to/prompt.txt \
    --image_size 384 672 \
    --max_image_size 512 \

Thanks go to the support from the MindSpore team and the open-source contributions from the OpenSora project.

If you wish to contribute to this project, you can refer to the Contribution Guideline.

• ColossalAI: A powerful large model parallel acceleration and optimization system.
• DiT: Scalable Diffusion Models with Transformers.
• OpenDiT: An acceleration for DiT training. We adopt valuable acceleration strategies for training progress from OpenDiT.
• PixArt: An open-source DiT-based text-to-image model.
• Flux: A powerful text-to-image generation model.
• Latte: An attempt to efficiently train DiT for video.
• HunyuanVideo: Open-Source text-to-video model.
• StabilityAI VAE: A powerful image VAE model.
• DC-AE: Deep Compression AutoEncoder for image compression.
• CLIP: A powerful text-image embedding model.
• T5: A powerful text encoder.
• LLaVA: A powerful image captioning model based on Mistral-7B and Yi-34B.
• PLLaVA: A powerful video captioning model.
• DSP: Dynamic Sequence Parallel introduced by NUS HPC AI Lab.
• MiraData: A large-scale video dataset with long durations and structured caption.

@article{opensora,
  title={Open-sora: Democratizing efficient video production for all},
  author={Zheng, Zangwei and Peng, Xiangyu and Yang, Tianji and Shen, Chenhui and Li, Shenggui and Liu, Hongxin and Zhou, Yukun and Li, Tianyi and You, Yang},
  journal={arXiv preprint arXiv:2412.20404},
  year={2024}
}

@article{opensora2,
    title={Open-Sora 2.0: Training a Commercial-Level Video Generation Model in $200k},
    author={Xiangyu Peng and Zangwei Zheng and Chenhui Shen and Tom Young and Xinying Guo and Binluo Wang and Hang Xu and Hongxin Liu and Mingyan Jiang and Wenjun Li and Yuhui Wang and Anbang Ye and Gang Ren and Qianran Ma and Wanying Liang and Xiang Lian and Xiwen Wu and Yuting Zhong and Zhuangyan Li and Chaoyu Gong and Guojun Lei and Leijun Cheng and Limin Zhang and Minghao Li and Ruijie Zhang and Silan Hu and Shijie Huang and Xiaokang Wang and Yuanheng Zhao and Yuqi Wang and Ziang Wei and Yang You},
    year={2025},
    journal={arXiv preprint arXiv:2503.09642},
}

We are grateful for their exceptional work and generous contribution to open source.