WorldGrow

The Problem

Training or deploying an infinite‑world generator requires a tightly coupled stack of sparse‑tensor modules, custom data pipelines, and hierarchical renderers. Most open‑source 3D generators stop at bounded scenes, forcing downstream teams to stitch together their own growth logic.

What This Does

WorldGrow implements a full “seed‑to‑world” pipeline built on the TRELLIS sparse‑tensor framework.

• Core model code lives in trellis/models/ – e.g. sparse_structure_flow.py and sparse_structure_vae.py define the flow‑matching and VAE back‑ends.
• Data handling is in trellis/datasets/ (components.py, sparse_structure_latent.py, …) and prepares block‑wise tensors for training and inference.
• The hierarchical representation hierarchy (trellis/representations/gaussian/, octree/, mesh/) supplies per‑block geometry and radiance fields.
• Rendering utilities (trellis/renderers/) turn latent tensors into meshes or point clouds for visualization.

The repository ships an example driver example_world_grow.py that loads pretrained weights from Hugging Face and runs a single generation pass.

How It Is Wired

Execution starts at the entry point trellis/pipelines/world_grow.py:run (line 411). run constructs a WorldGrowPipeline object, loads a pretrained checkpoint, and calls snapshot.

• snapshot creates an output directory (os.makedirs) – the only direct filesystem write detected.
• The pipeline then iterates over blocks, invoking forward on the selected model (sparse_structure_flow.py or sparse_structure_vae.py). The internal call graph shows forward → type (23 calls) and forward → reshape (12 calls), indicating heavy tensor reshaping throughout the model.
• Visualization passes (visualize_sample) call cuda (19 calls) and float (11 calls) to move tensors onto the GPU and convert them for rendering.
• Rendering is delegated to trellis/renderers/gaussian_render.py and mesh_renderer.py, which ultimately call torch.save‑style utilities (not shown here) to produce mesh files.

The most connected modules are:

trellis/modules/sparse/__init__ acts as a hub; any change there ripples through 16 other modules. The import graph contains 19 circular dependencies (e.g., `modules/sparse/__init__.py ↔ modules/sparse/basic.py ↔ modules/attention/__init__.py). Breaking these cycles—by extracting shared types into a dedicated utils module or deferring imports—will reduce coupling and simplify future extensions.

Control flow is often deep: trellis/trainers/basic.py and the attention modules reach 7 levels of nesting, making reasoning about early‑exit conditions difficult. High branching density (118 branches in 379 lines) further concentrates logic in a few files.

How To Use It

# Clone with submodules (required for the custom spconv/cumm forks)
git clone --recurse-submodules https://github.com/moses-y/WorldGrow.git
cd WorldGrow

# Install the modified TRELLIS dependencies
bash setup.sh

The repository does not contain a requirements.txt or pyproject.toml; setup.sh installs the necessary Python packages and builds the custom spconv/cumm wheels.

To run the demo:

python example_world_grow.py

The script sets environment variables (ATTN_BACKEND, SPCONV_ALGO) before importing the pipeline, matching the README instructions. No additional configuration files are present.

Real‑World Use

A robotics team can embed WorldGrow as a data‑augmentation service. A nightly job calls python -m trellis.pipelines.world_grow run --output /tmp/worlds, producing a new walkable scene that is immediately fed to a navigation stack. The generated mesh can be streamed to a simulator via trellis/renderers/mesh_renderer.py.

Code Health & Issues

• HIGH – Missing LICENSE – No license file at the repository root; legal reuse is undefined.
• HIGH – No test suite – 94 source files but zero test files; regressions cannot be automatically detected.
• HIGH – No CI pipeline – No .github/workflows/ or other CI config; builds and tests are never gated.
• HIGH – Import cycles – 19 circular dependencies (e.g., trellis/modules/sparse/__init__.py). Break cycles to improve modularity.
• HIGH – Duplicated code blocks – 540 six‑line repetitions across 46 __init__.py files; extract shared helpers.
• MEDIUM – Broad exception handling – Bare except: clauses in basic.py, pipelines/base.py, renderers/gaussian_render.py. Replace with specific catches.
• MEDIUM – Deep nesting – Up to 7 indentation levels in trainers/basic.py and attention modules; refactor into smaller functions.
• MEDIUM – File open without context manager – datasets/sparse_structure_latent.py and datasets/structured_latent.py use open() directly; wrap in with.

The Bottom Line

WorldGrow delivers a complete infinite‑world generation pipeline with well‑structured model and rendering code, but the current codebase suffers from high coupling, deep nesting, and a lack of automated testing or licensing. It is suitable for research or internal prototyping; production teams should first resolve import cycles, add a test suite, and formalize licensing before extending the stack.