Collegica Collegica Collegica
  • Start here
  • Campus
  • Apps
  • Events
  • Talks
  • About
  • Sign in
  • Newsletter

From a Walkthrough Video to a Training World

How NVIDIA turns real places into simulated ones — Gaussian splats, 3DGUT, NuRec, OpenUSD and Isaac Sim — what the 3D file really contains, and what a robot cannot do inside it

A plain guide to NVIDIA’s real-to-sim 3D stack for robotics: 3D Gaussian splatting, 3DGUT and gsplat, the NuRec reconstruction tools, the OpenUSD file that carries a scanned room into Isaac Sim, and the missing collision geometry, baked-in lighting and blind spots that decide what you can train. Read against NVIDIA’s own documentation, November 2026.
Author

Behzad Samadi

Published

November 17, 2026

A robot learns to walk or navigate by failing millions of times, and nobody wants those failures in a real office. So the failures happen in a simulator, which needs a world: floors, walls, furniture, lighting. Building that world by hand is slow, and a hand-built office never looks like your office. The newer idea is to scan a real place and drop the scan into the simulator. A few minutes of walking through a room with a camera becomes a 3D scene a robot can practise in.

NVIDIA ships most of the pieces of this pipeline, and they have confusing names: Gaussian splats, 3DGUT, gsplat, NuRec, Instant NuRec, Harmonizer, OpenUSD, ParticleField. This article is the map of the 3D and simulation half of that stack. It stays with the question a roboticist actually has: what is in the file that goes into the simulator, and what can a robot do with it? The September overview of the whole stack is Train the Robot Before You Build It; this article goes deep on one corner of it.

NoteWhat this article is, and is not

Read from the outside, dated 17 November 2026. Every claim in the main text was checked against NVIDIA’s documentation, its code repositories, its research pages, the arXiv papers or the partner’s own blog post; the claims that could not be confirmed are not used in the text; they are listed under “Reported, but not confirmed” near the end. Nothing was run. NuRec needs a Linux machine with an NVIDIA GPU of more than 24 GB, and none was available. This is a reading, not a test.

TL;DR

  1. The scene is a cloud of fuzzy blobs, not a mesh. 3D Gaussian splatting stores a scene as millions of small coloured, semi-transparent ellipsoids. It looks photographic from nearly any angle and renders fast, but it is visual only.
  2. Standard splatting breaks on robot cameras. 3DGUT fixes that. Fisheye lenses and rolling shutters, which robots and cars use, distort the classic method. NVIDIA’s 3DGUT (CVPR 2025 oral) handles them directly.
  3. NuRec is the toolbox around it, and it is open source since October 2026. Apache-2.0, a Linux x86_64 container, more than 24 GB of GPU memory (48 GB recommended).
  4. The file is an OpenUSD package. A .usdz is a plain zip. NVIDIA is moving the Gaussian data from its own schema to a standard OpenUSD one called ParticleField.
  5. A splat has no physics. NVIDIA’s own robotics guide says the scene “has no inherent collision properties”. You add a ground plane or a collision mesh yourself, and that decides whether the robot can walk in it.
  6. One reported result is real, not magic. A humanoid navigation policy trained on a scan of an office, using only its camera, reached 97.8% in simulation against 93.8% for a depth-sensor policy, and ran in the real office. A partner’s blog reports it; nobody independent has checked it.

Three ways to hold a room in a computer

A simulator needs three different things from a “room”, and no single 3D representation gives all of them.

What it is Good for Bad at
Mesh — triangles Collisions, physics, navigation Looks like a model, not a photo; fine detail (cables, glass) is lost
Point cloud / occupancy grid — dots or boxes in space Knowing where free space is Looking real
Gaussian splat — millions of soft blobs Looking like the real place No surfaces to touch

This is the key to everything that follows. A scan used for robot training nearly always ends up as two layers in one scene: a splat for what the camera sees, and a mesh for what the body bumps into. The Flexion case study below does exactly this.

