Daily Digest

Loading brief…

• [Bug Report] Newton: CUDA 700 (illegal memory access) on first step after hard reset — stale CollisionPipeline references freed model buffers

  github:isaac-sim/IsaacLab7/13/2026crashes-stabilityisaac-labnewtoncuda-700resetlifecyclecollision-pipeline

  On Isaac Lab’s Newton backend, a hard reset can crash with CUDA error 700 on the first step because CollisionPipeline reuses cached references to a freed/re-finalized Newton Model. Under GPU memory pressure, the next collide dereferences freed or mismatched de

  ⚡ Lifecycle correctness across reset/reinit is mandatory for long-running training; stale GPU references will cause catastrophic job failures.

• Lower conditional merges to predecessor copies

  github:NVIDIA/warp7/13/2026crashes-stabilitywarpcudacodegencontrol-flowundefined-behaviorillegal-memory-access

  Warp lowering of conditional merges can leave operands uninitialized along some paths, and a nested case leaked a branch value into its sibling branch. Under register pressure this surfaced as illegal CUDA memory access.

  ⚡ Warp codegen correctness under control-flow is foundational—any undefined behavior undermines GPU safety for simulation and learning workloads.

• `wp.tile_load_indexed` out-of-bounds read for neg idx

  github:NVIDIA/warp7/13/2026crashes-stabilitywarpcudamemory-safetytileout-of-boundskernels

  wp.tile_load_indexed performs an out-of-bounds read when given a negative index. Upper-bound OOB is predicated to zero, but negative indices can dereference before src.data instead of producing 0.

  ⚡ GPU primitives must be memory-safe by construction; boundary-condition bugs will surface as hard-to-debug corruption in larger pipelines.

• [BUG] Crash with CUDA error 700 when switching examples with Visualization options

  github:newton-physics/newton7/9/2026crashes-stabilitynewtonviewervisualizationcuda-error-700ptx-loadexamples

  Switching examples after enabling certain visualization options (Show Joints/Contacts/Inertia Boxes) can crash with Warp CUDA error 700, leading to PTX module load failures. This occurs when moving from robot_g1 to admm_contact_solver.

  ⚡ Visualization toggles and example switching must be crash-proof; otherwise interactive debugging becomes unsafe and unusable.

• [Bug Report] Failing contact sensing against prims with multiple colliders

  github:isaac-sim/IsaacLab7/8/2026▲ 1crashes-stabilityv3.0crashrenderinghardwareintegrationisaac-simisaac-lab

  Isaac Lab 3.0 regression: contact sensors fail when the target prim has multiple colliders, producing PhysX tensors filter pattern errors. Expected one match but found two, and subsequent filters match none.

  ⚡ Contact sensing must be robust to common asset authoring patterns (multiple colliders) because it underpins reward signals and safety metrics.

• Headless rendering hangs (~10s/frame) — viewport window creates a surfaceless render product that deadlocks RTX sync schedule

  github:isaac-sim/IsaacSim7/10/2026crashes-stabilityv6.0.0crashrenderinghardwareintegrationisaac-simwarp

  In Isaac Sim 6.0.0 headless (`--no-window`), rendering paths that call `app.update()` stall at ~10 seconds per frame after a viewport creates a surfaceless render product. The render fence never signals in headless mode, blocking RTX sync until an internal tim

  ⚡ Headless rendering is a core deployment path for synthetic data and CI; any render-schedule deadlock makes the platform non-viable in containers.

• Proposal: remove quadratic native island-discovery scratch for large tree counts

  github:google-deepmind/mujoco7/9/2026training-infrarlusddeploymentmujocowarphumanoid

  MuJoCo’s native island discovery uses quadratic temporary structures (ntree x ntree adjacency and column-index arrays) even for sparse incidence. Proposal is to remove the quadratic scratch by constructing connected components directly from constraint/tree inc

  ⚡ Large-scale robotics scenarios require solvers with sub-quadratic scratch behavior; quadratic temporary memory becomes a hidden scaling wall.

• [REQ] Make imported mesh SDF cooking configurable

  github:newton-physics/newton7/9/2026crashes-stabilitycrashusddeploymentdxdocsnewton

  Mesh SDF generation settings are partially configurable and inconsistent across USD/URDF/MJCF imports. Request is to expose configuration paths for Mesh.build_sdf() settings and avoid import paths that drop sdf_* options before expensive cooks occur.

  ⚡ Consistent, configurable mesh SDF cooking across formats is key for predictable collision fidelity and cost control in asset ingestion.

• [REQ] Make automatic USD mesh approximation configurable

  github:newton-physics/newton7/9/2026training-infrarlusddxdocsnewton

  Automatic USD mesh approximation calls ModelBuilder.approximate_meshes() without forwarding method-specific settings. This blocks users from applying required settings (e.g., CoACD threshold migration) through ModelBuilder.add_usd() while respecting USD-author

  ⚡ USD-driven collider approximation must allow method-specific knobs; otherwise migrations and fidelity fixes are blocked at the ingestion layer.

• Python-scope calls reject wp.Function parameters

  github:NVIDIA/warp7/12/2026▲ 1tooling-dxwarppython-apitype-inferencewp-funcdeveloper-experiencefunctional-programming

  Calling an @wp.func from Python fails when a parameter is annotated as wp.Function, even though the same call works inside a kernel. The error indicates Warp cannot infer the argument type for a Function object in Python scope.

  ⚡ Ergonomic parity between Python-scope and kernel-scope function calls is key for rapid prototyping and testability of Warp logic.

