world-grow/WorldGrow: Generate Infinite Explicit 3D Worlds from a Seed Block

world-grow/WorldGrow: Generate Infinite Explicit 3D Worlds from a Seed Block

Meta Description

WorldGrow generates infinite explicit 3D worlds via hierarchical block-wise synthesis. Explore installation, code examples, and use cases for this AAAI 2026 Oral research project.

Introduction

Procedural world generation has long been constrained by implicit representations—neural fields that look plausible from a distance but crumble under interaction. For robotics researchers, game developers, and simulation engineers, this creates a critical gap: you need 3D environments that are not just visually coherent but explicitly navigable, with real geometry you can walk through, plan paths across, and evaluate agents within.

world-grow/WorldGrow addresses this directly. As an AAAI 2026 Oral presentation, this open-source project introduces a hierarchical framework for infinite (open-ended) 3D world generation that produces explicit representations—Gaussian splats, meshes, and walkable geometry—starting from a single seed block. With 463 GitHub stars and active development through December 2025, WorldGrow represents a concrete step toward scalable, interactive world synthesis for researchers who need more than pretty pictures.

This article covers what WorldGrow actually does, how to run it, and where it fits in your technical stack.

What is world-grow/WorldGrow?

WorldGrow is a generative method for infinite explicit 3D world creation, developed by researchers at Shanghai Jiao Tong University, Huawei, and Huazhong University of Science and Technology. The project builds upon TRELLIS, Microsoft's open-source 3D generation framework, but extends it in a critical direction: scalability beyond single objects to expansive, coherent environments.

The core technical distinction is explicit representation. Where many neural world models use implicit fields (NeRF-style density networks), WorldGrow generates:

• 3D Gaussian Splatting (3DGS) point clouds (.ply)
• Textured meshes (.glb)
• Walkable scene geometry suitable for navigation and planning evaluation

The hierarchical generation process works in two stages: block-wise synthesis creates large-scale global layouts, then coarse-to-fine refinement adds local geometric and appearance detail. Starting from a single seed block, the system "grows" environments outward—hence the name.

As of the latest commit (2025-12-03), the project has released inference code and pretrained weights via Hugging Face, with full training pipelines planned. The repository has 463 stars and 26 forks—modest but growing traction for a research code release that only became fully runnable in November 2025.

Notably, the project launched an interactive 3DGS Gallery in December 2025, allowing browser-based exploration of generated scenes without local setup.

Key Features

Hierarchical block-wise world synthesis

WorldGrow generates environments through recursive block expansion rather than monolithic scene generation. This enables true open-ended growth—you specify a world_size in blocks (e.g., (3, 3) or (19, 39)), and the system synthesizes coherent transitions between adjacent regions. The coarse-to-fine pipeline ensures global layout consistency before local detail refinement.

Explicit multi-format output

The pipeline natively exports to three formats with a single inference pass:

• gaussian: 3D Gaussian Splatting point cloud (.ply) for real-time rendering
• mesh: Reconstructed textured mesh (.glb) for physics simulation and traditional graphics pipelines
• Rendered video sequences via imageio for qualitative evaluation

This dual representation is architecturally significant: Gaussian splats enable photorealistic novel-view synthesis, while meshes support collision detection, path planning, and physics-based interaction.

Walkable scene geometry

The generated outputs are explicitly designed for navigation and planning evaluation. This targets a concrete limitation of prior generative models: they produce visually impressive but functionally unusable environments. WorldGrow's scenes have traversable surfaces and coherent spatial structure.

Pretrained model availability

Weights are hosted on Hugging Face under the UranusITS/WorldGrow identifier, enabling immediate inference without training from scratch. The WorldGrowPipeline.from_pretrained() API follows Hugging Face conventions familiar to ML practitioners.

Modified sparse convolution backend

The repository includes customized cumm and spconv packages in submodules/, optimized for WorldGrow's specific workload. The setup.sh script handles installation of these modified dependencies—a necessary deviation from standard TRELLIS setup.

Use Cases

Robotics simulation and navigation research

WorldGrow's explicit, walkable outputs directly support embodied AI research. Researchers can generate diverse indoor environments for training and benchmarking navigation agents, with guaranteed traversable geometry. The 19×39 block example (~1,800 m²) demonstrates scalability sufficient for realistic indoor navigation tasks.

