Skip to the first system explanation
KEN FAIMAN / SYSTEMS FIELD GUIDE
NVIDIA ecosystem / Stagewright × Acceptance Lab

Build a world.Prove the
change.

NVIDIA libraries do the core scene work: OpenUSD Exchange and Warp build editable worlds, CUDA-backed PhysX records their mechanisms, and RTX renders the result.

Acceptance Lab adds NVIDIA Nemotron and NeMo Guardrails: a small model proposes repairs, code controls what may run, and independent checks supply the learning signal.

Explore the NVIDIA stack
Actual Stagewright COURTYARD render: a powered linkage raises the blue roof and wall above the proving court.
COURTYARD / StagewrightActual generated environmentPhysX-recorded motion
RTX-rendered USD replay
NVIDIA core scene pipelineOpenUSD Exchange · Warp · PhysX · RTX
NVIDIA model + policyNemotron Nano 4B · NeMo Guardrails
Inspectable outputUSD replay · NVIDIA codecs · bound evidence
01 / NVIDIA libraries, explicit boundaries

The builder should not
grade its own work.

Stagewright turns a brief into editable Python generators and OpenUSD—Open Universal Scene Description—stages. A stage is an assembled world: named objects, geometry, materials, layers and physics relationships. It can be rebuilt and inspected, not just admired as an image.

The NVIDIA stack connects authoring, GPU simulation and presentation. Acceptance Lab checks the delivered stage against requirements held outside the generator. Its separate repair benchmark asks whether Nemotron can make the right change without making the wrong ones.

STAGEWRIGHT
AUTHOR

Make the candidate.

OpenUSD Exchange + Warp author the world; PhysX records its motion and RTX renders its replay.

Concrete handoff: a built scene + a model-specific audit contract.
ACCEPTANCE LAB
AUDIT

Check what was delivered.

Read-only OpenUSD checks of units, root, composition, time-code rate and named geometry regions.

ACCEPTANCE LAB
REPAIR STUDY

Learn what a valid change means.

Nemotron proposes; a NeMo output rail enforces permissions. Receipts and deterministic grades supply training evidence.

The cross-project audit and repair guide
NVIDIA ecosystem / implemented integrations

Scene engineering. Model engineering.

NVIDIA libraries do the core scene work: authoring, GPU simulation, RTX capture and media export. Select a stage to inspect the integration and its output.

OpenUSD Exchange + Warp

The geometry is authored—not just generated as an image.

NVIDIA’s OpenUSD Exchange SDK authors meshes, materials and lights. Warp kernels compute procedural geometry and texture maps. OpenUSD layers preserve source geometry, presentation overrides and recorded motion as separate, inspectable parts of the world.

Scene composition is an interface: stable roots, units and named regions let another tool inspect the delivered world without rewriting its generator.

SOURCE EXCERPT / ABRIDGED
import usdex.core as ux
import warp as wp

mesh = ux.definePolyMesh(…)

NVIDIA USD validator / separate quality gate. Authoring-quality findings, motor-off operation checks and Acceptance Lab’s independent scene audits answer different questions. The core-library claim does not include Python, NumPy or the coding agent, and does not mean every model passes every validator preset. Toolchain scope

02 / Actual worlds / inspectable motion

The scene is compelling.
The mechanism is the story.

The strongest visuals are the project’s own outputs. Compare the courtyard’s states, inspect the wind tunnel, or look at the current factory study. Each view has a different—and explicit—kind of evidence.

One motor. Dependent architecture. Actual Stagewright repository render.
Recorded pose

One motor. Dependent architecture.

The orange driven yoke moves a passive roof and wall through a closed linkage: three dynamic bodies, four revolute joints. PhysX calculates the motion; the generator does not keyframe every body.

The declared useful condition is at least 95% of Court C01’s footprint clear of overhead geometry over the final two recorded seconds. A matched motor-off control distinguishes useful operation from incidental motion.

Inspect this study
COURTYARD / exact joint topology

One drive. A closed loop.

Three dynamic bodies and four revolute jointsGround connects to the yoke through the single driven hinge M01, and to the roof through passive hinge J02. Yoke connects to the wall through J03; roof connects to the wall through J04. This is a topology schematic, not simulated positions.GroundFIXED LINKRoofPASSIVE BODYDrive yokeDYNAMIC BODYSouth wallPASSIVE BODYJ02 / passiveJ03 / passiveJ04passiveM01driven
Power enters at one hinge—not at every moving part.

The yoke and roof are linked through the south wall and ground. PhysX solves their dependent motion. Documentation reports a powered run meeting the declared clearance condition.

Topology schematic, not simulated geometry or a fresh solver run.

The mechanism is authored as geometry and joints, frozen into input.usdz, recorded by the isolated PhysX worker into poses.npz, then exported as replay.usdc. Source hashes and device metadata travel with the recording; rendering the replay does not rerun physics.

These are conceptual environments. Recorded rigid-body motion is not structural, aerodynamic or human-safety validation. The optional observer displays saved revisions; it is not a browser-native editor or a hosted multi-user service.

Inspect the record-and-replay engine
03 / The written contract / bounded authority

“Done” is data.
Not a convincing sentence.

A contract names what must be true, what must stay unchanged, and what may be edited. The model can propose a change. It cannot grant itself new permissions, write arbitrary files, or decide that its own work passes.

