Access to this dataset is granted under CC BY-NC 4.0 for non-commercial research and evaluation. Commercial teams may request free internal evaluation access: select "Commercial internal evaluation" below and tell us what you plan to evaluate; we typically approve within one business day. Training, fine-tuning, production use, redistribution and custom scene generation require a separate written commercial licence from Imagine.io.

PhysicalAI SimReady Homes: Multi-Room Interiors

Version 1.0 · 1,000 simulation-ready multi-room home interiors that load into Isaac Sim and are ready to train on — no rigging, no retopology, no physics authoring.

Every scene is a furnished multi-room home in OpenUSD with rigid bodies, mass and inertia, collision approximations, PhysX friction/restitution/density, articulated doors and drawers, per-object semantic labels, PBR materials, HDRI lighting and placed cameras — plus a machine-readable sidecar naming every prim by path, and an editable scene graph if you want to change the furniture rather than the pixels.

Built by Imagine.io. Companion to PhysicalAI SimReady Assets, the public object/material/HDRI library these scenes draw from.

Licence notice. Public access is CC BY-NC 4.0 for non-commercial research and evaluation only, with attribution. Commercial teams may request free internal evaluation access by completing the gated form on this page — select "Commercial internal evaluation" and tell us what you want to test. Training, fine-tuning, production use, redistribution, public hosting and custom scene generation require a separate written commercial licence. To talk before requesting access, use the contact form on physical.imagine.io. Full terms in License and usage below.


Scenes	1,000
Objects per scene	~318 — furnished, collided, labelled
Distinct assets used	491
Floorplans	4 layouts (1br, 2br, 3bed, 4br), each furnished 250 ways
Total size	1.56 GB for the whole corpus (mean 1.56 MB per scene)
Lighting / surfaces	6 HDRI environments, 25 floor material packs
Units	metres, Z-up, right-handed, `kilogramsPerUnit=1`
Format	OpenUSD `.usdz` + `metadata.json` + `scene_graph.json` + `floorplan.json` + plan sheet
Sim compatibility	NVIDIA Isaac Sim, Omniverse, or any OpenUSD runtime with an HTTPS-capable asset resolver (see below)
Licence	CC BY-NC 4.0 public · free commercial evaluation · paid commercial licence

Why robotics teams use it

It is SimReady, not "a mesh you could simulate." Physics is authored per object class from a taxonomy — a chair is a dynamic rigid body with a convex-hull collider and wood friction; a countertop is static; a cabinet door is a joint with limits. You spawn a robot and the scene behaves. Nothing to clean up first.
Real interiors, not boxes on a plane. Multi-room homes with correct anthropometry: walkable circulation, doors that swing into rooms that have space for them, kitchens tiled with real cabinet runs and appliance clearances, bathrooms that actually seat a vanity, WC and shower. Layout comes from a space-planning engine, not from random scatter.
Every variation axis is a filterable column. Kitchen shape, sofa shape, TV mount, floor pack, wall tile, HDRI, sun azimuth, colour temperature, object histogram, room areas, footprint — all in the parquet index. Build a curriculum or a held-out split with a pandas query instead of eyeballing renders.
Scenes are under a megabyte. Geometry and textures resolve from the public assets repo by URL, so you can pull the whole corpus, or 20 scenes matching a spec, in seconds.
Reproducible and traceable. Each row carries code_rev, asset_index_sha256, seed and build flags. Bundles are content-named by a digest of their scene graph, so identical scenes are identical files.

What people build with it

Task	What the data gives you
Indoor navigation / SLAM / mapping	multi-room footprints, doorways, real clearances, `floorplan.json` as ground truth
Mobile manipulation	articulated doors, cabinet doors and drawers with joints and limits; graspable props on reachable surfaces
Perception (segmentation, depth, pose)	per-object semantic labels + `physics_index` prim paths → Isaac Replicator ground truth
Domain randomization / sim2real	material packs, HDRI, sun angle and colour temperature as explicit axes, already varied across the corpus
VLA / embodied agents	room-typed scene graph with poses, so instructions can be grounded ("go to the kitchen sink")
Layout & scene-synthesis research	the authored `scene_graph.json` and source floorplan next to the built result

Quick start

pip install huggingface_hub pandas pyarrow
hf auth login                            # gated: request access first
#   on huggingface_hub < 0.34, this command is `huggingface-cli login`

