Sceniris: A Fast Procedural Scene Generation Framework

Jinghuan Shang, Harsh Patel, Ran Gong, Karl SchmeckpeperarXiv 2025 · DOI · arXiv

Abstract

Sceniris is a high-throughput procedural 3D scene generation framework designed to meet the data demands of Physical AI and generative modeling. By implementing batched scene representations and GPU-accelerated collision checking via cuRobo, Sceniris achieves significant speedups over existing CPU-based methods. It further introduces robot reachability checks to ensure that generated scenes are functionally valid for embodied AI tasks, enabling the generation of thousands of diverse, collision-free scenes per second.

Introduction

Training embodied AI, robot manipulation policies, and 3D generative models requires massive amounts of diverse, collision-free 3D scenes. Collecting real-world 3D data is prohibitively slow and expensive, leading researchers to rely on synthetic data generated procedurally. However, existing procedural generators, such as Scene Synthesizer or Infinigen, often operate on single CPU threads, creating a severe throughput bottleneck. Generating a single scene every 10 seconds does not scale to the hundreds of thousands of variations required for robust AI training.

Sceniris enables fast domain randomization and massively parallel GPU-based scene generation.

Sceniris addresses this bottleneck by leveraging batched scene representations and GPU acceleration, achieving a massive 234x speedup over prior methods. It introduces novel robot reachability checks to ensure generated scenes are actually usable for embodied AI tasks.

Methodology

Sceniris overhauls the traditional procedural generation pipeline to maximize parallelization across several key components:

  • Batched Scene Representation: Instead of a single scene graph, Sceniris stores a batch of scene instances in a single graph. Spatial relationships are represented as tensors of transform matrices, allowing for the simultaneous processing of thousands of variations.
  • Batch Sampling and Caching: Objects are placed by sampling 2D points from support polygons (e.g., tabletops) in bulk from a canonical polygon. These points are cached and then transformed for individual scenes, minimizing redundant sampling overhead.
  • GPU Collision Checking: The framework replaces standard CPU-based collision libraries with NVIDIA's cuRobo, offloading collision checking for entire batches directly to the GPU.
  • Robot Reachability Checks: To ensure functional validity, Sceniris integrates a 4D reachability map (RM4D) to verify that placed objects are within the workspace of a specific robot manipulator.
  • Extended Spatial Relationships: The system supports complex placement rules, including "inside" containers, "between" anchor objects, or specific orientation constraints like "facing" another object.
The Sceniris pipeline: from configuration to batched scene generation with collision and reachability checks.

Key Insights

The development of Sceniris revealed that redundant overhead—such as repeatedly loading object assets—is a primary bottleneck in single-threaded methods. Implementing "warm starting" through caching mechanisms unlocks exponential speedups. Furthermore, vectorizing the scene graph allows procedural generation to fully exploit modern GPU architectures. Finally, the authors demonstrated that reachability checks, while traditionally complex, can be performed with negligible overhead (~0.0001s per query) when using batched 4D reachability maps.

Results and Evaluation

Sceniris demonstrates significant performance gains across various benchmarks:

  • Throughput: In a "warm start" scenario where assets are cached, Sceniris generates 16,384 scenes in 2.52 seconds—approximately 2,936x more valid scenes per second than the baseline.
  • Scalability: On a single NVIDIA L4 GPU, the system successfully generated a batch of 524,288 scenes at a rate of 533 valid scenes per second.
  • Complex Constraints: Even with complex spatial relationships (e.g., placing an object strictly between two others), Sceniris maintains a high throughput of ~249 scenes per second.

Conclusion and Future Work

While Sceniris significantly advances scene generation throughput, initialization overhead for GPU components like cuRobo remains a factor during "cold starts." Future work aims to move the batch sampling of heterogeneous polygons entirely to the GPU to further eliminate bottlenecks. Sceniris represents a critical step toward providing the massive-scale synthetic data necessary for the next generation of Physical AI.

Summary updated

Abstract

Synthetic 3D scenes are essential for developing Physical AI and generative models. Existing procedural generation methods often have low output throughput, creating a significant bottleneck in scaling up dataset creation. In this work, we introduce Sceniris, a highly efficient procedural scene generation framework for rapidly generating large-scale, collision-free scene variations. Sceniris also provides an optional robot reachability check, providing manipulation-feasible scenes for robot tasks. Sceniris is designed for maximum efficiency by addressing the primary performance limitations of the prior method, Scene Synthesizer. Leveraging batch sampling and faster collision checking in cuRobo, Sceniris achieves at least 234x speed-up over Scene Synthesizer. Sceniris also expands the object-wise spatial relationships available in prior work to support diverse scene requirements. Our code is available at https://github.com/rai-inst/sceniris
BibTeX
@misc{shang2025sceniris,
  author = {Jinghuan Shang and Harsh Patel and Ran Gong and Karl Schmeckpeper},
  title = {{Sceniris: A Fast Procedural Scene Generation Framework}},
  year = {2025},
  eprint = {2512.16896},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2512.16896},
}
Figure