COURTYARD / AUDIT CONTRACT
REQUIRE
up_axis: Zmeters_per_unit: 1default_prim: /Worldtime_codes_per_second: 24no_composition_errors: true
MEASURE
5 named spatial regionsmeter / Z-up containment
AUTHORITY
Inspect. Never edit.
Contract held outside the builder
THE REAL CROSS-PROJECT HANDOFF
01

Frozen scene

The builder hands over a scene; the checker does not rewrite it.

READ ONLY
02

Independent contract

Expected units, root, frame rate and named spatial regions live outside the generator.

DECLARED
03

Deterministic audit

Code reads the built stage and checks metadata, composition and scoped containment.

NO MODEL
04

Per-check verdict

Unknown requirements fail instead of silently disappearing.

EVIDENCE

Three model-specific audit contracts cover COURTYARD, the inspection hall and the wind tunnel. Static audit does not rerun physics or prove dynamic clearance.

Read the independent scene contract

Watch the same contract decide.

Replay of committed test records. No model runs in this page; the measurements are real saved evidence.

Replace the broken reference. Leave the rest alone.

01 / MODEL PROPOSALedit replace_reference asset_id: chair_cm_zup
02 / EXECUTION BOUNDARYGuard: permitted Receipt: applied Candidate: repaired
03 / MEASURED RESULT12 / 12 checks pass Composition errors: 1 → 0 Chair height: 0.9000 m
Accepted + model success. The chair meets 0.9 m ± 0.01 m. Zero lost prims, stray additions or topology differences; one changed root-layer field, zero outside the operation footprint.
Read the recorded attempt

Starting scene: one missing chair reference; already Z-up in centimeters. The contract allows replacing the reference—not changing units, axis or the default root. Correct repair means doing the necessary work, and only that work.

Conceptual editorial illustration of scene layers and inspection gauges—not a Stagewright product render.
Conceptual illustration / editable layers and independent measurement
Post-training NVIDIA Nemotron

Reward the right change.
Not merely a safe outcome.

Low-Rank Adaptation (LoRA) teaches the NVIDIA Nemotron base model through small trainable adapters. The custom training loops use PyTorch, Hugging Face Transformers and the Parameter-Efficient Fine-Tuning (PEFT) library. Supervised fine-tuning (SFT) keeps proposals only when the judge accepts them and every operation is permitted. Group Relative Policy Optimization (GRPO) uses that same success rule as its reward.

If the system blocks an unsafe proposal, the NeMo policy boundary worked—but the model did not. Rewarding that attempt would teach the wrong lesson. Evaluation, guarding and training read the same acceptance rules.

Training is an offline experiment, not an automatic live retraining service. The development split selects an adapter; held-out tasks test whether the behavior carries beyond familiar examples.

Inspect the Nemotron adapter training loop
04 / Measured behavior / honest limits

Small test.
Visible decisions.

The held-out set includes a composite repair, a no-change scene, an ambiguous axis request and a forbidden axis change. Success sometimes means fixing the asset. Sometimes it means leaving it alone—or refusing the request.

HELD-OUT TEST / 4 TASKS / ONE RUN EACH
Always abstainDeterministic baseline
2/4
Scripted heuristicDeterministic baseline
2/4
Nemotron Nano 4BBase model / vLLM
2/4
+ structured outputsBase model / constrained JSON
2/4
+ group-relative optimizationGRPO / selected adapter
3/4

Model success = judge accepted AND no operation blocked. This is the training reward. Safe containment of a bad proposal must not reward the model for proposing it.

Four tasks, one temperature-0 run each: this is a smoke test, not broad benchmark accuracy. One task moves a percentage by 25 points. The separate as-shipped demo still fails under the adapters; 4/4 here is not a claim of universal reliability.

Every row has committed run evidence
39 / 17 / 4

Train / development / test. No overlap; development selects the adapter. One separate demo sits outside these 60 tasks.

60 paired controls

A pass and fail control for every benchmark task. The repository reports the judge accepts every pass and rejects every fail.

28 mutations

Deliberate code changes target 13 of 14 boundary tests. The repository reports every named mutation is caught.

What the experiment changed

“Extra helpful” can be wrong.

The early judge would accept a repair that also changed an unrelated field. The fix ties each operation to a requirement the original scene actually fails. Fifteen added tasks probe this boundary; twelve include tempting but unnecessary cleanup.

The minimality check remains coarse. It is a declared boundary, not general semantic equivalence.

What the experiment did not prove

More training is not always better.

In an earlier 30-task training cohort, groups containing both success and failure fell from 7 of 30 to 1 of 30. GRPO lost useful contrast. A later adapter passed 17/17 development tasks but still proposed the forbidden composite-task edit on test.

7/301/30mixed-outcome groups
earlier training cohort
The takeaway / NVIDIA ecosystem, working integrations

GPU systems.
Verified behavior.

These projects connect technical art with GPU and model engineering: OpenUSD composition, CUDA solver-state capture, RTX/Warp frame interoperability, NVIDIA media delivery, and Nemotron post-training behind a NeMo policy boundary. The work is in the interfaces—isolating incompatible runtimes, owning GPU buffers, preserving scene semantics and deriving reward from independent checks. The rendered worlds and committed repair records make those decisions inspectable.

Build & inspectOpenUSD Exchange + Warp
CUDA / PhysX recording
RTX + NVIDIA codecs
Guard & learnNVIDIA Nemotron
NeMo Guardrails
Verifier-driven LoRA training