# download one scene, unpack it, check it, open it
python dataset_tools/download_scene.py --style scandinavian_3bed --seed 7 --out ./scenes --extract
python dataset_tools/validate_scene.py ./scenes/scandinavian_3bed_s7
<isaac>/python.sh dataset_tools/load_isaac.py ./scenes/scandinavian_3bed_s7/model.usdz

dataset_tools/ in this repo holds download_scene.py, extract_scene.py, validate_scene.py and load_isaac.py. Every script takes --help; load_isaac.py also takes --headless and --physics.

Starter pack: 20 scenes, no scripts

Kick the tyres on a filtered slice (~42 MB) straight from the index, without reading our tooling:

import glob, pandas as pd
from huggingface_hub import snapshot_download, hf_hub_download

REPO = "imagineio/PhysicalAI-SimReady-Homes"

# 1. pull just the index
d = snapshot_download(REPO, repo_type="dataset", allow_patterns="index/*.parquet")
df = pd.concat(pd.read_parquet(p) for p in glob.glob(f"{d}/index/*.parquet"))

# 2. filter on any variation axis
hits = df[(df.bedrooms == 4) & (df.interior_run == "island")].head(20)

# 3. download exactly those scenes; always use the row's own hf_path
for p in hits.hf_path:
    hf_hub_download(REPO, p, repo_type="dataset", local_dir="./scenes")

The same slice through the CLI, unpacked as it lands:

python dataset_tools/download_scene.py \
    --query "bedrooms == 4 and interior_run == 'island'" \
    --limit 20 --out ./scenes --extract

Load into Isaac Sim

A scene resolves its geometry over HTTPS, so it must be opened through a resolver that speaks it — in practice omni.usd, under Isaac's own Python:

import os
from isaacsim import SimulationApp
app = SimulationApp({"headless": True})

import omni.usd

# Pass an ABSOLUTE path -- see the warning below.
stage_path = os.path.abspath("./scenes/scandinavian_3bed_s7/model.usdz")

ctx = omni.usd.get_context()
assert ctx.open_stage(stage_path)
stage = ctx.get_stage()

Open the stage by absolute path. Given a relative path, Kit opens the scene but silently fails to resolve the .usdz's package-internal layers, so the procedural casework — the whole kitchen cabinet run, counters, uppers, oven tower — composes to nothing and the kitchen renders empty. The HTTPS vendor assets resolve either way, which is what makes it easy to miss. Measured on one scene, same session: relative gave 6,166 prims / 1,648 meshes, absolute gave 7,054 / 1,888. dataset_tools/load_isaac.py resolves the path for you.

(open_stage returns a bare bool on Isaac Sim 6.x and an (ok, error) pair on older Kit builds; both are truthy on success, so the assert above works either way.)

Or just: <isaac>/python.sh dataset_tools/load_isaac.py ./scenes/scandinavian_3bed_s7/model.usdz, which does exactly the above and reports prim, mesh and unresolved-reference counts.

Ground truth via Replicator

metadata.json names every prim by path, and every room already has a camera authored at a photographic standpoint — so you can wire up annotators without walking the stage or inventing a viewpoint:

import json, omni.replicator.core as rep

meta = json.load(open("./scenes/scandinavian_3bed_s7/metadata.json"))

# every labelled object, by prim path
prims = [o["prim_path"] for o in meta["objects"]]

# the authored per-room cameras live in the physics index (note the key is `prim`)
for cam in meta["physics_index"]["cameras"]:
    print(cam["room_id"], cam["prim"], cam["eye"], cam["target"])

rp = rep.create.render_product(meta["physics_index"]["cameras"][0]["prim"], (1280, 720))

writer = rep.WriterRegistry.get("BasicWriter")
writer.initialize(
    output_dir="./out",
    rgb=True,
    distance_to_camera=True,
    semantic_segmentation=True,
    instance_id_segmentation=True,
    normals=True,
)
writer.attach([rp])
rep.orchestrator.run()

Tested against


Isaac Sim	6.0.1 (what the corpus was authored and spot-checked on; no version is enforced)
OpenUSD	authored with `usd-core` 26.5 (`>=24.8`)
Python	3.11+
Not supported for loading	PyPI `usd-core` — no HTTPS resolver, see below

Two things to know before you load