What a Gaussian splat is

Imagine throwing a few million tiny translucent coloured balloons into a room, then stretching and tilting each one until, seen from the camera positions you recorded, they reproduce your photos. Each balloon has a position, a size and orientation, an opacity and a colour that can change with the viewing angle (so reflections and shine come out). That is a Gaussian. Drawing them is quick because the GPU can flatten each one onto the screen and add them up, which is rasterising; no light rays are traced. The method is called 3D Gaussian splatting (3DGS).

The open-source library that does this on a GPU is gsplat, made by the Nerfstudio team with NVIDIA, UC Berkeley and others. Its README says training takes up to 4× less GPU memory and up to 15% less time than the original research implementation.

Why robots needed a better splat: 3DGUT

The original method has a hidden assumption: the camera is a simple pinhole, and the maths approximates the projection of each blob onto the image with a local straight-line (linear) shortcut. Robots and cars use fisheye lenses to see wide, and many cameras read the picture one row at a time (a rolling shutter), so a moving camera sees a slightly bent world. For those cameras the shortcut gives errors, and the fix used to be rectifying (flattening) the image first, which throws away the edges.

3DGUT — 3D Gaussian Unscented Transform, the paper is “Enabling Distorted Cameras and Secondary Rays in Gaussian Splatting”, NVIDIA Research, CVPR 2025 (oral) — replaces the shortcut. Instead of linearising, it pushes a handful of sample points of each Gaussian through the real, non-linear camera model. Fisheye and rolling shutter then work directly, and the method stays a rasteriser, so it stays fast. NVIDIA’s project page compares it with the fisheye-specific FisheyeGS and reports it needs fewer than half the particles (0.38 million against 1.07 million).

There is a sibling worth knowing. 3DGRT (SIGGRAPH Asia 2024) draws the Gaussians by ray tracing rather than rasterising, which gives shadows, reflections and refraction, but the repository says it needs ray-tracing hardware and is slower than 3DGS. 3DGRUT, the code that holds both, combines them: primary rays by rasterisation, secondary rays (reflections off a mirror, say) by ray tracing. It is Apache-2.0 and is the training code the robotics recipes below run.

NuRec: the toolbox

NuRec (Neural Reconstruction) is NVIDIA’s name for the set of tools that turns recordings into simulator-ready worlds. Its main facts, from NVIDIA’s documentation and release notes:

  • Open source in October 2026, version 26.10, Apache-2.0, at github.com/NVIDIA/NuRec. The same release renamed its packages and containers from nre to nurec.
  • One renderer. Version 26.08 (September 2026) removed the older renderer, so every camera and LiDAR image now goes through gsplat. It also replaced the older image-cleanup models with Harmonizer.
  • Linux x86_64 only. Docker 23.0.1 or later, the NVIDIA Container Toolkit 1.13.5 or later, driver R580 or newer, CUDA 12.8 or later. The documentation asks for more than 24 GB of GPU memory and recommends more than 48 GB. The supported cards are data-centre and workstation: A100, A10, A40, RTX A6000, L20, L40, L40S, H20, H100 and the Blackwell RTX Pro 6000D. It is not a gaming-card or laptop workflow.
  • It was built for driving first. Most of the documentation is about cars (the data format, the actors, the benchmarks). Robotics has its own smaller set of recipes, below.

Cleaning up the picture: Harmonizer

A splat looks right from where the camera was and shows holes and floaters as you move away from it. Harmonizer is a single-step image diffusion model, based on NVIDIA’s Cosmos Predict2 0.6B, that cleans each rendered frame and keeps it steady from one frame to the next. Its model card describes a temporal version that sees the previous frame and a non-temporal one that does not. On an H100 the card reports 212 ms per 576×1024 image in the temporal mode and 28 ms in the other, so it is a real cost per frame. Its licence is the NVIDIA Open Model License, not Apache.