• [Bug Report] Duplicate imported classes

  github:isaac-sim/IsaacLab7/14/2026tooling-dxisaac-labpython-importsimulationappreproducibilityconfigstype-system

  Depending on SimulationApp startup/import order, Isaac Lab classes can be imported twice and end up with mismatched parent classes. This breaks type checks (e.g., config objects failing isinstance) and can cause subtle downstream failures.

  ⚡ Import/initialization determinism in Isaac Lab needs hard guarantees to keep large-scale training and evaluation pipelines reproducible.

• MjSpec.to_xml changes joint/state-vector ordering after attach round-trip

  github:google-deepmind/mujoco7/14/2026integrationmujocomjcfmodel-editingroundtripstate-vectorjoint-ordering

  MuJoCo's MjSpec.to_xml() can change joint/state-vector ordering after exporting and re-importing modular MJCF using asset/model and attach. This breaks assumptions about stable state ordering across a round-trip.

  ⚡ Round-trip integrity across modular model composition is a prerequisite for trustworthy sim-based validation and long-lived robot assets.

• Handle empty mesh decomposition results as failures

  github:newton-physics/newton7/14/2026asset-pipelinenewtonasset-importconvex-decompositionvhacdcoacderror-handling

  approximate_meshes() silently treats an empty CoACD/V-HACD decomposition as success and leaves meshes unchanged. It neither warns nor raises even when raise_on_failure=true, violating the documented fallback/contract.

  ⚡ Robust convex decomposition with explicit failure modes is critical for scalable asset ingestion and reliable physics behavior.

• USD decoder can change inferred mass/inertia for explicit body inertials and visual-only geoms

  github:google-deepmind/mujoco7/13/2026integrationmujocousdmass-propertiesinertiaroundtripinterchange

  MuJoCo's USD decoder can change inferred mass/inertia even when bodies have explicit inertials and there are visual-only geoms. This breaks MJCF->USD->MuJoCo validation that compares compiled inertials and deterministic rollouts.

  ⚡ USD interchange must preserve physical parameters deterministically; otherwise cross-tool pipelines cannot be trusted for regression testing.

• Durable articulation ordering replay contract: checkpoint metadata and a from_checkpoint resolution mode

  github:isaac-sim/IsaacLab7/13/2026training-infraisaac-labcheckpointingreplayarticulation-orderingcross-backendperformance

  Isaac Lab's articulation ordering relies on symbolic convention inference at env creation, which is fragile to backend default changes and adds ~9.3% startup cost. The issue proposes storing ordering metadata in checkpoints and adding a from_checkpoint resolut

  ⚡ Checkpoint replay must encode concrete ordering/permutation metadata to guarantee cross-backend reproducibility and reduce startup overhead.

• [BUG] Newton Warp renderer leaks deformable geometry across envs in multi-env tiled camera output

  github:newton-physics/newton7/13/2026renderingnewtonwarp-rendererrenderingsynthetic-datamulti-envdeformables

  Newton Warp renderer leaks deformable geometry across environments in multi-env tiled camera output, causing env_3 geometry to appear in env_0. The root cause is deformable raytracing sourcing global particle buffers without per-world scoping.

  ⚡ Multi-env rendering isolation is critical for synthetic data and tiled cameras; cross-world leakage invalidates datasets and visual regression.

• [BUG] Stabilize and share signed twist-angle reconstruction

  github:newton-physics/newton7/9/2026crashes-stabilitynewtonwarpquaternionsjoint-coordinatesnumerical-stabilitysmall-angles

  Newton reconstructs signed revolute joint coordinates using acos(twist[3]) which becomes zero in float32 for small rotations, creating a dead zone and discontinuity. The signed information exists in the quaternion vector but is lost by the acos path.

  ⚡ Kinematics reconstruction needs stable signed-angle extraction to avoid control dead zones that degrade manipulation/locomotion performance.

• Flaky test recurrence: test_stacked_small_primitive_cubes_hydroelastic_mujoco_warp_cuda_0

  github:newton-physics/newton7/9/2026crashes-stabilitynewtonciflaky-testsmujocowarpcuda

  A previously tracked flaky GPU test failed again with intermittent 'nefc overflow' warnings suggesting increasing njmax. The recurrence indicates instability or nondeterminism in hydroelastic MuJoCo Warp CUDA testing.

  ⚡ Deterministic, warning-free test baselines are important because solver buffer overflows can mask real regressions and destabilize CI.

• Flaky test: test_mujoco_hydroelastic_penetration_depth_cuda_0

  github:newton-physics/newton7/9/2026crashes-stabilitynewtonciflaky-testsmujocohydroelasticcuda

  GPU test test_mujoco_hydroelastic_penetration_depth_cuda_0 is flaky, failing with a ratio too low in one merge-queue run while later passing. The instability needs investigation to make outcomes reliable.

  ⚡ GPU test reliability is a prerequisite for fast iteration; nondeterministic physics metrics undermine confidence in improvements.

• [BUG] Inverse dynamics tests flaky

  github:newton-physics/newton7/9/2026crashes-stabilitynewtonciflaky-testsinverse-dynamicscuda

  Inverse dynamics tests are intermittently failing in the merge queue and are reported as flaky. The failures need root-cause analysis to stabilize CI coverage.

  ⚡ Inverse dynamics correctness and determinism are essential building blocks for control stacks and differentiable robotics workloads.