1. A scene needs network access to open. The bundle holds the USD, not the geometry. Every mesh, PBR texture and the HDRI resolves by https:// URL from the public, ungated imagineio/PhysicalAI-SimReady-Assets at load time. That is why a scene is under a megabyte instead of about a gigabyte, and it means you need a resolver that speaks HTTPS — Isaac Sim's OmniUsdResolver does, the PyPI usd-core build does not (it opens the stage and shows an empty room). Access here is enough; the assets repo needs no separate grant.

If assets come up missing after a network blip, Omniverse caches the failed fetch. Clear %LOCALAPPDATA%\ov\cache (Windows) or ~/.cache/ov (Linux) before retrying.

Running air-gapped? Mirror the assets repo locally and remap the resolver. Ask us and we'll send the mirroring steps, or supply pre-baked offline bundles with geometry inlined.

2. A scene is one archive, and it nests. Download <scene_digest>.zip, unpack it, then open model.usdz — you cannot point a viewer at the download. There is no text-readable USD layer at any level; the root inside the package is a binary crate (model.usdc).

What's in each scene

scenes/<scene_digest>.zip                ~1.56 MB
    model.usdz          the scene: geometry, physics, materials, lighting, cameras
    metadata.json       SimReady sidecar — rooms, objects, physics index, design choices
    topdown.png         plan sheet (imperial drafting sheet)
    scene_graph.json    editable room/object graph with poses and asset refs
    floorplan.json      the source floorplan the scene was built from

The archive is named by a digest of its scene graph, so identical scenes are identical files. layouts/<style>/ carries each floorplan's authored inputs once.

Use the hf_path / zip_url column, don't build the path. Earlier scenes are published at scenes/<style>/<scene_digest>.zip and both layouts are served, so each row's own path is the only correct one for that row.

Physics and SimReady, in detail

Every scene is authored for direct use in Isaac Sim:

Rigid bodies with mass and inertia, and static bodies for architecture and built-ins.
Collision approximations chosen per object class — convex hull, box proxy or SDF as the class warrants, rather than one blanket setting.
PhysX materials with real friction, restitution and density per surface (wood, tile, fabric, stone, metal).
Articulated openings — entry doors, cabinet doors and drawers as joints with limits and articulation roots, so a policy can actually open them.
Semantic labels per object, from a taxonomy that maps each class to its labels, body type, collider and physics preset.
Lighting and cameras — an HDRI dome plus ceiling fixtures, and per-room camera standpoints framed like an architectural photograph.

metadata.json carries a physics_index naming every rigid body, static body, collider, articulation root, material, light and camera by prim path (joints are named by joint_id) — so you can wire up Replicator, attach sensors or query the scene without walking the stage yourself.

The design block records the seeded per-room choices — the door style a kitchen's casework wears, the countertop stone, the sofa shape — at the point each was drawn. These are not derivable from the geometry, and they are mirrored into the index columns below.

How these scenes were made

Each scene is composed from Imagine.io's internally authored, rights-controlled 3D object library. Those objects were designed and built by experienced furniture, interior and 3D production artists to reflect real-world scale, structure, materials and construction details.

Assets are authored in real-world units with physically plausible dimensions, and prepared once with PBR materials, clean geometry, collision meshes, physics properties, articulation where applicable and structured metadata. That configuration is built once per asset and carries through to every scene the asset appears in.

A space-planning engine then composes those prepared assets into furnished homes through rule-based parametric variation across the axes listed below, constrained for physical validity at scene level. The 1,000 scenes here are 4 floorplans × 250 seeds, sampled to maximise structural and visual diversity within that space.

Variation is parametric, principled and reproducible. Fully synthetic: the corpus contains no real persons, real addresses or personally identifiable information.

Validation

Scenes are authored against SimReady rules in the generator and have been tested in NVIDIA Isaac Sim by Imagine.io. Validation in this release is spot-check, not per scene. The rules pass on sampled scenes, but the corpus run did not gate on them. Per-scene validation is available on custom corpora; see Known limits below.

References to NVIDIA, Isaac Sim, Omniverse, PhysX and SimReady on this page describe technical compatibility and validation context, not certification or endorsement. Isaac Sim, Omniverse and PhysX are trademarks of NVIDIA Corporation. No NVIDIA partnership, certification or trademark licence is implied beyond what is documented here.

Browse and filter the index