Instant NuRec: a first draft in 1.5 seconds

Normally a scene is optimised: the program adjusts every balloon again and again until the picture matches. That takes minutes to hours. Instant NuRec (NVIDIA research, arXiv 2607.14203, July 2026, updated in November) skips the loop: a single transformer network looks at a 10–20-second multi-camera driving clip and writes out the Gaussians in about 1.5 seconds.

It is a first draft, and NVIDIA says so. On its project page the full optimised NuRec scores 34.38 dB (a picture-similarity score, higher is better) against 29.93 dB for Instant NuRec’s dense version, and the reconstruction time is about 75 minutes against 1.5 seconds. The code is Apache-2.0 for the core, with some optional render and training extras under NVIDIA’s non-commercial source licence. Two limits from its repository: it takes calibrated driving-style multi-camera input, and parts of the training code are not in the release. For a robot in an office, it is not the tool as documented (my reading, not NVIDIA’s), but it shows where the field is going.

From a phone to a simulator: the two robotics recipes

NVIDIA’s NuRec documentation gives two ways to build an indoor scene for Isaac Sim, and neither needs a driving rig.

Recipe 1 — one camera, including a phone. This is the mono recipe.

  1. Capture. Any single camera: a smartphone, an action camera, a mirrorless. The guide’s advice is plain: steady lighting, locked focus and exposure, shutter 1/100 s or faster, a slow loop at several heights and angles, about 60% overlap between pictures, and avoid mirrors and zoom.
  2. Work out where each picture was taken. This is structure-from-motion, done by COLMAP, which gives camera positions and a sparse set of 3D points. The training code wants the simple pinhole camera models.
  3. Train. 3DGUT from the 3DGRUT repository, with USDZ export turned on. It takes “minutes to several hours”.
  4. Load. Import the USDZ into Isaac Sim 5.0 or later, add a ground plane, link a proxy mesh so objects cast shadows onto the scene, put a robot in, and press Play.

Recipe 2 — stereo robot cameras. For a robot that already carries a stereo camera (the documentation uses a ROS bag recording), the chain is cuSFM for camera poses, FoundationStereo for depth, nvblox for a mesh and an occupancy map, and then 3DGRUT for the splat, exporting USDZ. This one gives you a collision-friendly mesh as a by-product, which is the missing piece of the first recipe. The documentation says the nvblox mesh and occupancy “support collision and navigation”.

Both end in the same place: an OpenUSD package, loaded in Isaac Sim.

What is inside the file: OpenUSD and USDZ

OpenUSD (Universal Scene Description) is the open scene format that Pixar built and that the Alliance for OpenUSD, a non-profit whose founding members include Pixar, Adobe, Apple, Autodesk and NVIDIA, now looks after. A .usdz is its single-file package, and its specification is refreshingly dull: “a zero compression, unencrypted zip archive”. You can unzip a NuRec scene and look inside: scene descriptions, the trained Gaussian data, and the camera trajectory.

Two details trip people up.

  • Two ways to describe the blobs. Isaac Sim 5.x loads the older NuRec-specific schema, applied with OmniNuRecVolumeAPI. The Isaac Sim 6.x documentation describes scenes as USD stages using ParticleField geometry, a standard OpenUSD way to hold Gaussian splats and related radiance fields, which Omniverse RTX renders natively alongside ordinary polygons. The 3DGRUT repository says the custom NuRec USDZ “is going to be deprecated and replaced by ParticleField”, and that Isaac Sim 6.0 supports both. If a tutorial and your Isaac Sim version disagree, this is probably why.
  • Do not make the .usdz your root stage. The Isaac Sim 6.2 page lists a known limitation: open a .usdz as the root and then add another asset, and the added asset fails to load. Open a .usd or .usda root and reference the .usdz from it. The same page says DLSS Frame Generation can produce artefacts on particle fields and to switch it off.

The simulator around the scan: Omniverse, Isaac Sim, LiDAR and physics