• Make deterministic kernel record bounds maintainable

  github:newton-physics/newton7/9/2026training-infranewtondeterminismatomicsmemory-allocationkernels

  Deterministic kernel record bounds (deterministic_max_records) are fragile: under-sizing breaks correctness while conservative bounds waste memory. The issue requests a maintainable way to derive/declare bounds with regression coverage.

  ⚡ Determinism infrastructure must scale with kernel evolution, otherwise memory over/under-allocation becomes a recurring source of regressions.

• parse_usd: custom-frequency traversal does not honor ignore_paths

  github:newton-physics/newton7/8/2026asset-pipelinenewtonusdimportparse-usdignore-pathsapi-consistency

  parse_usd's custom-frequency traversal does not honor ignore_paths while other traversals do. This causes prims that should be ignored to be processed during the custom-frequency pass.

  ⚡ Import filtering must behave consistently across traversal modes to keep large USD stages manageable and reproducible in automated pipelines.

• Support deformable (cloth and soft body) resets in SolverVBD.reset()

  github:newton-physics/newton7/8/2026feature-requestsnewtonvbdresetdeformablesclothsoft-body

  SolverVBD.reset() currently resets rigid bodies, joints, and cables but explicitly does not reset deformables (cloth/soft bodies). The request is to support masked deformable resets by copying model particle state back into solver state.

  ⚡ First-class reset semantics for deformables are required to support RL-style episodic training and reproducible benchmarking with cloth/soft bodies.

• [BUG] test_reset_functionality_elliptic_cuda_0 is flaky

  github:newton-physics/newton7/8/2026crashes-stabilitynewtonciflaky-testsresetmujoco-warpcuda

  test_reset_functionality_elliptic_cuda_0 is flaky, intermittently hitting the solver's 100-iteration cap after resetting state. Failures occur in merge-queue GPU runs and correlate with a MuJoCo Warp solver upgrade noted in the report.

  ⚡ Reset determinism in physics tests is essential because reset loops are the backbone of episodic learning and regression testing.

• Honor pre-existing `PM_PYTHON_EXT` in Packman environment

  github:NVIDIA/warp7/8/2026▲ 1integrationintegrationwarp

  Warp's build script overwrites any pre-existing `PM_PYTHON_EXT` when constructing the Packman environment, preventing users from pointing Packman at a different Python. The fix is to reverse the merge order so existing environment values are honored.

  ⚡ Cross-compilation and hermetic build flows require build tooling to respect user-specified interpreters and environments to support edge platforms cleanly.

• Investigate VBD cloth quality and performance gap in teleoperation

  github:newton-physics/newton7/14/2026crashes-stabilitynewtonteleoperationclothvbdphysxprofiling

  A Newton teleoperation workload with two-way coupled MJWarp robot and VBD cloth runs ~10+ FPS versus 18–20 FPS on PhysX after initial optimization. The hypothesis is VBD needs more substeps for comparable cloth quality, requiring profiling to isolate physics c

  ⚡ Teleop workloads expose real-time physics/performance gaps that will directly impact interactive robot development and validation loops.

• Hydroelastic contact uses a single-body secant for `(k, φ₀)` instead of the series gradient

  github:newton-physics/newton7/13/2026manipulationnewtonhydroelastic-contactcontact-modelingcompliancesdfsolver-stability

  Newton hydroelastic contact forms (k, φ0) for penetrating faces using a single-body secant from one SDF rather than the series gradient described in the referenced velocity-level pressure-field model. This may yield incorrect solver parameters even if face for

  ⚡ Accurate compliant contact parameterization is key to stable contact-rich manipulation and to matching real dynamics across simulators.

• [BUG] Newton-nut_bolt_sdf example QA failure

  github:newton-physics/newton7/13/2026manipulationnewtonexamplescontact-richthreaded-assemblyxpbdmujoco-solver

  Newton nut_bolt_sdf example fails QA because nuts move jitterily instead of slow and controlled under both xpbd and mujoco solvers. No stderr or crash occurs, but expected physical behavior is not met.

  ⚡ Contact-rich threaded assembly is a high-sensitivity regression target; instability here signals gaps in solver/contact tuning for manipulation.

• [BUG] Newton-cloth_poker_cards example QA failure

  github:newton-physics/newton7/13/2026crashes-stabilitynewtondeformablesclothstabilityperformanceqa

  Newton cloth_poker_cards example fails QA: the card stack remains bouncy and never settles after impact. Performance is ~2.5 FPS on an RTX 3080 Laptop GPU.

  ⚡ Deformable stability and throughput are gating for synthetic data generation and interactive workflows that rely on real-time preview.

• [BUG] Newton example replay_viewer failed QA testing

  github:newton-physics/newton7/13/2026crashes-stabilitynewtonreplayhumanoidbroadphasecontact-buffersdeterminism

  Newton replay_viewer example fails QA because replayed humanoid bodies penetrate/fall through the ground. The recording run emitted repeated broadphase overflow/contact-capacity warnings, suggesting insufficient buffers as a possible cause.

  ⚡ Replay determinism requires capacity planning and robust contact/broadphase handling, or recorded artifacts won’t be trustworthy for regression.

• [BUG] Newton-basic_shapes example (VBD variant) not showing realistic friction behavior

  github:newton-physics/newton7/13/2026crashes-stabilitynewtonvbdxpbdfrictionphysics-validationexamples

  Newton basic_shapes passes under xpbd but fails under vbd because ground friction appears effectively absent for non-round objects, causing ice-like sliding. This contradicts expected behavior in the sample.

  ⚡ Friction realism must be consistent across solvers; otherwise task transfer and user trust degrade for manipulation and locomotion benchmarks.