Procedural content generation for games

Game developers needing large, varied environments can use WorldGrow as a backend generator, importing .glb meshes into Unreal Engine, Unity, or custom engines. The block-wise structure maps naturally to streaming world systems where distant regions generate on-demand.

3D scene understanding benchmark creation

Computer vision researchers can synthesize unlimited training data with known ground-truth geometry, camera trajectories, and semantic layouts. Unlike captured datasets, generated worlds avoid privacy concerns and permit arbitrary scene complexity scaling.

Architecture and interior design prototyping

The coarse-to-fine generation enables rapid spatial layout exploration. Designers can generate multiple block-scale configurations, evaluate circulation patterns, and refine promising candidates—though current outputs lack semantic room labels for direct architectural workflow integration.

Gaussian splatting research infrastructure

For researchers working on 3DGS rendering improvements, WorldGrow provides a generator for large-scale test scenes beyond existing object-centric datasets. The .ply exports are compatible with standard Gaussian splatting viewers and renderers.

Installation & Setup

WorldGrow requires following TRELLIS's environment setup with critical modifications to sparse convolution packages.

Step 1: Clone with submodules

git clone --recurse-submodules https://github.com/world-grow/WorldGrow.git

The --recurse-submodules flag is required—the modified cumm and spconv packages live in submodules/ and will not be fetched otherwise.

Step 2: Environment setup

Follow TRELLIS installation instructions for base dependencies. WorldGrow inherits this environment configuration.

Step 3: Install modified sparse convolution packages

# Run the provided setup script for optimized installation
bash setup.sh

Critical warning from the authors: The original cumm and spconv packages are not suitable for WorldGrow's models. The setup.sh script installs the modified versions from submodules/ with necessary optimizations.

Step 4: Verify GPU availability

WorldGrow requires CUDA-capable hardware. The example script calls .cuda() on the pipeline without device selection logic—ensure CUDA_VISIBLE_DEVICES is set appropriately if you have multiple GPUs.

Step 5: (Optional) Configure attention backend

The code supports flash-attn (default) or xformers for attention computation. Set via environment variable before import:

import os
os.environ['ATTN_BACKEND'] = 'xformers'  # If flash-attn is unavailable

Real Code Examples

Basic world generation

The repository provides example_world_grow.py as the primary usage reference. Below is the complete example with explanatory comments:

import os
# os.environ['ATTN_BACKEND'] = 'xformers'   # Can be 'flash-attn' or 'xformers', default is 'flash-attn'
os.environ['SPCONV_ALGO'] = 'native'        # Can be 'native' or 'auto', default is 'auto'.
                                            # 'auto' is faster but will do benchmarking at the beginning.
                                            # Recommended to set to 'native' if run only once.

import imageio
from trellis.pipelines import WorldGrowPipeline
from trellis.utils import render_utils

# Load a pipeline from a model folder or a Hugging Face model hub.
pipeline = WorldGrowPipeline.from_pretrained("UranusITS/WorldGrow")
pipeline.cuda()

# Run the pipeline
world_size = (3, 3) # Specify the desired world size (in blocks)
outputs = pipeline.run(world_size=world_size)

# Render the outputs
r = 1.5 + max(world_size)
look_at = [0.25 * (world_size[0] - 1), 0.25 * (world_size[1] - 1), 0]
video = render_utils.render_video(outputs['gaussian'], r=r, look_at=look_at)['color']
imageio.mimsave("sample.mp4", video, fps=30)

outputs['mesh'].export("sample.glb")
outputs['gaussian'].save_ply("sample.ply")

What this does: After loading the pretrained weights from Hugging Face, the script generates a 3×3 block world, renders an orbital video, and exports both mesh and Gaussian splat representations. The r and look_at parameters center the camera on the generated region.

Key parameter: world_size controls generation scope. The (3, 3) example completes quickly; scaling to (19, 39) produces the ~1,800 m² demonstration scene but requires proportionally more memory and computation.

Performance-optimized inference (mesh exclusion)

For faster iteration when only Gaussian splats are needed:

# Modify the pipeline.run() call to exclude mesh generation
outputs = pipeline.run(world_size=world_size, formats=['gaussian'])
# This skips the mesh reconstruction branch, reducing inference time

This is not shown as a separate example in the README but is explicitly documented as a supported option: "You may also adjust formats=['gaussian'] to exclude mesh generation for faster inference."

Sparse convolution algorithm selection

The SPCONV_ALGO environment variable controls a meaningful performance trade-off:

os.environ['SPCONV_ALGO'] = 'auto'      # Faster for repeated runs; benchmarks on first invocation
os.environ['SPCONV_ALGO'] = 'native'    # Predictable latency; recommended for single generations

The README explicitly recommends 'native' for one-off runs to avoid benchmarking overhead.

Advanced Usage & Best Practices

Memory scaling with world size

The (19, 39) example represents a stress test, not a typical workload. Start with (3, 3) or (5, 5) to validate your environment before scaling. GPU memory constraints will bound maximum world size before compute time becomes the bottleneck.

Format selection for downstream pipelines

Choose outputs based on your consumer: Gaussian splats for [INTERNAL_LINK: neural-rendering-viewers] and real-time visualization; meshes for physics engines, traditional ray tracing, and collision detection. The .glb format includes textures; .ply stores Gaussian parameters (position, covariance, color, opacity).

Attention backend fallback

If flash-attn installation fails (common on older GPUs or non-standard CUDA versions), xformers provides a compatible alternative with minimal quality impact. The commented line in the example script exists for this purpose.

Submodule integrity

If you cloned without --recurse-submodules, sparse convolution operations will fail with cryptic errors. Re-clone or run git submodule update --init --recursive to recover.

Citation and community contribution

The authors explicitly request stars and citations for academic use. The BibTeX entry is provided in the repository for paper references.

Comparison with Alternatives

TRELLIS (the direct codebase ancestor) excels at single-object generation with text/image conditioning but does not address large-scale scene composition or navigability. WorldGrow's block-wise hierarchy is the architectural extension enabling environment-scale generation.

Traditional procedural content generation (Unreal PCG, Houdini) offers mature tooling and artist control but requires substantial manual rule authoring. WorldGrow trades some control for automation—valuable when you need diversity at scale without artist investment.

Neural implicit world models (not listed in table due to fundamental architectural differences) produce continuous representations but lack explicit geometry for direct physics simulation. WorldGrow's explicit outputs are the technical differentiator for embodied AI applications.

FAQ

Q: What hardware is required? A: CUDA-capable GPU. The .cuda() call implies NVIDIA hardware; VRAM requirements scale with world_size.

Q: Can I use this commercially? A: License is currently TBD ("to be finalized before full code release"). Check the repository for updates before production deployment.

Q: How does this differ from Minecraft world generation? A: WorldGrow generates explicit 3D geometry with neural rendering quality, not blocky voxels. Outputs are continuous surfaces suitable for photorealistic visualization.

Q: Is training code available? A: As of December 2025, only inference code and pretrained weights are released. Full training pipelines are planned.

Q: Why modified cumm/spconv? A: The original packages lack optimizations for WorldGrow's specific sparse convolution patterns. The authors provide compatible replacements.

Q: Can I generate outdoor environments? A: The README emphasizes indoor scenes; outdoor capability is not explicitly documented. The gallery may clarify this.

Q: How do I report issues or contribute? A: Use GitHub Issues on the world-grow/WorldGrow repository.

Conclusion

world-grow/WorldGrow occupies a specific and valuable niche: explicit 3D world generation at scale, with outputs that bridge neural rendering quality and practical utility for navigation and simulation. It is not yet a production tool—the TBD license, recent code release, and planned training pipelines mark it as active research software—but for researchers in embodied AI, procedural generation, and 3D scene understanding, it provides immediately usable infrastructure.

The project is best suited for:

• Researchers needing diverse, navigable 3D environments
• Developers prototyping Gaussian splatting applications at scene scale
• Teams evaluating generative methods against planning and navigation benchmarks

If your work intersects with any of these, clone the repository, run the example script, and explore the interactive gallery. Star the project if you find it useful, and cite the AAAI 2026 Oral paper in academic work.

Get started: https://github.com/world-grow/WorldGrow