A scan is only the scenery. Three more things make a simulator: a renderer that shows it, sensors that measure it, and a physics engine that makes things push back. NVIDIA names all of these, and the names overlap, so here is who does what.

Omniverse and Isaac Sim: platform and application

Omniverse is NVIDIA’s platform of libraries and SDKs for physical-AI simulation and digital twins, built on OpenUSD. Its documentation lists libraries such as ovrtx (rendering and sensor simulation on NVIDIA RTX), ovphysx and ovstream, most marked pre-release. The long-standing core is the Kit SDK, a framework for building applications around OpenUSD. Isaac Sim is one such application: “an open-source application on NVIDIA Omniverse”, in its own words. It imports robots and scenes from URDF, MJCF, Onshape CAD or USD, and gives you rendering, physics and sensors in one place.

Two licence facts matter before you build anything on it. The Isaac Sim source on GitHub is Apache-2.0, but building or running it needs additional NVIDIA components such as the Kit SDK, “covered under separate license terms”. Isaac Sim “is free to use for internal R&D and development purposes”, and an NVIDIA AI Enterprise licence is needed if you redistribute it with Omniverse Kit or deliver it to third parties as a service. (The FAQ gives no prices, and I found no official price list.)

The renderer is Omniverse RTX, and it is what draws a scan. NVIDIA’s documentation says a ParticleField “participates in path tracing, camera effects, shadows, reflections, and refractions”. Its own examples include flowers refracting through a glass bowl and casting shadows on the floor. The same page lists the catches:

  • Splats have no surface, so shadows falling on them can look “blobby”.
  • They do not cast shadows by default; you switch that on.
  • Light intensity does not brighten them. The colours are fixed, display-ready values (tonemapping is skipped); to scale brightness you use the emission_intensity input of a special material.
  • Splat transparency is noisy for the denoiser, and DLSS Frame Generation can cause artefacts.

Importing a splat you trained yourself means converting its .ply file to OpenUSD (NVIDIA points to a script in the OpenUSD repository for this), and training with 3DGRUT can export ParticleField directly.

LiDAR: simulated by the renderer

A LiDAR measures distance with laser pulses. In Isaac Sim it is not a separate physics calculation: “RTX Lidar sensors are simulated at render time on the GPU with RTX hardware”. That is the 6.x documentation (last updated 14 October 2026). The practical points:

  • It is a prim in the scene. An OmniLidar prim carries the sensor description, and a render product with the GenericModelOutput output collects the returns.
  • Real sensor models are built in. The page names Example_Rotary, SICK picoScan, Hesai XT32 and Ouster OS configurations, and distinguishes rotary sensors (a full scan is one 360° turn) from solid-state ones (a full sweep of the field of view).
  • Materials change the answer. “Lidar return behavior depends on material properties (for example, emissivity, reflectivity)”, so glass and shiny floors behave like the real thing only if their material is set up.
  • It plugs into ROS 2. Output is available as PointCloud2 for 3D scans and LaserScan for 2D sensors.
  • One trap. The sensor’s tick_rate must equal its scan rate, or it emits “partial scans every frame instead of accumulating to a full scan”.
  • Older sensors are being retired. The PhysX-based LiDAR is deprecated since 6.0, replaced by a physics ray-cast sensor. LiDAR set up for 5.x with JSON configuration files needs converting; a script ships for that.

Does that LiDAR see a splat? Unconfirmed. NVIDIA’s Isaac Sim and Omniverse pages on neural scenes do not mention LiDAR at all, and no statement was found that RTX Lidar returns hits from a ParticleField. What is documented is on the reconstruction side: the NuRec service itself renders LiDAR from a scan, since version 26.04 (May 2026, “GSplatRenderer now supports lidar rendering”), with an opt-in path in 26.09 that “reconstructs and renders measured LiDAR returns directly”. Those are NuRec’s own render service for driving logs, not Isaac Sim’s sensor. If you need a laser scanner in a scanned room, plan on the collision mesh being what the scanner hits, and test it.