• custom @wp.func_grad that needs more shared memory than its forward

  github:NVIDIA/warp7/11/2026renderingrenderinghardwarewarp

  Warp under-allocates shared memory for a custom backward kernel when the backward requires more shared memory than the forward. This leads to out-of-bounds shared memory writes and CUDA error 700, while CPU appears to tolerate it.

  ⚡ Differentiable simulation workloads need reliable backward-kernel resource accounting, or CUDA-only failures will erode trust in GPU-first pipelines.

• Make the copy "Incompatible array data types" error show data types

  github:NVIDIA/warp7/10/2026otherwarp

  Warp’s wp.copy type mismatch error does not show the source and destination dtypes. Users must add extra debugging to determine what types are incompatible.

  ⚡ Improving error observability in core compute libraries reduces iteration time and support load for robotics developers.

• Fix freeing memory while a conditional body graph is captured

  github:NVIDIA/warp7/10/2026renderingrenderinghardwarewarp

  Freeing a CUDA array while capturing a conditional body graph can add a mem-free node to the wrong CUDA graph. This triggers cudaGraphAddMemFreeNode failures (cudaErrorInvalidValue) and breaks capture workflows.

  ⚡ Graph capture correctness is foundational for performant robotics stacks; capture-edge bugs can negate the value of graph-based acceleration.

• Add a design document for API Capture and CPU Graphs

  github:NVIDIA/warp7/10/2026training-infrarlhardwaredocsnewtonwarp

  Users request a design document covering API Capture, serialized .wrp graphs, and CPU capture/replay. The feature set has expanded enough that code and user guide usage examples are not sufficient to understand behavior and constraints.

  ⚡ As Warp’s capture/graph system grows, lack of design-level documentation becomes a scaling bottleneck for adoption and ecosystem contributions.

• IsaacSim ERROR_OUT_OF_DEVICE_MEMORY on Nvidia L4 GCP Setup

  github:isaac-sim/IsaacSim7/10/2026asset-pipelineusdrenderinghardwareintegrationisaac-sim

  User hits ERROR_OUT_OF_DEVICE_MEMORY on a GCP setup using an NVIDIA L4 while following the recommended Isaac Sim cloud setup guide. The issue occurs with both compiled-from-source and precompiled binaries, preventing progress.

  ⚡ Cloud GPU deployment needs clearer memory sizing and guardrails, or Isaac Sim adoption stalls at first-run failures.

• [BUG] Resetting example admm_contact_solver leads to illegal memory access

  github:newton-physics/newton7/10/2026crashes-stabilitycrashrenderinghardwarenewtonwarp

  The `admm_contact_solver` example sometimes crashes when clicking the UI "Reset" button, with Warp CUDA error 700 illegal memory access. The crash is intermittent and can occur after several resets.

  ⚡ UI-driven reset/switch paths must be hardened; intermittent illegal memory accesses are especially damaging for developer trust in simulation tooling.

• [BUG] add_triangles misaligns tri_areas after filtering degenerate elements

  github:newton-physics/newton7/10/2026renderingrenderingnewtonwarp

  ModelBuilder.add_triangles() filters degenerate faces but keeps tri_areas unfiltered, misaligning areas with stored triangles. This causes valid triangles to read the wrong (e.g., zero) area and can also produce length errors after partially mutating core arra

  ⚡ Geometry import correctness (including per-element attributes) is essential for reliable SDF/contact behavior and consistent downstream simulation.

• [BUG] add_particles accepts inconsistent array lengths and produces invalid models

  github:newton-physics/newton7/10/2026hardware-integrationhardwarenewtonwarp

  ModelBuilder.add_particles() allows inconsistent array lengths across positions/velocities/masses/etc., producing an invalid model that still finalizes. This can yield non-finite state on CPU and potential out-of-bounds reads on CUDA; inputs should be validate

  ⚡ Model builders must be fail-fast and structurally consistent to keep physics stable and avoid GPU out-of-bounds reads in production pipelines.

• [BUG] ArticulationView accepts invalid masks that can trigger CUDA illegal memory access

  github:newton-physics/newton7/10/2026renderingrenderinghardwarenewtonwarp

  ArticulationView accepts invalid boolean masks without validating shape/device, and a subsequent kernel may read out of bounds. An empty CUDA mask can trigger CUDA illegal memory access (error 700) and poison the CUDA context.

  ⚡ Robust input validation in high-level views is critical to prevent CUDA context-poisoning crashes that disrupt long-running training jobs.

• [BUG] Examples of modifying ViewerGL camera speed fail due to _cam_speed being moved to ViewerGUI

  github:newton-physics/newton7/9/2026hardware-integrationhardwaresensorsnewtonwarp

  Examples that adjust ViewerGL camera speed fail because _cam_speed moved from ViewerGL to ViewerGUI in Newton v1.3.0. The example uses hasattr checks that no longer find the attribute, making small-scale scenes hard to view.

  ⚡ Keeping examples in sync with API changes is essential to reduce onboarding friction and avoid users copying broken patterns.