index/*.parquet is the index — and because nothing inside a bundle has its own URL, it is the only index. Every variation axis is a column, so you filter here and download only what you want. The preview column embeds a 256 px thumbnail, so the Data Studio viewer above shows a plan sheet for every row.

It is a directory of parquet shards, not one file: scenes are generated on several machines at once and each publishes its own rows as it uploads, so the index is always current rather than assembled afterwards. Every shard carries an identical schema, so the split loads as one table — read it through datasets, or glob it:

from datasets import load_dataset
df = load_dataset("imagineio/PhysicalAI-SimReady-Homes", split="train").to_pandas()

# or without `datasets`, straight from the parquet:
#   from huggingface_hub import snapshot_download
#   import pandas as pd, glob
#   d = snapshot_download("imagineio/PhysicalAI-SimReady-Homes", repo_type="dataset", allow_patterns="index/*.parquet")
#   df = pd.concat(pd.read_parquet(p) for p in glob.glob(f"{d}/index/*.parquet"))

# every 4-bedroom scene with an island kitchen and a wall-mounted TV
hits = df[(df.bedrooms == 4) & (df.interior_run == "island") & (df.tv_mount == "wall")]
print(hits[["style", "seed", "scene_id", "zip_url"]])

Drop the preview column if you only want to filter — it is ~34 KB of thumbnail per row and dominates the read.

Which axes actually vary, and with what

Walls are fixed per floorplan, so the structural axes are determined by style rather than independent of it. Combining them across floorplans can therefore produce a query that matches nothing — bedrooms == 3 and interior_run == "island" is empty, because island kitchens exist only in the 4-bedroom plan. Filter structure with style (or with one structural column), then filter within it on the seeded axes.

	Columns
Vary with `seed`, within every floorplan	`cabinet_door_style`, `cabinet_handle_variant`, `countertop_finish`, `oven_housing`, `sofa_shape`, `tv_mount`, `hdri`, `sun_azimuth`, `floor_pack_living`, `floor_pack_kitchen`, `floor_pack_bathroom`, `wall_pack_exterior`, `wall_pack_interior`, `wall_tile_pack`, `wall_tile_m`, `rug_packs`, `mat_packs`, `asset_ids`, `asset_names`, `assets_by_class`, `window_assets`, `object_variants`, `object_count`, `referenced_count`, `placeholder_count`, `class_histogram`, `rigid_body_count`, `static_body_count`, `collider_count`, `joint_count`, `articulation_root_count`, `material_count`, `dropped_required`
Fixed by `style` — one value per floorplan	`room_count`, `bedrooms`, `bathrooms`, `room_types`, `room_areas_m2`, `floor_area_m2`, `footprint_w_m`, `footprint_d_m`, `circulation`, `kitchen_shape`, `kitchen_run_count`, `interior_run`, `door_assets`, `balcony_door_assets`, `light_count`, `camera_count`, `scale_up_factor`, `scale_up_capped`, `bath_openings_clamped`
Constant corpus-wide in v1.0	`cook_mode`, `open_kitchen`, `has_courtyard`, `veranda_depth`, `lighting_mode`, `color_temp`, `ceiling_pack`, `floor_pack_balcony`, `dropped_bathroom_core`

Recommended evaluation split

Because walls are fixed per floorplan, split by style, not by seed. Seeds re-furnish a home; they do not redraw it. For results comparable across papers, we recommend holding out one architecture entirely:

train = df[df.style != "scandinavian_3bed"]  # every architecture but one
test  = df[df.style == "scandinavian_3bed"]  # the held-out architecture, unseen walls

Please report this as SimReady-Homes-A so numbers are comparable between papers. Splitting by seed measures furniture generalisation only, and will overstate architectural generalisation.

Variation axes you can filter on

Group	Columns
Identity	`scene_id` (= `scene_digest`), `style`, `seed`, `zip_url`, `hf_path`
Plan shape	`room_count`, `bedrooms`, `bathrooms`, `room_types`, `room_areas_m2`, `floor_area_m2`, `footprint_w_m`, `footprint_d_m`
Typology	`circulation`, `open_kitchen`, `has_courtyard`, `veranda_depth`
Surfaces	`floor_pack_living`, `floor_pack_kitchen`, `floor_pack_bathroom`, `floor_pack_balcony`, `wall_pack_exterior`, `wall_pack_interior`, `ceiling_pack`, `wall_tile_pack`, `wall_tile_m`, `rug_packs`, `mat_packs`
Kitchen design	`kitchen_shape`, `kitchen_run_count`, `cabinet_door_style`, `cabinet_handle_variant`, `countertop_finish`, `cook_mode`, `oven_housing`, `interior_run`
Living design	`sofa_shape`, `tv_mount`
Lighting	`hdri`, `lighting_mode`, `sun_azimuth`, `color_temp`, `light_count`
Assets	`asset_ids`, `asset_names`, `assets_by_class`, `door_assets`, `window_assets`, `balcony_door_assets`, `object_variants`
Composition	`object_count`, `referenced_count`, `placeholder_count`, `class_histogram`
Physics	`rigid_body_count`, `static_body_count`, `collider_count`, `joint_count`, `articulation_root_count`, `material_count`, `camera_count`
Quality	`dropped_required`, `dropped_bathroom_core`, `scale_up_factor`, `scale_up_capped`, `bath_openings_clamped`
Provenance	`code_rev`, `asset_index_sha256`, `generated_at`, `remote_assets_remote`, `remote_assets_local`, `build_s`, `stage_timings_s`

Metadata schema

metadata.json is simready_scene_metadata_v2, with top-level keys: schema, schema_version, generated_at, scene_id, units, coordinate_system, usd_export, packaging, variation_config, source_floorplan, functional_layout, dropped_furniture, design, rooms, objects, physics_index, build_stats.

A real sidecar, trimmed to one object, one room and one camera:

{
  "schema": "simready_scene_metadata_v2",
  "schema_version": "2.0",
  "scene_id": "scandinavian_1br_s1",
  "units": { "length": "meters", "angle": "radians", "mass": "kilograms" },
  "coordinate_system": { "up": [0, 0, 1], "handedness": "right" },
  "rooms": [
    { "room_id": "kitchen", "type": "kitchen", "semantic_class": ["kitchen"],
      "area_m2": 15.866, "polygon": [], "object_ids": [] }
  ],
  "objects": [
    {
      "object_id": "door_o_0",
      "class": "door",
      "room_id": null,
      "prim_path": "/Root/Scenes/Scene/Architecture/LivingRoom/door_o_0",
      "placeholder": false,
      "semantics": { "class": ["door"] },
      "physics": {
        "body": "rigid",
        "collider": "boundingCube",
        "physics_preset": "wood_generic",
        "material": { "staticFriction": 0.5, "dynamicFriction": 0.45,
                      "restitution": 0.38, "density": 650 }
      },
      "referenced": true,
      "asset_source": { "asset_id": 462, "name": "Door 1", "is_articulated": true,
                        "extents_m": [1.149, 0.157, 2.259] }
    }
  ],
  "physics_index": {
    "cameras": [
      { "type": "Camera", "prim": "/Root/Scenes/Scene/Kitchen/Cameras/Kitchen_Camera",
        "room_id": "kitchen", "eye": [3.6581, 6.8152, 1.9751],
        "target": [2.1341, 6.8152, 1.2344], "focal_length": 6.4153,
        "h_aperture": 20.955, "v_aperture": 15.2908, "fov_deg": 100.0 }
    ]
  },
  "build_stats": {
    "room_count": 5, "object_count": 185, "rigid_body_count": 381,
    "static_body_count": 75, "collider_count": 1209, "joint_count": 134,
    "material_count": 16, "light_count": 46
  }
}

physics_index groups are rigid_bodies, static_bodies, colliders, articulation_roots, joints, materials, referenced_assets, lights, cameras and filtered_pairs. Mind the key names, which differ by group: most entries name their prim as prim, materials uses path, joints carry only joint_id (no prim path), and objects[] uses prim_path. Note also that the sidecar's scene_id is the human-readable build name, while the index's scene_id column is the content digest that names the bundle.

Coordinate conventions. Homes uses metres, Z-up, right-handed, kilogramsPerUnit=1 consistently in both the metadata and the USD export. This differs from PhysicalAI SimReady Kitchens, whose metadata reports Y-up while its USD export is Z-up. If you consume both datasets in one pipeline, normalise explicitly rather than assuming a shared convention.

Reproducibility

Each row carries code_rev, asset_index_sha256, seed and the build flags, which together name the exact inputs a scene came from.

One caveat, stated plainly: asset URLs point at resolve/main/ of the assets repo rather than a pinned commit. Scenes therefore track that repo's main branch — asset fixes reach already-published scenes for free, but a restructuring there would affect every scene here at once.

Known limits

We would rather you find these here than after a training run.

Walls are fixed per floorplan. A seed re-furnishes a home; it does not redraw it. Room polygons, door positions and the footprint are identical across every seed of a floorplan, so architectural diversity is 4 architectures. Split held-out sets by style, not by seed. → Need more architectures? We generate them on request. Ask.
Structural axes are not independent of style, and five axes are constant corpus-wide, so a query that crosses them can match nothing. See Which axes actually vary above before writing a filter. → Decoupling an axis from the floorplan is a build option on custom corpora.
Ceiling material is constant. The library ships exactly one ceiling pack, so every scene shares it. → Additional packs are a build option on custom corpora.
Wall materials are thin — 7 packs across the corpus. → Expandable on request.
HDRI is keyed on the seed alone, from a pool of 6, so all floorplans at a given seed share their lighting. → A wider pool, or lighting decoupled from seed, is a build option.
Scenes are not SimReady-validated per scene in this release. The rules exist in the generator and pass on spot-checked scenes, but the corpus run did not gate on them. → Per-scene validation is available on custom corpora. Ask.

Roadmap

This release is version 1.0. Planned additions:

More architectures and floorplan typologies, beyond the current 4
Wider material and lighting pools (ceiling packs, wall packs, HDRI set)
Per-scene SimReady validation gating the corpus run
Pinned asset revisions, so a scene names an immutable asset commit
Additional domains beyond homes: apartments, offices, warehouses, retail, factories

License and usage

Imagine.io operates a three-path licensing model. The path that applies depends on who you are and what you want to do with the dataset.

Path 1: Public non-commercial research (CC BY-NC 4.0)

This public release is provided under the Creative Commons Attribution-NonCommercial 4.0 International License.

Non-commercial researchers may use, copy, share and adapt this dataset for research, education and non-commercial evaluation, provided they give appropriate attribution to Imagine.io, link to the licence, and indicate if changes were made.

Geometry, textures and HDRIs resolve at load time from imagineio/PhysicalAI-SimReady-Assets, also CC BY-NC 4.0. Access here is enough (no separate grant), but a loaded scene is governed by both licences.

Specifically permitted under Path 1:

Load, render, modify and remix scenes for research, teaching and evaluation
Publish renders, figures and videos in papers, theses, talks and blog posts, with attribution
Train models for research and release the checkpoints for non-commercial use, naming this dataset as a training source
Redistribute modified scenes non-commercially, with attribution, under the same licence

Commercial use is not permitted under Path 1. Commercial use includes, but is not limited to:

Use by for-profit companies for internal R&D
Model training or fine-tuning for commercial systems
Model evaluation or benchmarking for commercial systems, unless separately approved under evaluation terms
Product development
Synthetic data generation for commercial use
Paid consulting or customer projects
Commercial redistribution, resale, sublicensing, or public hosting of the dataset
Incorporation into commercial products, platforms, datasets or simulation services

This licence does not grant rights to third-party trademarks, logos, brand names, patents, publicity rights, or other rights not owned or controlled by Imagine.io.

Path 2: Free commercial evaluation

Commercial teams may request free internal evaluation access from Imagine.io. Evaluation access allows approved teams to test the dataset against existing models and simulation pipelines for purchase-evaluation purposes only. It does not permit training, fine-tuning, product development, production use, commercial redistribution, external publication or derivative commercial datasets unless separately agreed in writing.

To request it, click Request access at the top of this page, select "Commercial internal evaluation" in the Intended use field, and describe what you want to evaluate. We review and approve typically within one business day.

To talk before submitting a request, use the contact form on physical.imagine.io.

Free commercial evaluation terms (summary). Final terms are sent for written acceptance before access is granted.

Purpose. Approved commercial teams may access the evaluation dataset solely to evaluate whether PhysicalAI SimReady Homes is suitable for their internal model, simulation, perception, embodied AI or physical AI workflows.

Allowed:

Download and inspect approved evaluation files
Load scenes into internal simulation or model-evaluation pipelines
Run existing models against the dataset
Generate internal evaluation results for purchase decisions
Share internal findings within the requesting company

Not allowed:

Training or fine-tuning models
Using the dataset to improve production systems
Product development or production deployment
Redistribution, resale, sublicensing, public hosting, or transfer to third parties
Publishing benchmark results, papers, model cards, demos or blog posts without written approval
Creating derivative commercial datasets
Extracting source assets for resale, asset libraries or competing platforms
Using the dataset to build or train a directly competing 3D asset, simulation-content or world-generation platform

Term. Typically 30 to 90 days unless extended in writing.

Data handling. On request or at end of evaluation, the evaluator must delete or certify deletion of dataset files unless a commercial licence is signed.

Commercial conversion. Training, fine-tuning, benchmarking, production use, custom data generation, API access and broader commercial rights require a separate written commercial licence.

Path 3: Paid commercial licence

Commercial training, fine-tuning, benchmarking, synthetic data generation, platform integration, custom scene generation and production use require a separate written commercial licence from Imagine.io.

Paid commercial licensees may use trained or evaluated model weights commercially. Restrictions apply to redistribution of the dataset itself, source scene files, extracted assets, derivative commercial datasets, and the creation of competing asset or world-generation platforms. Final terms are scoped per engagement.

→ Start a commercial licence conversation

No warranty

The corpus is provided as is, without warranty of any kind, express or implied. See the Validation and Known limits sections above for what has and has not been verified.

Commercial evaluation and custom generation

This release is a public sample of what Imagine.io's generation engine can produce. Teams that need more work with us on:

Free internal evaluation access for commercial teams (Path 2 above)
Custom scene packs for robotics and physical AI evaluation: your floorplans, your typologies, the room types and object classes your policy is failing on
Commercial model training and benchmarking rights (Path 3 above)
Recurring dataset subscriptions with new domains and updates
Synthetic render-pass generation at scale (RGB, depth, segmentation, normals, instance maps)
OpenUSD / Isaac Sim / Omniverse-compatible environment generation in domains beyond homes: apartments, offices, warehouses, retail, hospitality, factories
Your own product catalogue or SKUs ingested as SimReady assets
Per-scene SimReady validation, custom variation axes and metadata schemas, annotation formats matched to your pipeline
Offline and air-gapped bundles, on-prem or exclusive delivery
API or engine access for parameter-driven world generation against your asset library

→ Get in touch

Citation and attribution

If you use this dataset in non-commercial research, model cards, GitHub repositories, demos or publications, please include:

"PhysicalAI SimReady Homes by Imagine.io, Version 1.0, licensed for non-commercial use under CC BY-NC 4.0."

Please also include:

A link to this dataset page and to imagine.io
A link to the CC BY-NC 4.0 licence
A note describing any modifications, filtering, rendering, conversion, augmentation or derived annotations

@dataset{imagine_physicalai_simready_homes_2026,
  author    = {Imagine.io},
  title     = {PhysicalAI SimReady Homes: Multi-Room Interiors},
  year      = {2026},
  version   = {1.0},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/imagineio/PhysicalAI-SimReady-Homes},
  license   = {CC BY-NC 4.0}
}

About Imagine.io

This dataset is a sample of what our generation engine produces.

Imagine.io is the world generation layer for physical AI. Our configuration engine composes thousands of internally authored, rights-controlled 3D products and environment objects into physics-validated training environments through parametric variation. Teams use the engine to generate environment volumes tuned to their training needs: thousands of composed scenes with controlled parameters for materials, layout, lighting and clutter.

We started with kitchens and homes to showcase what the engine produces. The same engine extends to any environment or industry where physical simulation matters. Teams who need more come to us for:

The engine itself, for composing scenes from your own asset library, the same way these 1,000 homes were composed from ours
Custom asset libraries built to your specifications and made engine-compatible, so you can compose scenes specific to your domain
Custom digital replicas or simulation-ready environments built under customer-specific rights and specifications, for composition at scale

Learn more at physical.imagine.io or get in touch.

Related datasets

Dataset	Contents	Licence
PhysicalAI SimReady Homes	1,000 multi-room home interiors	CC BY-NC 4.0
PhysicalAI SimReady Kitchens v1	800 kitchen environments	CC BY-NC 4.0
PhysicalAI SimReady Assets	Object / material / HDRI library these scenes draw from	CC BY-NC 4.0

Downloads last month: 106

Total file size:

1.6 GB