Physics: PhysX by default, Newton as the experiment

PhysX is the default engine in Isaac Sim, run through the omni.physx extension, which the documentation calls “a wrapper around the NVIDIA PhysX SDK”. Both it and the newer Newton engine read the standard USD Physics schema, and only one is active at a time.

Newton is the open-source engine built on Warp, integrating MuJoCo Warp, a Linux Foundation project started by Disney Research, Google DeepMind and NVIDIA. NVIDIA announced Newton 1.0 as generally available at GTC in March 2026 and describes it as production-ready for contact-rich manipulation and locomotion, with reported speed-ups over MuJoCo’s JAX version of 252× (locomotion) and 475× (manipulation) on an RTX PRO 6000 Blackwell card. Inside Isaac Sim the status is more careful: “Newton integration in Isaac Sim is experimental”, tested only on a short list of robots (the G1, H1, T1, UR5e, Allegro and Shadow hands). You pick it with the isaac-sim.newton.sh launch script, a call to switch_physics_engine("newton"), or the viewport’s engine selector. Its documented limits include: edits to the scene while it plays are not applied, assets tuned for PhysX may need repair (zero-size collision shapes, closed loops, a unit scale other than metres), and it keeps only 200 contacts by default and drops the rest.

Isaac Lab 3.0 is where the choice shows up for training. Its documentation describes a multi-backend design with Isaac Sim PhysX, Newton and a separate OvPhysX, chosen by a launch option such as physics=newton_mjwarp or physics=physx. Newton can even run without a full Isaac Sim install. The documentation pages I read still showed beta labels on parts of 3.0, so check the version before relying on it.

Where the scan meets the physics. Physics never looks at the splat. It sees the ground plane and the colliders you give it. That is why the Flexion pipeline builds a second layer, and why the stereo recipe’s nvblox mesh matters. No NVIDIA page was found that explains how to turn a particular splat into collision shapes; that step is yours to design.

What a robot cannot do in a splat

This is the section that matters most if you came to train something.

It has no physics. NVIDIA’s mono recipe says it outright: “Your reconstructed scene is visual geometry only — it has no inherent collision properties.” A robot dropped in falls through the floor. You add a ground plane (and align it, because the guide notes the normalising transform does not guarantee the floor sits at height zero), and for walls and furniture you need a collision mesh from somewhere else. No NVIDIA tool that pulls a collision mesh out of a splat was found. The stereo recipe’s nvblox mesh and Niantic’s reconstruction pipeline (below) are the two examples that produce one.

The lighting is frozen. A splat records the room as it looked at capture: the time of day, the shadows, the reflections. Changing the light means a separate model. NVIDIA’s open Cosmos Transfer can re-render video with new conditions such as snow, driven by a text prompt, and its repository shows a simulation-to-real augmentation workflow. Note that the Transfer 2.5 repository says it is no longer under active development and points to Cosmos 3, so check which version you would use.

It is only as good as the walk-through. Where you did not point the camera, the scene is sparse and ragged. NVIDIA’s pages do not state this as a rule; it follows from how the method works, and the partner post below says it too.

It is a snapshot. People, doors and moved chairs are not in it. The partner post adds them in simulation.

The honest summary. A splat gives your policy realistic eyes. It does not give it a body to bump into, and it does not give it a world that changes. The mesh and the physics engine do that part. The physics engines are covered in the section above.

A worked example, with its caveats: Flexion, Niantic Spatial and NVIDIA