• Stabilize `wp.quat_twist_angle()` near zero and add a signed variant

  github:NVIDIA/warp7/9/2026hardware-integrationhardwaredocsnewtonwarp

  wp.quat_twist_angle() uses acos on the twist scalar component, which rounds to 1.0 in float32 near zero, producing a dead zone and discontinuity. Request is to stabilize behavior near zero and add a signed variant.

  ⚡ Stable small-angle rotation utilities are foundational for robot kinematics/dynamics; numerical dead zones propagate into controllers and learning signals.

• Heap-buffer-overflow during APIC capture of padded bsr_set_transpose

  github:NVIDIA/warp7/9/2026hardware-integrationhardwarewarp

  APIC capture of a padded bsr_set_transpose intermittently triggers heap corruption in CI (glibc free invalid next size) and AddressSanitizer reports a heap-buffer-overflow. The crash breaks the process pool and fails the job.

  ⚡ Capture/replay infrastructure must be memory-safe under all operator variants; CI-detected heap corruption is a critical reliability risk.

• [BUG] kamino_mujoco_admm_solver truncates contacts

  github:newton-physics/newton7/9/2026integrationnewtonkaminomujococontactslimitsadmm

  kamino_mujoco_admm_solver logs warnings that Newton rigid_contact_max exceeds Kamino model_max_contacts_host, causing contact truncation. Defaults should be aligned to prevent unexpected truncation in the example.

  ⚡ When integrating with external stacks, mismatched default limits can silently degrade results and confuse users; defaults must be coordinated.

• [BUG] robot_ur10 with 32 worlds has robots colliding with their base

  github:newton-physics/newton7/9/2026environment-designnewtonur10multi-worldinitializationcollisionsexamples

  Running robot_ur10 with 32 worlds shows some robot instances visually colliding with their base. This suggests an issue with initial placement, joint configuration, or collision setup when scaling world count.

  ⚡ Multi-world scaling needs careful initialization and collision filtering; self-collisions at higher world counts erode confidence in batched simulation.

• [BUG] examples vbd_soft_rigid_contact has low framerate

  github:newton-physics/newton7/9/2026training-infranewtonvbdperformancewindowsexamplescontact

  The vbd_soft_rigid_contact example runs at around 7 fps on Windows 11 with an A6000. Performance is too low for comfortable use.

  ⚡ Low framerate in baseline contact demos reduces iteration speed and limits usefulness for profiling, education, and data generation.

• [BUG] examples rigid_soft_contact has a low framerate

  github:newton-physics/newton7/9/2026training-infranewtonperformancewindowssoft-bodycontactexamples

  The rigid_soft_contact example runs at around 20 Hz on Windows 11 with an A6000. The reporter notes the framerate does not look good at this speed.

  ⚡ Interactive performance of soft-rigid demos impacts developer productivity and perceived viability for real workloads.

• [Question] Point cloud generation fails in the camera output example because camera pose fields become zero/NaN

  github:isaac-sim/IsaacLab7/8/2026crashes-stabilitycrashusdsensorsdocsisaac-simisaac-lab

  In Isaac Lab camera output example, point cloud generation fails because camera pose fields become zero/NaN. The report uses Isaac Lab main with Isaac Sim 5.1 and the documented camera output tutorial script.

  ⚡ Sensor output correctness (camera pose integrity) is critical because downstream perception (e.g., point clouds) is a primary training signal.

• [BUG] test_friction_ramp_mujoco_warp_cuda_0 is flaky

  github:newton-physics/newton7/8/2026crashes-stabilitynewtonfrictionmujoco-warpcudaci-flakinesscontact-dynamics

  A MuJoCo Warp CUDA friction ramp test failed on an unrelated change, indicating intermittent behavior. The issue asks to investigate the cause of the flakiness in this GPU test.

  ⚡ Persistent GPU test flakiness in friction/contact scenarios weakens our ability to validate improvements in contact models used by Physical AI training.

• Require VBD contact history preallocation for CUDA graphs

  github:newton-physics/newton7/8/2026deploymentnewtoncuda-graphssolver-vbdcollision-pipelinepreallocationruntime-error

  With rigid_contact_history enabled, constructing CollisionPipeline after SolverVBD prevents the solver from knowing contact capacity at init, causing issues for CUDA graphs. The proposed change raises a targeted RuntimeError instructing users to construct in t

  ⚡ CUDA graph capture in simulation needs explicit capacity contracts between collision and solver components to be dependable for high-throughput training and deployment.

• [Bug Report] VS Code Setup Guide: `extraPaths` setting in *settings.json* conflicts with `pyproject.toml`

  github:isaac-sim/IsaacLab7/12/2026docs-onboardingv6.0.1isaac-labvscodewindowsonboardingpylancepyproject-toml

  On Windows with Isaac Sim 6.0.1 prebuilt binaries, the VS Code setup task generates python.analysis.extraPaths that conflicts with pyproject.toml in a newly created Isaac Lab project. This produces a VS Code/Pylance configuration conflict rather than a clean s

  ⚡ Editor/tooling setup must be conflict-free to reduce onboarding friction and support Windows developers reliably.

• Changing CPU compiler flags causes PCH errors

  github:NVIDIA/warp7/12/2026tooling-dxwarpcpucompilationpchclangcache

  Changing Warp CPU compiler flags between modules in the same process triggers Clang target-feature errors and forces Warp to discard PCH and recompile without it. Tests pass but compilation becomes slower and logs misleading errors.

  ⚡ Compilation cache correctness (e.g., PCH keys) directly impacts iteration speed for users building custom CPU kernels and extensions.

• LeRobot v0.6.0 Adds World Models, Reward Models, and an Open GR00T

  hn:gr00t7/9/2026▲ 1othergrootlerobot

  A Hacker News item highlights LeRobot v0.6.0 adding world models, reward models, and an open GR00T. No further details are provided in the corpus entry.

  ⚡ Ecosystem moves toward world/reward models and open robot foundations increase pressure to integrate simulation and data pipelines with emerging open stacks.

• Kamino: Extract policy & other logic from `example_rl_drlegs` into main DR Legs example

  github:newton-physics/newton7/13/2026docs-onboardingnewtonexamplesrlonnxtorchbenchmarking

  Policy logic from an internal Kamino RL drlegs example should be moved into the main DR Legs example with a CLI switch for policy vs standalone. The request prefers moving to ONNX to avoid a torch dependency and to align the benchmark with the example.

  ⚡ Reducing heavyweight dependencies and consolidating examples lowers adoption friction and makes benchmarks more portable.

• Re-enable test_friction_ramp_mujoco_warp_cuda_0

  github:newton-physics/newton7/13/2026crashes-stabilitynewtontestingregressionfrictionmujocowarp

  A previously disabled friction ramp test (mujoco_warp_cuda_0) needs follow-up to be re-enabled. The issue provides no additional details beyond the re-enable request.

  ⚡ Keeping key physics regression tests enabled is essential to prevent silent behavior drift across solver and GPU backends.

• Support stretch, shear, bend, and twist stiffness in USD cable import

  github:newton-physics/newton7/12/2026asset-pipelineusd

  USD cable import currently applies only stretch and bend stiffness mappings while ignoring parsed shear and twist stiffness when building the rod. The builder falls back to defaults (shear=stretch, twist=bend) and emits a warning, leading to incorrect cable be

  ⚡ USD import fidelity for deformables/cables is key to reuse real production assets and maintain consistent physical behavior across tools in the Physical AI ecosystem.

• OnPlaybackTick-driven ROS2 camera OmniGraph added as `over` on payload-referenced robot stops publishing after 1-2 frames (render product/data valid, ROS2CameraHelper output stalls)

  github:isaac-sim/IsaacSim7/10/2026asset-pipelinev5.1.0usdrenderinghardwaredeploymentsensorsperception

  A ROS2 camera OmniGraph driven by OnPlaybackTick stops publishing after 1–2 frames when added as an `over` on a payload-referenced robot. Render products and image data appear valid, but ROS2CameraHelper output stalls.

  ⚡ ROS2 sensor streaming must be robust to common USD composition patterns (payloads/over) to be credible for real robot integration.

• Support compiling kernels from a string

  github:NVIDIA/warp7/10/2026other

  Warp kernels currently must live in a .py file tied to a module, limiting CLI one-liners and dynamically generated kernels. Users want first-class support for compiling kernels from strings without exec-based workarounds.

  ⚡ More flexible kernel authoring enables faster experimentation and better alignment with agentic/devtool workflows.

• Add efficient CPU block execution with fibers

  github:NVIDIA/warp7/10/2026hardware-integrationhardware

  Request to support block_dim > 1 on CPU with CUDA-like block semantics, including shared tile state and barriers. Proposal suggests implementing cooperative fibers per block to preserve correctness while improving efficiency.

  ⚡ Closing CPU/GPU semantic gaps (block/thread behavior) broadens Warp’s utility for debugging, CI, and CPU-only deployments.

• USD decoder misses physics-purpose material bindings on colliders

  github:google-deepmind/mujoco7/10/2026asset-pipelineusdrenderingdocsintegrationmujoco

  MuJoCo’s USD decoder misses physics-purpose material bindings on colliders when different materials are used for visual vs physics purposes. This breaks contact property preservation in MJCF↔USD roundtrip validation.

  ⚡ USD physics material semantics must roundtrip correctly across engines or USD becomes a weak link in sim asset portability.

• USD decoder does not preserve sites, model names, unlimited joints, and disabled-collider metadata

  github:google-deepmind/mujoco7/10/2026crashes-stabilitycrashusddocsintegrationmujoco

  MuJoCo’s USD decoder does not preserve several semantics needed for roundtrip validation: sites, model names, unlimited joints, and disabled-collider metadata. This undermines compiled-model comparisons and deterministic rollouts after import.

  ⚡ Metadata and semantic preservation in USD import/export is critical for deterministic validation and trustworthy cross-sim workflows.

• sample/compile cannot load USD decoder plugins without manual plugin registration

  github:google-deepmind/mujoco7/10/2026asset-pipelineusdintegration

  MuJoCo’s sample/compile cannot load USD decoder plugins unless the plugin is manually registered/loaded. Users want the sample to auto-load plugins from standard build/install directories before parsing.

  ⚡ Plugin discoverability and sensible defaults are key to making USD-based pipelines usable from the command line and in CI.

• Cached non-deterministic kernels retain deterministic launch metadata

  github:NVIDIA/warp7/10/2026renderingrenderinghardwarewarp

  Warp can retain deterministic launch metadata when switching to a cached non-deterministic kernel variant of the same module. This results in incorrect execution (e.g., counters run twice), and reproduces only with a warm disk cache.

  ⚡ Determinism controls must be airtight across caching boundaries to keep training/validation metrics trustworthy.