The best-described robotics use is a July 2026 post by Niantic Spatial (published 20 July 2026), about work with Flexion Robotics and NVIDIA.

  • Capture: “A few minutes of video from an off-the-shelf 360° camera”, walked once through an office; no LiDAR or tripods.
  • Two layers from one reconstruction: a metric, gravity-aligned Gaussian splat for appearance, and a collision mesh built from depth estimated with MVSAnywhere, a zero-shot multi-view stereo model. “Derives both layers from the same reconstruction, so they agree by construction.”
  • Training: Isaac Sim and Isaac Lab, with the scene loaded as a NuRec volume; reinforcement learning with massively parallel rollouts on one GPU. The policy sees only the onboard RGB camera, plus body data and the goal, and outputs a velocity command that a separate locomotion policy turns into steps. Collisions and falls are penalised.
  • Result in simulation: each policy evaluated over 1,024 rollouts.
Office RGB policy trained on the 3DGS scan Depth-sensor policy
Flexion (Zurich) 97.8% 93.8%
Niantic Spatial (London, more complex) 75.0% 70.9%

The other RGB set-ups in the post (a synthetic textured office and a generated mesh) did worse than depth in both scenes, which is the point: the photographic scan is what let a camera-only policy compete.

Real robot. The post says the RGB policy “transfers zero-shot to the physical robot” and performed on par with a depth-based policy in the real office.

Read it carefully. It is a partner’s own blog post: no independent benchmark, and the policies are specific to the one captured layout and lighting. The post’s own limits are that the scene is a static snapshot and fidelity depends on capture coverage. Its own summary line is a good one to keep: “RGB is not magic.”

What it costs to try

Route What you need Cost shape
Read and learn A browser Free. NVIDIA’s documentation and the open repositories
Capture and pose only A phone and COLMAP COLMAP is free, third-party software; training is the step that needs the big GPU
Train and simulate A data-centre or workstation NVIDIA GPU, over 24 GB, on Linux Rent by the hour, or own an RTX-class workstation card
Open an existing scene Isaac Sim, plus NVIDIA’s NuRec sample dataset from Hugging Face The Isaac Sim 6.2 page’s navigation examples use that dataset

The last row matters for a beginner: you can look at a finished scene in Isaac Sim before you ever scan anything. For the machines Isaac Sim itself wants, and what to do without an RTX card, see the September stack overview.

What to do this week

  1. Open a finished scene first. Take NVIDIA’s NuRec sample scenes and run the navigation example in Isaac Sim, then try the mono recipe’s last step on any scene: add a ground plane and a robot, and watch what stands on a floor that is not really there.
  2. Scan one room with your phone. Follow the capture advice (steady, slow, overlapping). Run COLMAP. Even if you cannot train yet, the pose step tells you whether your capture is good enough.
  3. Plan the second layer before the first. Decide where the collision mesh comes from (a depth sensor, a reconstruction pipeline, or a few boxes you place by hand) before you invest in the pretty layer.
  4. Check your Isaac Sim version against the tutorial: 5.x uses the NuRec volume schema, 6.x moves to ParticleField.

Reported, but not confirmed

These claims turned up in the research brief this article started from, in search results or in third-party write-ups. None could be confirmed on NVIDIA’s own pages, so none of them is used above. They are listed so you can chase them, with what is known about each. Treat every number here as unverified.

About the 3D pipeline

  • “Instant NuRec beats the best baseline by 2.01 dB, which is 28.26 dB.” The 2.01 dB gain is on the paper’s abstract page. The 28.26 dB figure appears in third-party summaries and on neither the paper’s abstract nor NVIDIA’s project page.
  • “850,000 of the 2 million Instant NuRec Gaussians seed the training.” The 2,000,000 default is in the repository. The 850,000 sampling figure was not on the pages read; it may sit in NuRec documentation that was not opened.
  • Throughput. The brief gives 3.33 reconstructions an hour on one RTX 6000 Pro (about 18 minutes a clip), 100 frames a second at 1080p, and 4 to 5 times faster on 8 GPUs. NVIDIA’s “How NuRec works” page does not contain these numbers. It links a Li Auto scaling page that was not opened.
  • Scale and adoption. “4,000 daily scene reconstructions, 4,000,000 daily clip evaluations, 200,000 weekly safety assessments” and a Li Auto platform of millions of clips: not found on the pages read.
  • “More than 150 GB of disk” and a “Built on NVIDIA Cosmos” attribution duty for Harmonizer. The brief takes these from an agent-skill listing. They are not on NVIDIA’s hardware and software pages or on Harmonizer’s model card, which names the NVIDIA Open Model License.
  • “26.03 was the first public release.” NuRec’s notes date 26.03 to April 2026 and do not say it was the first public release.
  • “3DGUT beat FisheyeGS across perceptual metrics.” The project page compares them and reports fewer particles. The “across perceptual metrics” wording was not confirmed.
  • A five-model Asset Harvester pipeline. One NVIDIA page lists five models (Mask2Former, C-RADIO, Sana Multiview, LGM, Fixer). The model card lists a different pipeline, so the page is probably out of date.