• [BUG] Cube passes through chain in example mujoco_xpbd_coupled_solver

  github:newton-physics/newton7/10/2026othernewtonwarp

  In the mujoco_xpbd_coupled_solver example, the chain falls through the cube without interacting, indicating broken collision/constraint coupling. The provided repro uses newton[examples]==1.4.0.rc1 and Warp 1.15.0 on Windows.

  ⚡ Contact/constraint regressions in example stacks can quickly damage confidence in coupled-solver reliability for robotics workloads.

• [BUG] mujoco_mpm_coupled_solver particles appear stuck in the air

  github:newton-physics/newton7/10/2026othernewtonwarp

  In the mujoco_mpm_coupled_solver example, some particles appear stuck in mid-air and do not move. The repro is with newton[examples]==1.4.0.rc1 and Warp 1.15.0 on Windows.

  ⚡ MPM coupling issues in reference examples suggest solver correctness/performance gaps that can block adoption for deformables/fluids.

• [BUG] Example kamino_mujoco_admm_solver warns about truncated contacts

  github:newton-physics/newton7/10/2026hardware-integrationhardwaremujoconewtonwarp

  The kamino_mujoco_admm_solver example consistently warns about truncated contacts. The log indicates this happens in a typical setup (Warp 1.15.0 on A40), suggesting defaults or limits are easy to exceed.

  ⚡ If default example configurations routinely hit contact truncation, users will question solver robustness and parameterization guidance.

• [REQ] Support different no. of articulations per world

  github:newton-physics/newton7/10/2026othernewtonfigure

  Request to support different numbers of articulations per world and provide flat views of articulation data for homogeneous and heterogeneous cases. Current returned shapes are centered on (num_world, num_articulation, data), which is limiting.

  ⚡ Scaling to realistic training setups requires flexible batching APIs that handle heterogeneous per-world composition without forcing identical topologies.

• [REQ] Supporting different number shapes be accepted in selection API

  github:newton-physics/newton7/10/2026other

  Selection API currently requires articulations to be identical including shape counts, rejecting some heterogeneity that may be unnecessary (e.g., visual shape differences). Request is to accept different shape counts where safe and leave subtle collider diffe

  ⚡ Relaxing unnecessary homogeneity constraints in selection/view APIs improves scalability and asset diversity for simulation-based training.

• [BUG] SolverStyle3D produces NaNs for active zero-mass particles

  github:newton-physics/newton7/10/2026renderingrenderingnewtonwarp

  SolverStyle3D can generate NaNs when active particles have zero mass (e.g., isolated vertices left after face filtering). The init step divides by mass for ACTIVE particles without guarding against zero, so zero-mass particles should be fixed and finite.

  ⚡ Numerical robustness around edge cases (e.g., zero mass) is required for stable cloth/soft-body pipelines used in manipulation and contact learning.

• [BUG] ControllerPID masked reset may launch on the wrong Warp device

  github:newton-physics/newton7/10/2026renderingrenderinghardwarenewtonwarp

  ControllerPID.State.reset(mask) launches a kernel without specifying a device, so it may run on CPU even when inputs are on CUDA. This can cause a crash (exit code 139) instead of resetting masked entries, and should validate mask compatibility up front.

  ⚡ Device correctness (CPU vs CUDA) must be enforced consistently to prevent hard crashes in robotics control components built atop Warp.

• Add configurable USD purpose filtering to Newton viewers

  github:newton-physics/newton7/9/2026asset-pipelineusdrenderingmujoconewton

  Newton viewers currently apply viewport-style USD purpose defaults (show default/proxy; hide guide/render) with no user override. Request is to add configurable purpose visibility so users can reveal guide geometry (e.g., MuJoCo sites) or hide other purposes.

  ⚡ Viewer-level controls for USD purpose filtering improve debugging and inspection of converted assets without requiring stage edits.

• [BUG] examples cable_bundle_hysteresis renders cables as a single uniform color

  github:newton-physics/newton7/9/2026othernewton

  The cable_bundle_hysteresis example renders all cables as a uniform color with no variation, and some CLI options appear to have no effect. This makes the example confusing and possibly indicates a rendering/material or parameter wiring issue.

  ⚡ Example visual correctness matters because examples set user expectations and are often used as reference implementations.

• [BUG] proxy_joint_gripper soft object drifts from gripper over time

  github:newton-physics/newton7/9/2026renderingrenderinghardwaremanipulationnewton

  In the proxy_joint_gripper example, a deformable object drifts out of the gripper over time. The object should remain stably held after grasping rather than sliding away unexpectedly.

  ⚡ Stable grasp/contact behavior for deformables is crucial for manipulation credibility; drift undermines confidence in contact modeling and constraints.

• [BUG] xpbd_vbd_coupled_solver --solver vbd lets particles pass through

  github:newton-physics/newton7/9/2026renderingrenderinghardwarenewton

  In xpbd_vbd_coupled_solver running with `--solver vbd`, particles pass through unexpectedly. The baseline is expected to keep cloth/particles bounded and above ground.

  ⚡ Baseline solver modes must enforce non-penetration; otherwise they cannot serve as trustworthy references for learning and evaluation.

• [BUG] mujoco_vbd_coupled_solver --solver vbd has excessive floor penetration

  github:newton-physics/newton7/9/2026renderingrenderinghardwaremujoconewton

  In mujoco_vbd_coupled_solver with `--solver vbd`, there is excessive floor penetration. Rigid bodies and particles should not significantly penetrate the ground in a baseline configuration.

  ⚡ Contact quality in rigid/soft scenes is a core product claim; excessive penetration in baseline modes reduces trust in physics realism.

• [BUG] mujoco_franka_vbd_cable_admm_solver robot penetrates the floor

  github:newton-physics/newton7/9/2026environment-designnewtonmujocofrankascene-setuppenetrationexamples

  In mujoco_franka_vbd_cable_admm_solver, the Franka robot penetrates the floor. The example likely needs a placement adjustment and corresponding keypoint updates.

  ⚡ Out-of-box examples must be spatially and physically consistent so they can be used as reliable baselines and demos.

• [BUG] robot_policy go2 with PhysX reports narrowphase overflow warnings

  github:newton-physics/newton7/9/2026locomotionnewtongo2robot-policyphysxnarrowphasecontacts

  robot_policy go2 run with PhysX prints repeated narrowphase overflow warnings recommending higher nconmax/naconmax values. The example should be configured to avoid these warnings by default.

  ⚡ Policy examples must run cleanly across physics backends; persistent overflow warnings suggest brittle defaults for contact buffer sizing.

• [BUG] robot_policy go2 reports narrowphase overflow warnings

  github:newton-physics/newton7/9/2026locomotionnewtongo2robot-policynarrowphasecontactsexamples

  robot_policy go2 repeatedly logs narrowphase overflow warnings suggesting higher nconmax/naconmax. The example is expected to run without these warnings in its default configuration.

  ⚡ Clean, warning-free locomotion demos are important for adoption; repeated overflow warnings indicate default buffers are undersized for common scenes.

• [BUG] examples vbd_rigid_rigid_contact is hard to understand

  github:newton-physics/newton7/9/2026docs-onboardingnewtonexamplesdocumentationonboardingvbdvisualization

  A user reports the vbd_rigid_rigid_contact example is hard to understand and questions its value, noting it looks like simple wireframe shapes with unclear purpose. They ask for clarification on what is being shown and why.

  ⚡ Examples need clear intent and narrative to function as onboarding assets rather than confusing demos with unclear value.

• Array annotation `repr()` uses constructor form instead of subscript syntax

  github:NVIDIA/warp7/9/2026renderingrenderingwarp

  Warp array annotation repr() renders as a constructor-like string rather than subscript syntax, so it doesn't round-trip with eval(). This affects Sphinx autodoc return type rendering.

  ⚡ Small documentation/representation details in core libraries cascade into poor autogenerated docs, increasing onboarding time for developers.

• Semantic segmentation does not capture IRI SpillEvent PuddleGlass despite semantic label being applied

  github:isaac-sim/IsaacSim7/8/2026synthetic-datav6.0.1synthetic-datausdrenderinghardwareperceptionisaac-sim

  In Isaac Sim 6.0.1, a generated IRI SpillEvent puddle appears in RGB but is not captured in semantic segmentation even after applying semantic labels to the puddle mesh. The leaking source object is labeled correctly, but the generated spill is not.

  ⚡ Synthetic data generation must reliably label dynamic/generated assets (events, fluids) or users will lose trust in SDG pipelines for training.

• Streaming Client on Windows auto-resizes

  github:isaac-sim/IsaacSim7/8/2026renderingrenderinghardwaredeploymentintegrationisaac-sim

  Streaming Client 2.0 on Windows auto-resizes when OS scaling is set to 125%, producing an oversized GUI despite a requested 1920x1080 resolution. Logs indicate dynamic resize adjustments due to alignment and constraint requirements.

  ⚡ Remote/streaming UX issues create avoidable friction for enterprise users who rely on streaming clients for lab access and demos.

• Add missing SolverXPBD API docstrings

  github:newton-physics/newton7/8/2026docs-onboardingnewtonxpbddocsapi-docssolver

  SolverXPBD lacks docstrings for constructor parameters and several user-facing methods. The issue requests comprehensive Google-style Args documentation and method docstrings.

  ⚡ High-quality API docs reduce support burden and accelerate adoption, especially for solver-level classes with many parameters and units.

• Validate Isaac Sim's force-based conveyor model with Newton solvers

  github:newton-physics/newton7/13/2026integrationisaac-simnewtonwarpconveyorcontact-forcesvalidation

  The request is to validate Isaac Sim’s force-based conveyor formulation (Warp kernels applying friction-limited tangential forces from contact impulses) using Newton solvers. Newton’s current conveyor example uses a rotating belt mesh and ordinary friction and

  ⚡ Aligning force-based interaction models across Isaac Sim and Newton improves portability of industrial workflows and reduces duplicated implementations.

• [Performance; Model editing] Batch adding of bodies/geoms/etc.

  github:google-deepmind/mujoco7/12/2026feature-requestsmujocoperformancemodel-editingapiprocedural-generationlarge-scenes

  MuJoCo's C model-editing API adds items one at a time and recomputes signature each time, which is painfully slow for large worlds. The request is for batch adding bodies/geoms/etc. to avoid repeated expensive recomputation.

  ⚡ High-throughput scene/model editing APIs matter for large procedural worlds and synthetic-data generation pipelines.

• [REQ] Warn when CollisionPipeline auto-sizes a very large rigid contact buffer

  github:newton-physics/newton7/8/2026tooling-dxnewtoncollision-pipelinecontactsmemorywarningsdx

  Request to warn when CollisionPipeline auto-sizes a very large rigid contact buffer allocation. The warning should include the resolved slot count/bytes, drivers (pair count, world count), and remediation (set rigid_contact_max explicitly).

  ⚡ Transparent resource sizing warnings help users avoid surprise OOMs and better tune simulations for large-batch training.