About sensors and simulation

  • “Isaac Sim’s RTX LiDAR sees Gaussian splats.” No NVIDIA page says so. One third-party site, from a search snippet, says a 0.7.0 version of the ovrtx library adds “experimental lidar rendering of NuRec-trained splats”. It was not opened or checked.
  • “A NuRec .usdz ships with a collision mesh inside.” A third-party write-up says so. NVIDIA’s own recipes say the splat has no collision properties, and no NVIDIA page was found describing a bundled mesh.
  • “GPU convex hulls are limited to 64 vertices and faces.” A search snippet, not confirmed on a primary page. If you rely on convex collision shapes, check the PhysX documentation for your version.
  • PhysX time-step and speed figures. No NVIDIA page was found that states them for Isaac Sim.
  • Omniverse pricing. One third-party article calls Omniverse “free for production use”, which conflicts with the licence FAQ’s terms above, so it is not used. NVIDIA publishes no price list on the pages read.
  • “Splats show blind spots away from the captured path.” True by how the method works, and the partner’s blog says fidelity depends on capture coverage, but NVIDIA’s pages do not state it as a rule.
  • The OmniDreams comparison. The brief sets NuRec against NVIDIA’s OmniDreams video world model and World Labs’ Marble. OmniDreams’ frame rates were confirmed in its paper (68 frames a second, one camera; up to 105 per camera on 16 GPUs), but the closed-loop comparison section was not read and the Marble column is unsupported.

Pages that could not be read

NVIDIA’s Omniverse neural-rendering page, an Isaac Sim neural-rendering page, its 5.0 NuRec assets page, a LiDAR scan-pattern page and the PhysX limitations page all returned errors or redirects. What those pages say about supported cameras, LiDAR and collision inside Isaac Sim is therefore unknown.

Sources

Research notes, the claim-by-claim check against these pages, and the items that could not be confirmed are in the accompanying folder.

  • NuRec. Documentation, release notes 26.10, hardware and software pages, source.
  • Robotics recipes. Mono (one camera), stereo, Reconstruct a scene in Isaac Sim using only a smartphone.
  • Isaac Sim and USD. NuRec assets in Isaac Sim 6.2; USDZ specification; Alliance for OpenUSD.
  • Splatting research. 3DGUT, 3DGRT, 3DGRUT code, gsplat.
  • Instant NuRec and Harmonizer. arXiv 2607.14203, project page, code, Harmonizer.
  • Case study. Niantic Spatial: Flexion humanoid real-to-sim, sim-to-real.
  • Omniverse, LiDAR and physics. Omniverse; Isaac Sim and its licence FAQ; Gaussian splats (particle fields) in Omniverse RTX; RTX Lidar and the deprecated PhysX lidar; physics in Isaac Sim and its Newton backend; Isaac Lab; NuRec release notes; Newton 1.0 announcement.
  • Cosmos Transfer and Newton. cosmos-transfer2.5, newton-physics/newton.

© 2026 Collegica

A learning companion to Mechatronics3D

  • About

  • Apps

  • Events

  • Talks

  • YouTube

  • Facebook

  • For AI agents