Daily Digest

Loading brief…

• VBD and SemiImplicit record-buffer limits in deterministic mode

  github:newton-physics/newton11/1/2026crashes-stabilitynewtonwarpdeterminismcuda-graph-capturememory-usagevbd

  Deterministic mode uses overly conservative record-buffer bounds that can require multiple GBs and prevent CUDA graph capture for larger cloth scenarios. SemiImplicit triangle-particle contact can exceed Warp’s 32-bit record-buffer limit under graph capture fo

  ⚡ Determinism features that blow up memory or hit record-buffer limits undermine scalable, repeatable simulation workflows needed for Physical AI training and validation.

• SolverMuJoCo: use MuJoCo Warp's native determinism mode

  github:newton-physics/newton11/1/2026integrationnewtonwarpmujoco-warpdeterminismcompilationkernel-cache

  Newton’s approach to forcing Warp deterministic mode onto MuJoCo Warp modules no longer compiles with Warp 1.19 due to kernels that both read and atomically update the same array. Determinism tests are skipped, and the proposed direction is to map to MuJoCo Wa

  ⚡ Determinism that breaks across dependency versions undermines confidence in reproducible simulation pipelines central to NVIDIA’s Physical AI platform.

• [Jetson Thor / T264] MGBE RX data corruption with "dma-coherent" - is MGBE really IO-coherent?

  nvidia-forum:robotics-edge-computing11/2/2026▲ 3hardware-integrationjetson-thort264mgbeethernetdma-coherentio-coherency

  Reports MGBE RX data corruption on Jetson Thor/T264 when using the "dma-coherent" setting, questioning whether the MGBE path is truly IO-coherent. This can break reliable high-speed Ethernet receive on the platform.

  ⚡ Edge-network I/O coherency issues directly undermine deterministic, high-throughput robot data pipelines needed for on-device Physical AI.

• Kernel requests too little shared memory when it moves a tile returned by a `wp.func` to shared storage

  github:NVIDIA/warp11/11/2026crashes-stabilitywarpcudashared-memorytilekernelillegal-memory-access

  Warp CUDA kernels that call a wp.func returning a tile can under-request dynamic shared memory when the tile is later moved to shared storage (e.g., via wp.tile_broadcast). This can silently corrupt results or trigger illegal memory accesses depending on other

  ⚡ Correct CUDA shared-memory sizing in Warp kernels is critical for trustworthy high-performance simulation and differentiable workloads in Physical AI pipelines.

• [BUG] Actuator gradients are wrong with several steps on one tape

  github:newton-physics/newton11/11/2026crashes-stabilitynewton-physicswarpautodiffgradientstapeactuator

  Newton Actuator steps reuse internal buffers, so recording multiple steps on one wp.Tape causes later steps to overwrite data needed for earlier backward passes. This produces incorrect gradients for multi-step tapes, especially when nonlinear components are i

  ⚡ Correct differentiable physics gradients are essential for training and optimization loops that underpin Physical AI control and design workflows.

• Custom AGX Orin Carrier board stuck at UEFI

  nvidia-forum:robotics-edge-computing11/11/2026hardware-integrationjetson-agx-orincarrier-boarduefibootbringuphardware-debug

  A custom Jetson AGX Orin carrier board is stuck at UEFI. This prevents booting into the OS and blocks any further software setup or deployment work.

  ⚡ Robust bring-up on custom carrier boards is key to making NVIDIA edge platforms viable for real-robot deployments.

• [BUG] wp.Mesh crashes on out-of-range triangle indices

  github:NVIDIA/warp11/10/2026crashes-stabilitywarpmeshsegfaultbounds-checkinggeometrycpu

  Warp wp.Mesh() does not bounds-check triangle indices and can segfault on CPU with out-of-range or negative indices. Mesh.refit() and assigning Mesh.points can also crash because they read through indices without validation.

  ⚡ Hard crashes from invalid geometry inputs erode developer confidence and complicate productionizing simulation and geometry pipelines.

• [REQ] Make wp.sparse.bsr_mm differentiable (tape.backward currently crashes)

  github:NVIDIA/warp11/10/2026training-infrawarpsparsebsr-mmautodifftapecrash

  Recording warp.sparse.bsr_mm on a Tape causes tape.backward() to crash due to indexedarray lacking .grad. Even without the crash, kernels are compiled with enable_backward=False, so gradients would be missing.

  ⚡ Differentiable sparse linear algebra is foundational for scalable optimization and learning pipelines that rely on structured physics and constraints.

• Lossless H264/H265 (NV24/4:4:4) fails on high-entropy frames due to hardcoded 1.5*W*H buffer cap in libtegrav4l2/libnvvideo

  nvidia-forum:robotics-edge-computing11/10/2026crashes-stabilitynvidia-forumrobotics-edgeh264h265lossless-videonv24

  Lossless H264/H265 in NV24/4:4:4 fails on high-entropy frames due to a hardcoded 1.5*W*H buffer cap in libtegrav4l2/libnvvideo. This suggests certain frames exceed the cap, causing encode/decode failure for otherwise valid lossless use cases.

  ⚡ Hardcoded multimedia limits in edge platform libraries can break critical perception/video workflows and block deployment of high-fidelity sensor streams.

• Newton backend: no supported path to run-to-run determinism with contacts (6.2.0.1)

  github:isaac-sim/IsaacSim11/10/2026sim2realv6.2.0.1isaac-simisaac-sim-6-2-0-1newtondeterminismcontactswarp

  Isaac Sim 6.2.0.1 bundles Newton 1.6.1, which predates deterministic collision pipeline and solver APIs, leaving no supported way to get run-to-run determinism with contacts enabled. The issue notes that setting `wp.config.deterministic = RUN_TO_RUN` fails to

  ⚡ Lack of determinism with contacts blocks reliable regression testing and reproducible training/evaluation, weakening the platform’s credibility for physics-based Physical AI.

• [Bug Report] A depth-only RTX camera makes headless RGB cameras render black

  github:isaac-sim/IsaacLab11/10/2026renderingisaac-labheadlessrtx-camerasynthetic-datargbdepth

  In headless runs, creating a depth-only RTX camera causes all RTX RGB cameras to return black frames in the same process. The report attributes this to `IsaacRtxRenderer.create_render_data` setting a process-wide `/rtx/sdg/force/disableColorRender=True` and it

  ⚡ Process-wide renderer state leaks in headless mode can silently corrupt synthetic data generation and perception training pipelines at scale.

• ParticleField3DGaussianSplat turns one flat colour after Stop, then ERROR_DEVICE_LOST (Isaac Sim 6.0.1)

  github:isaac-sim/IsaacSim11/10/2026crashes-stabilityv6.0.1isaac-simgaussian-splattingparticlefield3dgaussiansplatrenderingdevice-lostplay-stop-cycle

  ParticleField3DGaussianSplat without a bound material can turn into a flat color after repeated Play/Stop cycles and later crash with ERROR_DEVICE_LOST. The issue reproduces using the public flowers_1 asset and appears tied to repeated Gaussian prim reload beh

  ⚡ Rendering stability issues that lead to device loss can halt simulation workflows and reduce confidence in Isaac Sim as a production-grade platform.

• [MJX] mjOption.disableactuator is ignored: actuators in a disabled group still produce force

  github:google-deepmind/mujoco11/10/2026othermujocomjxactuatorsoptions-bitfieldphysics-parityjax

  MJX ignores mjOption.disableactuator, so actuators in disabled groups still produce forces and update activation. This deviates from MuJoCo C behavior where disabled actuators are skipped in multiple engine stages.

  ⚡ Parity gaps between reference physics engines and accelerated backends can compromise reproducibility for Physical AI training and evaluation pipelines.

• Loaded APIC graphs crash on CPU and return zeros on CUDA when a kernel samples a texture

  github:NVIDIA/warp11/10/2026crashes-stabilitywarpapicgraph-captureserializationtexture2dcuda

  APIC graphs that include texture sampling save successfully but fail after reload in a new process: CUDA returns zeros and CPU crashes. The loaded graph only works when the original texture is still alive in the same process.

  ⚡ Graph serialization correctness is key for reproducible, portable compute pipelines that underpin Physical AI simulation and training workloads.

• Loaded APIC graph crashes when a kernel reads through a struct array's `wp.array` field

  github:NVIDIA/warp11/10/2026crashes-stabilitywarpapicgraph-captureserializationstruct-arraysillegal-memory-access

  APIC graphs that read through a struct array's wp.array field save but crash after reload in a new process (CUDA illegal memory access, CPU segfault). The graph only behaves correctly when loaded in the same process while original arrays remain alive.

  ⚡ Reliability of saved/loaded compute graphs affects deployability of accelerated components used across Physical AI workflows.

• Jetson orin nano 8gb SDRAM broken,hardware problem

  nvidia-forum:robotics-edge-computing11/10/2026hardware-integrationjetson-orin-nanosdramhardware-failurermarobotics-edge

  User reports Jetson Orin Nano 8GB SDRAM is broken and frames it as a hardware problem, with no further details. This indicates a potential device failure preventing use.

  ⚡ Hardware reliability incidents on Jetson platforms can directly block edge deployment of Physical AI applications.

• Register and indexed tile operations produce wrong results for padded vector and matrix arrays

  github:NVIDIA/warp11/10/2026crashes-stabilitywarpcudacpu-backendmemory-alignmentvec3mat33

  Register and indexed tile load/store operations return incorrect values for padded vec3 and mat33 arrays on both CPU and CUDA. This breaks correctness when data uses common alignment padding (e.g., 16-byte stride for vec3).

  ⚡ Warp correctness bugs in core memory/tile primitives directly undermine trust in GPU-accelerated simulation and learning workloads built on NVIDIA’s Physical AI stack.

• Gradients of wp.frac() and vector wp.mod() are always zero

  github:NVIDIA/warp11/9/2026training-infrawarpautogradgradientsfracmoddifferentiable-sim

  Backward gradients through wp.frac() and vector wp.mod() are always zero, with no error or warning. This silently produces incorrect gradients away from discontinuities where the derivative should be non-zero.

  ⚡ Broken autodiff for common math ops reduces Warp’s usefulness for differentiable simulation and gradient-based training central to Physical AI.

• Xavier NX system crush and auto reboot

  nvidia-forum:robotics-edge-computing11/9/2026crashes-stabilityxavier-nxcrashauto-rebootstabilityedge-deployment

  A Xavier NX system is reported to crash and auto reboot. The lack of details indicates an early-stage but potentially blocking reliability issue for that platform.

  ⚡ Unexplained crashes and reboots on deployed Jetson hardware directly threaten uptime for Physical AI edge systems.

• [BUG] Box contacts against mesh triangles can be centimetres deep and sideways since #4974

  github:newton-physics/newton11/9/2026crashes-stabilitynewtoncollisioncontactsregressionmesh-trianglebox-contact

  After a specific contact-normal change, mesh triangle vs box contacts can be reported as centimeters deep with sideways normals when they should be shallow and upward. The regression is reported on both main and release branches and changes contact depth/norma

  ⚡ Physics contact regressions create non-physical behavior that can invalidate simulation-based testing and training in NVIDIA’s Physical AI workflows.

• NVIDIA Jetson AGX Thor – Boot Failure at Elevated Temperature Despite Operating Within Specified Thermal Limits (JetPack 7.2)

  nvidia-forum:robotics-edge-computing11/9/2026crashes-stabilityjetsonagx-thorboot-failurethermalstabilityjetpack-7-2

  Jetson AGX Thor reportedly fails to boot at elevated temperature even while operating within specified thermal limits, on JetPack 7.2. This prevents reliable field operation and may indicate a platform stability or firmware issue.

  ⚡ Thermal-robust boot reliability is foundational for Physical AI edge deployments in real-world environments.

• Integrating a hierarchical cognitive controller with Unitree A1 locomotion

  github:isaac-sim/IsaacLab11/9/2026training-infrarllocomotionintegrationfeature-requestisaac-simisaac-lab

  Feature request to integrate a hierarchical cognitive controller with Unitree A1 locomotion in Isaac Lab. The issue template indicates a proposal rather than a bug report, with missing details like versions to be filled in.

  ⚡ Supporting modular hierarchical controllers alongside locomotion stacks would broaden Isaac Lab’s role as a platform for higher-level Physical AI decision-making integrated with motor control.

• Orin Nano Super USB-C only enumerates in recovery, with INA3221/FUSB301 I2C probe errors

  nvidia-forum:robotics-edge-computing11/9/2026hardware-integrationjetson-orin-nanousb-crecovery-modei2cina3221fusb301

  Orin Nano Super USB-C reportedly only enumerates in recovery mode, accompanied by INA3221/FUSB301 I2C probe errors. If accurate, this blocks normal USB-C operation and potentially device provisioning/debug workflows.

  ⚡ What this means strategically for NVIDIA's Physical AI platform.

• Jetson Orin Nano Developer Kit No-Boot / Dead Board (P/N 945-13766-0000-000)

  nvidia-forum:robotics-edge-computing11/8/2026hardware-integrationjetson-orin-nanodeveloper-kitno-bootdead-boardhardware-failurerma

  User reports a Jetson Orin Nano Developer Kit that will not boot / appears to be a dead board, referencing a specific part number. This prevents any progress on setup or development.

  ⚡ Reliability of Jetson dev kits is a gating factor for getting Physical AI stacks into developers’ hands and into real-world prototyping loops quickly.

• Orin NX 16GB gets stuck on the system boot screen

  nvidia-forum:robotics-edge-computing11/8/2026hardware-integrationjetsonorin-nxboot-failuresystem-bootrobotics-edgedevice-bringup

  Orin NX 16GB reportedly gets stuck on the system boot screen. This prevents the device from booting normally and blocks any development or deployment on the platform.

  ⚡ Edge device reliability is foundational; boot failures on Jetson-class systems directly block deploying Physical AI applications and running on-device stacks.

• [Bug Report] Startup loading screen raises UnicodeEncodeError (cp932) when stdout is redirected on Japanese Windows

  github:isaac-sim/IsaacLab11/8/2026renderingv3.0.0renderinghardwareisaac-simisaac-labmujoconewton

  Isaac Lab training aborts on Japanese Windows when stdout is redirected due to a UnicodeEncodeError in the loading screen output. The middle dot character in the run-summary title cannot be encoded with cp932, so training never starts.

  ⚡ Developer experience issues in common OS/locale setups can stop training runs outright, reducing Isaac Lab adoption in global teams and CI environments.

• Gstreamer failing to launch with Nvcompositor

  nvidia-forum:robotics-edge-computing11/6/2026crashes-stabilitygstreamernvcompositormultimediavideo-pipelineruntime-failure

  GStreamer fails to launch when using Nvcompositor. This blocks building or running a media pipeline that depends on NVIDIA's compositor element, implying a driver/plugin/config compatibility issue.

  ⚡ Stability and reliability of the multimedia stack are foundational for edge Physical AI applications that depend on real-time video composition and streaming.

• [BUG] SolverImplicitMPM: yielding material loses volume under shear (Q1/P0), independent of max_iterations; P1d/pic8 lock

  github:newton-physics/newton11/5/2026renderingrenderinghardwarenewtonwarp

  SolverImplicitMPM shows unphysical volume loss under plastic shear for a yielding material with the reported Q1/P0 configuration, and it does not improve with more iterations. The reporter notes this appears distinct from a known convergence issue referenced a

  ⚡ Physics correctness in deformables/MPM is essential for simulation credibility in downstream robotics and autonomy workflows.

• Let `tile_cholesky_inplace()` skip zeroing the opposite triangle

  github:NVIDIA/warp11/5/2026renderingrenderinghardwaremujoconewtonwarp

  Feature request for `wp.tile_cholesky_inplace()` to optionally skip zeroing the opposite triangle after factorization, since downstream solves read only the selected triangle. Current behavior adds an extra pass over the whole tile for cleanliness, potentially

  ⚡ Kernel-level performance knobs in Warp can materially improve end-to-end training and optimization throughput for Physical AI workloads.

• Isaac Sim 6.2 Kit fast_importer selects mixed charset_normalizer Python/native modules, causing 41 extension startup failures

  github:isaac-sim/IsaacSim11/5/2026crashes-stabilityv6.2crashrlrenderinghardwaredeploymentintegration

  On Linux pip installs of Isaac Sim 6.2.0.0, Kit fast_importer can load a mixed Python and native implementation of charset_normalizer depending on directory enumeration order. This triggers binary-layout exceptions and cascades into 41 extension startup failur

  ⚡ Python packaging determinism and module loading robustness directly impact Isaac Sim reliability as a core dev platform for Physical AI.

• L4T R39.2 NVDEC: SIGSEGV in libnvvideo.so when current picture has no frame buffer (NvVideoDecoderDecode called with NULL+0x310)

  nvidia-forum:robotics-edge-computing11/5/2026crashes-stabilityl4t-r39-2nvdecvideo-decodesigsegvlibnvvideojetson

  On L4T R39.2, NVDEC triggers a SIGSEGV in libnvvideo.so when the current picture has no frame buffer. The crash occurs in NvVideoDecoderDecode when called with NULL+0x310, breaking decode reliability.

  ⚡ Stable hardware-accelerated video decode on Jetson is critical for edge perception pipelines in Physical AI deployments.

• Issue where HSB multi-camera transmission terminates unexpectedly with an error

  nvidia-forum:robotics-edge-computing11/4/2026sensors-perceptionrobotics-edge-computingmulti-cameracamera-streaminghsbtransport-errors

  HSB multi-camera transmission is terminating unexpectedly with an error. This blocks sustained multi-camera streaming needed for perception pipelines.

  ⚡ Unreliable multi-camera transport breaks the sensor stack needed for perception and closed-loop autonomy on edge deployments.

• Timeout issue when executing hololink.start()

  nvidia-forum:robotics-edge-computing11/4/2026integrationrobotics-edge-computinghololinkstartuptimeoutsintegration

  Calling hololink.start() hits a timeout. This prevents bringing up the link/streaming path needed to run the system.

  ⚡ Startup timeouts in key link/stream APIs increase integration risk for end-to-end Physical AI sensor-to-compute pipelines.

• MSS: Failed to initialize SDRAM

  nvidia-forum:robotics-edge-computing11/4/2026hardware-integrationsdramboot-failuremssembeddedbring-upedge-device

  User reports an error: "MSS: Failed to initialize SDRAM". With no further context, it indicates a platform bring-up or boot-time memory initialization failure.

  ⚡ Bring-up failures like SDRAM init errors can halt edge device adoption and need crisp diagnostics for deployment readiness.

• IGX T5000: mttcan can0–can3 appear but ip link up fails (CBB TIMEOUT / read 0xffffffff); same carrier+DTB works on Jetson AGX Thor T5000

  nvidia-forum:robotics-edge-computing11/4/2026hardware-integrationigxt5000canbusmttcandevice-treebringup

  On IGX T5000, mttcan interfaces appear (can0–can3) but bringing the link up fails with CBB TIMEOUT / read 0xffffffff. The same carrier+DTB works on Jetson AGX Thor T5000, suggesting an IGX-specific bring-up or compatibility issue.

  ⚡ Platform reliability on IGX/Jetson I/O stacks directly impacts adoption of NVIDIA edge compute for robotics deployments that require deterministic field buses like CAN.

• On the t4000 equipped with PREEMPT_RT, a cold boot issue occurred

  nvidia-forum:robotics-edge-computing11/4/2026crashes-stabilityt4000preempt-rtcold-bootrealtime-linuxstability

  A cold boot issue is reported on a T4000 system equipped with PREEMPT_RT. The platform fails to reliably boot under this configuration.

  ⚡ Boot stability with PREEMPT_RT is a prerequisite for real-time robotics deployments that NVIDIA targets with edge platforms.

• Unexpected first-step friction impulse after a zero-velocity teleport using the GPU tensor API

  github:isaac-sim/IsaacSim11/4/2026crashes-stabilityv6.1crashrlusdrenderinghardwaresensors

  In Isaac Sim 6.1, a dynamic cylinder can receive an unexpected large tangential (friction) impulse on the first physics step after a horizontal teleport, even when pose and all velocities are reset to zero. The behavior depends on prior contact history with th

  ⚡ Deterministic reset/teleport semantics are essential for scalable training loops and reproducible robotics experiments on GPU-accelerated simulation.

• GR00T N1.7 license clarification: model card says commercial use, but LICENSE file in HF repo says non-commercial

  nvidia-forum:robotics-edge-computing11/4/2026docs-onboardinggrootlicensingmodel-cardhuggingfacecommercial-usepolicy

  User reports a conflict for GR00T N1.7: the model card indicates commercial use, but the LICENSE file in the Hugging Face repo says non-commercial. This ambiguity blocks teams from deciding whether they can use the model commercially.

  ⚡ Unambiguous model licensing is required to enable enterprise adoption and downstream commercialization of NVIDIA Physical AI models.

• Jetson Orin Nano Super - 3 months old - DEAD - need support

  nvidia-forum:robotics-edge-computing11/4/2026hardware-integrationjetsonorin-nanohardware-failuresupportrma

  A Jetson Orin Nano Super reportedly died after three months and the user is requesting support. The issue is a device failure blocking continued use.

  ⚡ Hardware reliability and support responsiveness on Jetson are critical to trust in NVIDIA’s edge platform for robotics products.

• [BUG] ModelBuilder.add_rod() increases the total mass of a fixed-length rod as segment count increases

  github:newton-physics/newton11/3/2026crashes-stabilitycrashusdrenderingdxnewtonwarp

  ### Bug description When I build a uniform straight rod with `ModelBuilder.add_rod()`, increasing only the segment count increases its total mass. For the same 0.30 m rod, refining from 32 to 128 segments changes the mass from **43.825 g to 111.684 g**. These

• [BUG] SolverMuJoCo state sync drifts FREE/BALL joint velocities and positions

  github:newton-physics/newton11/3/2026tooling-dxdxintegrationmujoconewtonwarp

  ### Bug Description `SolverMuJoCo` (MuJoCo Warp backend) pushes Newton `joint_q`/`joint_qd` into MuJoCo before every step and pulls them back after it (`update_data_interval=1`, the default; after #4984 this becomes the only mode). For FREE and BALL joints th

• Agx orin jp7.2.1 备份报错，无法backup

  nvidia-forum:robotics-edge-computing11/3/2026deploymentjetsonagx-orinjetpackjp7-2-1backup-restoreedge-deployment

  User reports that backing up an AGX Orin system on JP7.2.1 fails with an error and they cannot perform a backup.

  ⚡ Reliable Jetson lifecycle tooling (backup/restore) is critical to deploying and maintaining Physical AI systems at the edge.

• Nvgpu PBDMA semaphore timeout on AGX Orin (JP6.2)

  nvidia-forum:robotics-edge-computing11/2/2026crashes-stabilityjetson-agx-orinjetpack-6-2nvgpupbdmasemaphore-timeoutgpu-hang

  Nvgpu PBDMA semaphore timeouts occur on Jetson AGX Orin under JetPack 6.2. This indicates a low-level GPU scheduling/submit hang that can stall or crash compute workloads.

  ⚡ GPU driver/firmware stability on Jetson is foundational for dependable edge deployment of robotics workloads.

• Float64 Nanogrid lookup mixes distance precision during PicQuadrature binning

  github:NVIDIA/warp11/2/2026hardware-integrationhardwarewarp

  Float64 `PicQuadrature` fails to compile on Nanogrid/AdaptiveNanogrid due to mixed-precision math in a lookup fallback (float32 `max_dist` divided by float64 cell size). This blocks end-to-end float64 screened reconstruction workflows when particle binning hit

  ⚡ Float64 correctness/compilability is key for higher-fidelity physics and geometry pipelines that some Physical AI workflows rely on.

• Float64 Cube B-spline FEM assembly uses float32 node coordinates and gradients

  github:NVIDIA/warp11/2/2026integrationintegrationwarp

  Warp 3D B-spline FEM assembly fails to compile with float64 geometry/fields because Cube B-spline shape functions use float32 node coordinates and gradients. This blocks float64 diagnostic/profile work and float64 FEM usage for that element basis.

  ⚡ Reliable float64 FEM support in Warp enables precision-demanding simulation and reconstruction workflows used in advanced Physical AI toolchains.

• L4T 39.2.1: Host1x fence-chain double release causes stall

  nvidia-forum:robotics-edge-computing11/1/2026crashes-stabilityl4t-39-2-1host1xfencestalljetsonsynchronization

  On L4T 39.2.1, a host1x fence-chain double release is reported to cause a stall. The corpus does not include repro steps or logs beyond the title.

  ⚡ Core OS graphics/compute synchronization bugs can stall edge workloads and jeopardize real-time Physical AI applications.

• [REQ] Coalesced multiple-RHS application of FSAI factors

  github:NVIDIA/warp11/1/2026renderingrenderinghardwareintegrationwarp

  Request to add efficient coalesced multiple-RHS application for existing FSAI factors, with a shared block-product interface and CUDA path. The request references an existing implementation in Warpack and notes FSAI construction is already upstream in Warp.

  ⚡ Improving batched/blocked linear-algebra kernels in Warp strengthens the performance foundation for Physical AI simulation and optimization workloads.

• [REQ] Reusable GMRES solve actions with fresh device residual diagnostics

  github:NVIDIA/warp11/1/2026training-infrarlrenderinghardwareintegrationwarp

  Request to expose a reusable GMRES solve action with fresh device-side residual diagnostics, so GMRES can be embedded inside other Warp algorithms while keeping upstream GMRES as the implementation. The requester points to an existing downstream adapter patter

  ⚡ Reusable solver actions with device-side diagnostics improve composability of Warp algorithms used throughout Physical AI simulation and optimization.

• [REQ] Reusable multiple-RHS CG solves for one shared sparse operator

  github:NVIDIA/warp11/1/2026renderingrenderinghardwareintegrationfeature-requestwarp

  Request for a convenient, efficiently batched way to solve one sparse SPD operator against many independent RHS vectors, reusing operator and preconditioner. The request emphasizes shared-matrix/shared-preconditioner contracts and optimized block products beyo

  ⚡ Efficient multi-RHS sparse solves enable higher-throughput simulation and learning workloads that depend on repeated linear solves in Physical AI.

• [BUG] MPR raycast fallback accepts nonlocal support witness as contact on large box floor

  github:newton-physics/newton11/1/2026crashes-stabilitynewton-physicscollision-detectionmprraycastcontactslarge-scenes

  Newton's convex collision path can accept a nonlocal support witness as a contact when MPR witnesses are invalid and refinement falls back. In large scenes this can yield contacts tens of meters away and has been observed alongside downstream constraint-solver

  ⚡ Robust contact generation is essential to prevent downstream solver failures and maintain large-scale simulation stability in Physical AI.

• Auto-update (GNOME) to L4T R36.4.7 bricked NVMe boot on AGX Orin: "ERROR: nvme0n1p1 not found" (cause + fix)

  nvidia-forum:robotics-edge-computing10/31/2026deploymentjetson-agx-orinl4tr36-4-7ota-updatenvme-bootboot-failure

  An auto-update to L4T R36.4.7 reportedly bricked NVMe boot on AGX Orin with an "nvme0n1p1 not found" error. The issue implies an update path that can render devices unbootable without a recovery procedure.

  ⚡ Safe OTA/update pathways are critical to keeping edge Physical AI deployments recoverable and minimizing downtime.

• Support CPU devices in Nanogrid.from_environment_voxels() and AdaptiveNanogrid.from_environment_voxels()

  github:NVIDIA/warp10/31/2026renderingrenderinghardwaredxwarp

  Nanogrid.from_environment_voxels and AdaptiveNanogrid.from_environment_voxels reject device="cpu" with a runtime error, even though related single-environment CPU volume/grid paths work. This prevents building multi-environment NanoVDB-derived geometry on CPU.

  ⚡ CPU support for geometry/voxel builders broadens developer accessibility and enables hybrid CPU/GPU workflows in Physical AI tooling.

• [BUG] Kamino dense solver cannot initialize G1 at 8K and 16K environments

  github:newton-physics/newton10/31/2026crashes-stabilitynewton-physicskaminodense-solverpadmmrsl-rlscaling

  The Kamino dense solver fails to initialize G1 at 8K and 16K environments due to signed 32-bit integer overflow in dense Delassus allocation sizes and Jacobian offset construction. 4,096 environments runs, but 8,192 and 16,384 hit element counts/offsets exceed

  ⚡ This indicates hard scaling ceilings from 32-bit indexing/allocations that will block high-throughput multi-environment training and evaluation pipelines.

• Validate Steel material coefficient sums and friction scaling for float32 overflow

  github:newton-physics/newton10/30/2026renderingrenderingnewton

  Finite non-negative material coefficients and scaled friction can still overflow float32 during addition/multiplication, producing non-finite results. The issue requests range checks in Steel solver paths and regression tests to prevent overflow-driven failure

  ⚡ Numeric robustness in physics solvers is foundational to stable simulation pipelines that Physical AI training depends on.

• Fix SolverSteel disabled-closure warning and clarify parent-wrench changelog

  github:newton-physics/newton10/30/2026docs-onboardingdocsnewton

  A follow-up is needed to fix incorrect `SolverSteel` disabled-closure warning behavior. It also asks to clarify a `BODY_PARENT_F` changelog entry about a deferred pre-elimination exception when loop-closure reactions are omitted.

  ⚡ Clear, correct solver warnings and changelog/doc alignment reduce adoption risk and debugging time for simulation users.

• SolverImplicitMPM (GIMP): the face of a moving kinematic collider over-compresses and spreads more than the face of a fixed one

  github:newton-physics/newton10/30/2026renderingrenderinghardwaredeploymentintegrationnewtonwarp

  In SolverImplicitMPM with integration_scheme="gimp", deformation becomes asymmetric depending on which kinematic collider face is moving, with over-compression near the moving die. The asymmetry swaps sides when the other die moves, and is much smaller with th

  ⚡ Physics correctness and symmetry in material interaction is critical for trusting simulation results used to design and validate Physical AI behaviors.

• Jetson Orin Nano Developer Kit: Boot Failure from NVMe SSD, JBD2 Invalid Checksum and OS Chain A Unbootable

  nvidia-forum:robotics-edge-computing10/29/2026crashes-stabilityjetson-orin-nanonvmeboot-failurejbd2filesysteml4t

  Jetson Orin Nano Developer Kit fails to boot from an NVMe SSD, with filesystem checksum errors (JBD2) and the OS chain A marked unbootable. This blocks development until storage/boot-chain recovery is understood and repeatable.

  ⚡ Boot reliability on Jetson developer kits is foundational for deploying Physical AI stacks and reduces friction for edge bring-up and iteration.

• [Bug Report] FORGE policy linear velocity loses motion due to overwritten position history

  github:isaac-sim/IsaacLab10/29/2026training-infrarlhardwaremanipulationisaac-simisaac-lab

  In Isaac Lab ForgeEnv, the `ee_linvel` observation appears to lose true motion because FactoryEnv and ForgeEnv reuse and update the same position-history buffer within one call. Reporter confirmed it exists in v3.0.0, main, and v2.3.0, and is asking for confir

  ⚡ Incorrect observation bookkeeping undermines policy learning reliability and reproducibility, which is central to scaling Physical AI training with Isaac Lab.

• Flashing failure on Jetson Orin Nano 8GB P3767-0003: SDRAM init still fails after applying t234 DRAM PCN 2026-08-27

  nvidia-forum:robotics-edge-computing10/29/2026crashes-stabilityjetson-orin-nanop3767-0003flashingsdram-initdramt234

  Flashing fails on Jetson Orin Nano 8GB (P3767-0003) because SDRAM initialization still fails even after applying the t234 DRAM PCN dated 2026-08-27. This prevents bringing the device up at all.

  ⚡ Flashing and DRAM init robustness on Jetson is critical to shorten time-to-first-boot for edge Physical AI deployments and developer adoption.

• SolverSteel with deterministic=RUN_TO_RUN fails inside a CUDA graph capture that Warp didn't start

  github:newton-physics/newton11/4/2026integrationnewtonwarpcuda-graphsdeterminismtorch-integrationsolversteel

  With deterministic=RUN_TO_RUN, SolverSteel cannot be captured into a CUDA graph unless Warp initiated the capture. External capture mechanisms (e.g., cuStreamBeginCapture or torch.cuda.graph) get invalidated mid-step.

  ⚡ Incompatibility with external CUDA graph capture limits composability of Warp-based physics with broader PyTorch and CUDA ecosystem workflows.

• [BUG] add_mjcf silently drops <sensor> elements (e.g. <touch>)

  github:newton-physics/newton11/4/2026sensors-perceptionnewtonmjcfmodel-importsensorstouch-sensorsolver-mujoco

  ModelBuilder.add_mjcf silently ignores the MJCF <sensor> section, so sensors like <touch> never appear in the built model. The same XML loaded directly with MuJoCo includes the sensor, indicating a loss during import without warnings.

  ⚡ Silent drops in sensor import pipelines erode trust in simulation-to-control parity, weakening sim-based validation and data generation workflows.

• Determinism

  github:newton-physics/newton11/1/2026sim2realnewtondeterminismphysics-simulationwarpsolvercuda-graphs

  Work is needed to make run-to-run deterministic simulation available across multiple Newton solvers and to reduce its cost. Current deterministic mode has documented limitations and high overhead in some configurations.

  ⚡ Deterministic simulation is a prerequisite for reproducible training, debugging, and certification paths across NVIDIA’s Physical AI stack.

• Reduce deterministic-mode overhead under CUDA graph replay

  github:newton-physics/newton11/1/2026training-infrawarpdeterminismcuda-graph-replayperformancecontactsxpbd

  Under CUDA graph replay, Warp deterministic mode sorts and re-initializes worst-case record buffers every replay, causing extreme slowdowns for contact-heavy kernels. Reported overheads include 48x (XPBD rigid pile) and 216x (Style3D cloth) versus non-determin

  ⚡ If deterministic replay is orders-of-magnitude slower under CUDA graphs, it blocks practical large-scale training pipelines that depend on graph replay for throughput.

• SolverKamino: deterministic mode

  github:newton-physics/newton11/1/2026sim2realnewtonkaminowarpdeterminismcontactsatomics

  Kamino’s current kernels rely on atomic slot reservations and counters that would be rejected by Warp’s deterministic codegen. The issue outlines kernel and algorithm changes needed to support a deterministic mode, with some parts potentially disabled until re

  ⚡ Solver coverage gaps for determinism create inconsistencies that reduce reproducibility across tasks and environments in the Physical AI platform.

• Coupled solvers: add a deterministic option

  github:newton-physics/newton11/1/2026sim2realnewtonwarpdeterminismcoupled-solversatomicsrecord-buffers

  Coupled solvers accumulate interface forces with atomics and need refactors plus exact deterministic record bounds to enable a deterministic option. Warp deterministic constraints (e.g., rejecting a second atomic on a slot counter) require kernel restructuring

  ⚡ Deterministic coupled solvers are key for consistent multi-physics interactions, which Physical AI workloads rely on for stable training and evaluation.

• SolverImplicitMPM: add a deterministic option

  github:newton-physics/newton11/1/2026sim2realnewtonwarpmpmimplicit-mpmdeterminismatomics

  Implicit MPM needs a deterministic option because some transfers and force accumulation use floating-point atomics and some kernels use updates that Warp deterministic codegen rejects. Proposed changes include module options propagation, replacing `+=` with st

  ⚡ Deterministic MPM broadens reproducible deformables and material simulation, improving reliability of Physical AI training that depends on contact-rich dynamics.

• SolverStyle3D: add a deterministic option

  github:newton-physics/newton11/1/2026sim2realnewtonstyle3dwarpdeterminismclothself-contact

  Style3D has no deterministic option and uses floating-point atomics for forces, requiring module option support and exact deterministic record bounds for narrow-phase kernels. Deterministic graph replay can be extremely slow (reported 216x on a 97x97 cloth und

  ⚡ Deterministic cloth and contact simulation is essential for reproducible policy learning and regression testing in Physical AI scenarios with deformables.

• Jetson Thor (L4T 39.2.1): Binding MGBE to vfio-platform for DPDK fails (-EINVAL / Error 22) – Missing dma-coherent on SMMU0

  nvidia-forum:robotics-edge-computing11/5/2026▲ 4hardware-integrationhardware

  On Jetson Thor with L4T 39.2.1, binding the MGBE device to vfio-platform for DPDK fails with -EINVAL (Error 22). The post indicates a missing dma-coherent setting on SMMU0, blocking the intended userspace driver path.

  ⚡ DPDK/vfio enablement on Jetson is key to deterministic, high-throughput edge pipelines that Physical AI applications depend on.

• IGX700 BMC – Account Lockout After Multiple Failed Login Attempts

  nvidia-forum:robotics-edge-computing11/10/2026▲ 1hardware-integrationigx700bmcaccount-lockoutremote-managementedge-deployment

  IGX700 BMC accounts can lock out after multiple failed login attempts, potentially blocking remote management access. The issue suggests an operational friction point around access policy and recovery procedures.

  ⚡ Manageability and recoverability issues in IGX platform administration increase operational risk for edge Physical AI deployments.

• Hardware timestamping on RTL8126 fails

  nvidia-forum:robotics-edge-computing11/11/2026hardware-integrationjetsonnicrtl8126hardware-timestampingptpedge-computing

  Hardware timestamping fails on the RTL8126 network interface. This blocks or degrades time-synchronized networking workflows that depend on NIC timestamp support.

  ⚡ Reliable hardware timestamping is foundational for synchronized sensing and control loops across edge robotics deployments.

• Jetson Thor USB Host Controller Resource Limit with Multiple CAN Adapters

  nvidia-forum:robotics-edge-computing11/11/2026hardware-integrationjetson-thorusbhost-controllercan-buscan-adapterresource-limit

  Jetson Thor USB host controller hits a resource limit when using multiple CAN adapters. This prevents scaling to multiple CAN devices on the same system without changes or workarounds.

  ⚡ I/O scalability limits on edge platforms directly constrain real-robot sensor/actuator integration for Physical AI applications.

• HSB SDK v3.0.0: How to access data in a custom Python operator?

  nvidia-forum:robotics-edge-computing11/11/2026docs-onboardinghsb-sdkpython-operatorcustom-operatordata-accesssdk-usagerobotics-edge

  A user asks how to access data in a custom Python operator in HSB SDK v3.0.0. This suggests missing or unclear documentation/API patterns for operator I/O and data handling.

  ⚡ Better operator data-access guidance reduces friction when extending NVIDIA edge/robotics SDK pipelines used in Physical AI products.

• multicontact: GJK/MPR manifold scratch buffers rely on CUDA-only fixedarray idioms

  github:newton-physics/newton11/11/2026integrationnewton-physicswarpmulticontactcuda-specificmetal-backendportability

  Newton multicontact manifold scratch buffers rely on CUDA-only fixedarray and pointer aliasing behaviors. This breaks on backends with strict address spaces (e.g., Apple Metal) because it treats thread-local stack storage as a device pointer.

  ⚡ Reducing backend-specific assumptions in core physics/contact code increases portability across GPU backends needed by diverse Physical AI developer environments.

• Nvidia,disable-power-down

  nvidia-forum:robotics-edge-computing11/11/2026hardware-integrationjetsonpower-managementdevice-treedisable-power-downplatform-configedge-computing

  The topic references "Nvidia,disable-power-down", indicating a need to disable a power-down behavior via NVIDIA-related configuration. Missing context suggests unclear device-tree or platform settings for power management.

  ⚡ Power-management controls that are hard to configure can destabilize real-time robotics behavior and complicate deployment on NVIDIA edge devices.

• How can we run inference of Alpamayo 2 super on jetson AGX thor?

  nvidia-forum:robotics-edge-computing11/11/2026deploymentjetson-agx-thorinferencedeploymentmodel-compatibilityedge-airuntime

  A user asks how to run inference for "Alpamayo 2 super" on Jetson AGX Thor. This indicates uncertainty about model support, optimization, or runtime deployment steps on that platform.

  ⚡ Running modern model inference reliably on Jetson-class hardware is central to deploying Physical AI capabilities on robots.

• <model> asset in an included file is looked up with the directory twice when the main file is loaded as dir/scene.xml

  github:google-deepmind/mujoco11/10/2026asset-pipelinemujocomjcfasset-resolutionincludepath-bugrobot-models

  MuJoCo incorrectly resolves a <model> asset file path in an included file when the main MJCF is loaded from a subdirectory, duplicating the directory in the resolved path. This causes model loading to fail with a file-not-found error like 'case2/case2/sub/chil

  ⚡ Consistent asset path resolution is important for reliable robot model composition workflows that feed simulation-to-training pipelines.

• to_xml() drops mass="0" density="0" from a geom default class, so the saved XML compiles to a heavier body

  github:google-deepmind/mujoco11/10/2026asset-pipelinemujocomjcfxml-exportmodel-serializationmass-propertiesrobot-arms

  MuJoCo's to_xml() drops explicit mass="0" and density="0" on geom defaults, changing the exported model's physical properties. The re-saved XML compiles with default density and yields a much heavier body than the original.

  ⚡ Simulation-to-asset export fidelity issues directly undermine trust in model interchange and sim2real validation workflows.

• Support wp.handle in framework and DLPack converters

  github:NVIDIA/warp11/10/2026integrationwarpdlpackjaxpytorchpaddlehandle-dtype

  Warp converters (from_torch/from_jax/from_paddle/from_dlpack) do not support explicit dtype=wp.handle imports/exports using 64-bit integer storage. Users want handle arrays to round-trip through DLPack and framework converters while preserving underlying bits

  ⚡ Robust interop (Torch/JAX/Paddle/DLPack) is a key enabler for Physical AI pipelines that mix simulation, learning, and GPU compute libraries.

• wp.sqrt() gradient is inf at x == 0, unlike wp.length()

  github:NVIDIA/warp11/10/2026training-infrawarpautodiffgradientsnumerical-stabilitysqrtnan

  Warp's wp.sqrt() adjoint computes 0.5/sqrt(x) with no guard, producing inf gradients at x==0 that often become NaNs downstream. This differs from wp.length() behavior and can break common patterns like sqrt(dot(v,v)) at v==0.

  ⚡ Numerical stability in autodiff primitives is critical for reliable gradient-based optimization and learning workloads in Physical AI.

• [REQ] Make wp.sparse.bsr_mv differentiable

  github:NVIDIA/warp11/10/2026training-infrawarpsparsebsr-mvautodifftapegradients

  warp.sparse.bsr_mv is not differentiable with wp.Tape because kernels are built with enable_backward=False. tape.backward() completes but returns all-zero gradients for x and A.values with only a warning, requiring users to implement their own adjoint.

  ⚡ Missing gradients in sparse ops force users into custom adjoints, slowing adoption of Warp as a learning/optimization backend for Physical AI.

• Deterministic contacts and contact matching are limited to 2**20 shapes with meshes, heightfields or hydroelastic shapes

  github:newton-physics/newton11/10/2026crashes-stabilitynewton-physicsdeterminismcontactscollisionmeshesheightfields

  Newton's deterministic contacts/contact matching use an int64 sort key that limits models with mesh/heightfield/hydroelastic contacts to at most 2**20 shapes. Exceeding that now raises ValueError when deterministic mode is enabled (directly or via contact_matc

  ⚡ Determinism limits at large scale constrain reproducible simulation and evaluation for big scene generation and multi-object Physical AI workloads.

• Box-triangle contact is 1 m deep for a triangle nearly parallel to a thin box face (after #5241)

  github:newton-physics/newton11/10/2026crashes-stabilitynewton-physicscollisioncontact-depthregressionbox-trianglethin-geometry

  After a fix in #5241, Newton now produces an incorrect ~1 m deep box-triangle contact when a triangle is nearly parallel to a thin box face. The same configuration previously produced a ~1.4 mm contact, indicating a regression in narrowphase contact depth hand

  ⚡ Contact robustness regressions can destabilize physics-based training and evaluation, especially for thin geometries common in real-world assets.

• OVRTX periodic cables do not follow Newton simulation

  github:isaac-sim/IsaacLab11/10/2026crashes-stabilityisaac-labnewtonovrtxcablesusdgeombasiscurves

  Periodic `UsdGeom.BasisCurves` cables render but stay at their authored pose instead of following the simulated cable when using Newton + OVRTX. Open cables update correctly, indicating a specific issue with periodic curves not updating with simulation.

  ⚡ Simulation/visualization mismatches undermine trust in physics-based workflows and reduce the value of Isaac Lab as a debugging and development environment.

• [BUG] SolverXPBD zeroes body velocities below 1e-4, so slow bodies stop or never start moving

  github:newton-physics/newton11/10/2026othernewton-physicsxpbdrigid-body-dynamicssolver-stabilitynumerical-thresholdsvelocity-clamping

  SolverXPBD clamps small linear/angular velocities to zero every iteration, causing slow free bodies to stop and preventing bodies from ever starting to move when per-step changes are below the threshold. This breaks expected behavior versus other solvers and r

  ⚡ Physics-solver correctness issues at small velocity scales can undermine trust in simulation fidelity used for Physical AI evaluation and training.

• [BUG] Hollow mesh mass properties ignore the requested shell thickness

  github:newton-physics/newton11/10/2026othernewton-physicsmass-propertiesinertiameshasset-physicshollow-shell

  Hollow mesh mass properties ignore the requested shell thickness and reuse cached defaults. The scaling uses volume (s³) instead of thin-shell area (s²), producing incorrect inertia/mass properties for scaled hollow meshes.

  ⚡ Accurate mass/inertia computation for assets is foundational for reliable simulation behavior that Physical AI stacks depend on.

• Orin Nano Super, JetPack 6.2.1: CPU at 95 % while GPU clock stays below max during TensorRT inference on 4 RTSP streams

  nvidia-forum:robotics-edge-computing11/10/2026deploymentjetson-orin-nanojetpack-6-2-1tensorrtrtspvideo-inferenceperformance-bottleneck

  On Orin Nano Super with JetPack 6.2.1, TensorRT inference on four RTSP streams shows CPU near 95% while GPU clocks stay below max. This indicates a bottleneck outside GPU compute (e.g., decode/IO/scheduling) that limits throughput.

  ⚡ Edge inference performance predictability (CPU/GPU utilization) is critical for scalable Physical AI deployments on Jetson/Orin.

• [BUG] ModelBuilder.collapse_fixed_joints gives the merged body a wrong inertia

  github:newton-physics/newton11/10/2026othernewton-physicsmodelbuilderfixed-jointsinertiarigid-body-dynamicsarticulation

  collapse_fixed_joints merges masses and COM correctly but computes a wrong composite inertia about the merged COM. The child inertia is shifted using the child frame origin instead of its COM, and the parent inertia is not shifted to the merged COM.

  ⚡ Incorrect inertia composition in model-building tools can silently corrupt dynamics, reducing reliability of simulation-based Physical AI development.

• [BUG] Aggressive viewer picking response on a lightweight branched harness with SolverVBD

  github:newton-physics/newton11/10/2026tooling-dxnewtonwarpviewerpickingwiring-harnesssolvervbd

  Viewer picking causes overly aggressive forces near branch junctions, making a lightweight wiring harness fold, tumble, and oscillate excessively. The behavior is reported with SolverVBD and takes a long time to settle after release.

  ⚡ Unstable interactive manipulation in physics viewers slows iteration and debugging for robotics and digital-twin workflows on NVIDIA’s platform.

• Bazel: downstream modules fail on mujoco_pip for Python 3.15; please bump rules_python to 2.5.0

  github:google-deepmind/mujoco11/9/2026integrationmujocobazelrules-pythonpython-3-15build-integrationmodule-deps

  Downstream Bazel modules fail when using mujoco_pip for Python 3.15 due to rules_python version pinning. The request is to bump rules_python to 2.5.0 to restore pip toolchain/interpreter resolution.

  ⚡ Build-system breakages in popular simulators compound ecosystem fragmentation and raise the cost of integrating Physical AI components into Bazel-based stacks.

• Why is π0.5 inference about 5× slower under T3000 software emulation on Jetson Thor?

  nvidia-forum:robotics-edge-computing11/9/2026deploymentjetson-thorsoftware-emulationinferenceperformancet3000edge-ai

  π0.5 inference is reported to run about 5× slower under T3000 software emulation on Jetson Thor. This raises questions about expected performance characteristics and emulation fidelity.

  ⚡ Large performance gaps under software emulation complicate benchmarking and capacity planning for running Physical AI models on Jetson Thor.

• Intermittent Slow Suspend (~1 in 500 cycles) on Jetson Orin Nano (JetPack 7.2)

  nvidia-forum:robotics-edge-computing11/9/2026crashes-stabilityjetson-orin-nanojetpack-7-2suspendpower-managementintermittentstability

  Jetson Orin Nano shows intermittent very slow suspend behavior occurring roughly 1 in 500 cycles. The report is tied to JetPack 7.2 and suggests a sporadic stability/latency problem in power management.

  ⚡ Rare-but-severe power-state latency issues erode reliability expectations for always-on robotics systems deployed on Jetson.

• wp.autograd.jacobian() returns zero gradients for kernels whose adjoint reads an output (atomic_min/atomic_max)

  github:NVIDIA/warp11/9/2026training-infrawarpautogradjacobiangradcheckatomic-minatomic-max

  wp.autograd.jacobian() returns zero gradients for kernels using atomic_min/atomic_max when the adjoint reads an output, while wp.Tape produces correct gradients. gradcheck fails without Warp reporting an error or warning.

  ⚡ Inconsistent gradient tooling results weaken developer confidence in Warp-based differentiable pipelines for Physical AI training and verification.

• Jetson Thor T5000 PCIe C2 width confirmation: Data Sheet / Design Guide say x1, Linux Developer Guide says x2 (Lane4+Lane5) — which is correct?

  nvidia-forum:robotics-edge-computing11/9/2026docs-onboardingjetson-thort5000pcielane-widthdocumentationhardware-design

  Jetson Thor T5000 PCIe C2 lane width is inconsistent across documents (data sheet/design guide vs Linux Developer Guide). The user is asking which PCIe width is correct (x1 vs x2).

  ⚡ Conflicting hardware interface documentation increases integration errors and slows partner designs for Jetson Thor-based Physical AI devices.

• [REQ] Reserve less memory by default for rebuildable volumes

  github:NVIDIA/warp11/9/2026feature-requestswarpvolumesnanogridmemory-usagesparse-gridsfem

  Rebuildable Warp volumes reserve worst-case memory by default, leading to very large per-point allocations even for dense inputs. The request is to reserve less memory by default for allocate_by_voxels/allocate_by_tiles and related paths (e.g., fem.Nanogrid.fr

  ⚡ Excess default memory reservation limits scale and density of 3D world representations, impacting Physical AI simulation and data generation throughput.

• [BUG] Rebuildable volumes crash when their reserved memory can't be allocated

  github:NVIDIA/warp11/9/2026crashes-stabilitycrashrenderinghardwarewarp

  Warp rebuildable volumes can crash when reserved memory allocation fails because allocation success is not checked. Failures lead to CPU segfaults or CUDA illegal memory access that breaks the context, and rebuildable volumes can hit this due to extreme defaul

  ⚡ Hard crashes from allocation failures undermine reliability for large-scale synthetic worlds and geometry processing pipelines in Physical AI workloads.

• omni.replicator.core: orchestrator.step() drives four full renders per capture and keeps one

  github:isaac-sim/IsaacSim11/9/2026renderingv6.1.0renderinghardwaresensorsperceptiondocsintegration

  In Isaac Sim Replicator, a single orchestrator.step() triggers four full application updates and renders per capture while only keeping one image. With path tracing where each update converges, this wastes most render time as discarded pixels.

  ⚡ Inefficient capture orchestration directly increases synthetic data generation cost and slows dataset throughput for training Physical AI models.

• [BUG] capture_debug_dot_print() fails on CPU graphs and on loaded graphs before their first launch

  github:NVIDIA/warp11/9/2026renderingrenderinghardwarewarp

  wp.capture_debug_dot_print() throws an unrelated CUDA invalid-argument error when called on CPU-captured graphs or on graphs loaded before first launch. The function should either support these cases or fail with a clear, accurate error message.

  ⚡ Warp graph tooling reliability directly impacts developer trust and iteration speed for physics/robotics workloads that depend on capture/replay.

• [BUG] bsr_compress() isn't replayed by CPU graph captures or kept in saved graphs

  github:NVIDIA/warp11/9/2026crashes-stabilitycrashhardwareintegrationwarp

  Graph capture does not record wp.sparse.bsr_compress() for CPU captures, so it runs during recording but not during replay, producing wrong or uncompressed matrices and can crash when capturing fem.integrate() with row_compress. CUDA graphs run it, but capture

  ⚡ Correct capture/replay semantics for sparse/FEM operations are critical to deterministic simulation and scalable training pipelines built on Warp graphs.

• Retain allocations made by callable CUDA conditional graph bodies

  github:NVIDIA/warp11/9/2026hardware-integrationhardwareintegrationnewtonwarp

  Callable CUDA conditional graph bodies can allocate arrays or internal scratch during capture, but CUDA disallows allocation nodes inside these bodies and the memory must remain valid for replay even if Python arrays are released. The proposal is to retain cap

  ⚡ Robust CUDA graph capture for dynamic control flow and memory lifetimes is key to high-performance simulation/training loops that must avoid host-side overhead.

• USB OTG Compatibility Issue with USB 3.0 Hubs on NVIDIA Jetson AGX Orin – JetPack 6.2

  nvidia-forum:robotics-edge-computing11/9/2026hardware-integrationjetsonagx-orinusb-otgusb-3-hubperipheralsjetpack-6-2

  User reports USB OTG compatibility issues with USB 3.0 hubs on Jetson AGX Orin running JetPack 6.2. This can break device connectivity assumptions for cameras, storage, or debug peripherals.

  ⚡ Peripheral compatibility on edge platforms directly affects integration velocity for robotics prototypes and deployments.

• NVMe SSD Flashing Issue on NVIDIA Jetson AGX Xavier

  nvidia-forum:robotics-edge-computing11/9/2026deploymentjetsonagx-xaviernvmeflashingprovisioningdeployment

  User reports an NVMe SSD flashing issue on Jetson AGX Xavier. This blocks or complicates installing and provisioning the target system on NVMe storage.

  ⚡ Reliable flashing and storage provisioning are prerequisites for scaling edge deployment of Physical AI systems.

• [Thor]SW Shutdown Case & Reset

  nvidia-forum:robotics-edge-computing11/9/2026hardware-integrationjetsonthorshutdownresetpower-managementembedded

  User asks about a software shutdown case and reset behavior for Jetson Thor. This indicates uncertainty or unexpected behavior around power management and reset flows.

  ⚡ Well-defined power/reset/shutdown behavior is essential for robust embedded robotics systems using NVIDIA edge modules.

• NvBufSurfTransform (VIC) alters chroma on same size NV12 to NV12 copy, luma kept exact, NV16/NV24 and GPU compute kept exact

  nvidia-forum:robotics-edge-computing11/9/2026sensors-perceptionjetsonnvbufsurftransformvicnv12video-processingcolor-chroma

  User reports that NvBufSurfTransform (VIC) changes chroma on an NV12-to-NV12 copy at the same size, while luma remains exact and other formats/GPU paths remain exact. This implies a potential correctness issue in a common video processing path.

  ⚡ Deterministic, correct pixel transformations are critical to trustworthy vision pipelines in Physical AI deployments.

• 【Jetson Thor】Troubleshooting for OC Alarm Issues

  nvidia-forum:robotics-edge-computing11/9/2026crashes-stabilityjetsonthoroc-alarmpowerstabilitytroubleshooting

  User requests troubleshooting guidance for OC alarm issues on Jetson Thor. This suggests over-current or related alarm events impacting system stability or operation.

  ⚡ Clear diagnostics and mitigations for platform alarms are necessary to maintain system reliability in edge Physical AI deployments.

• Orin NX；hardware watchdog

  nvidia-forum:robotics-edge-computing11/9/2026hardware-integrationjetsonorin-nxwatchdogreliabilityembeddedrecovery

  User asks about a hardware watchdog on Jetson Orin NX. This implies a need for system-level reset/recovery mechanisms and clarity on hardware watchdog availability or configuration.

  ⚡ Reliable watchdog support is essential for autonomous Physical AI systems that must self-recover from hangs in production.

• Unable to Reproduce DROID-W Benchmark Performance from NVIDIA Workshop

  nvidia-forum:robotics-edge-computing11/9/2026deploymentdroid-wbenchmarkingperformance-regressionworkshopreproducibility

  User reports they cannot reproduce DROID-W benchmark performance from an NVIDIA workshop. The post body is empty, so the setup, hardware/software stack, and measured deltas are unknown.

  ⚡ What this means strategically for NVIDIA's Physical AI platform.

• Request for USB PD VIF file for CYPD8225 (CCG8) firmware on Jetson Thor reference design

  nvidia-forum:robotics-edge-computing11/9/2026docs-onboardingjetson-thorusb-pdvifcypd8225ccg8reference-design

  Request for a USB PD VIF file for CYPD8225 (CCG8) firmware on the Jetson Thor reference design. Lack of this artifact may block USB-PD compliance/validation or bring-up workflows for partners.

  ⚡ What this means strategically for NVIDIA's Physical AI platform.

• How can OrinAGX sipl framework support 8lane configuration

  nvidia-forum:robotics-edge-computing11/8/2026hardware-integrationjetson-orin-agxsipl8-lanecamera-pipelineconfiguration

  User asks how the Orin AGX SIPL framework can support an 8-lane configuration. The post body is empty, so the specific interface (e.g., camera/SerDes) and current limitation are unclear.

  ⚡ What this means strategically for NVIDIA's Physical AI platform.

• Jetson Orin NX – 3.3V GPIO Pull-up Safety During Initial Flashing

  nvidia-forum:robotics-edge-computing11/8/2026hardware-integrationjetson-orin-nxgpio3v3flashingbring-uphardware-safety

  User is concerned about 3.3V GPIO pull-up safety during initial flashing on Jetson Orin NX. This suggests risk of improper electrical states or potential damage/misconfiguration during provisioning.

  ⚡ Hardware bring-up safety guidance directly impacts developer confidence and time-to-first-success on NVIDIA edge platforms used for Physical AI deployments.

• Does the SMCU (RH850) work without issues on the IGX-T5000?

  nvidia-forum:robotics-edge-computing11/8/2026hardware-integrationigx-t5000smcurh850compatibilityedge-computingplatform-validation

  User asks whether the SMCU (RH850) works without issues on the IGX-T5000. This indicates uncertainty about component compatibility or known issues on that platform.

  ⚡ Verified compatibility of safety/control microcontrollers with IGX platforms is important for dependable edge robotics deployments and compliance workflows.

• Remove legacy rigid AVBD and start-origin Rod construction

  github:newton-physics/newton11/8/2026training-infrarldxdocsnewton

  Newton proposes completing deprecations by removing a legacy rigid-body formulation and making compliant ALM the only rigid-body mode in `SolverVBD`. It also removes a legacy rod body-origin convention (`start`) in favor of COM-centered frames.

  ⚡ Reducing legacy physics paths while keeping authored assets compatible is key to stable simulation foundations for training and testing Physical AI behaviors.

• [BUG] wp.utils array helpers run on the current CUDA device instead of their arrays' device

  github:NVIDIA/warp11/8/2026renderingrenderinghardwarewarp

  Warp `wp.utils` array helpers run CUDA work on the current device rather than the device where the arrays reside, using the wrong stream and allocating scratch memory on the wrong device. This can break graph captures or cause operations to be captured into th

  ⚡ Correct multi-GPU device semantics in core array utilities is essential for robust scaling and predictable CUDA graph capture in Physical AI simulation/training pipelines.

• Support `capture_launch()` inside an active CUDA graph capture

  github:NVIDIA/warp11/8/2026renderingrenderinghardwarewarp

  Request that `wp.capture_launch(graph)` work inside an active CUDA graph capture on the same device, enabling nested graph replay. Currently it raises an error even though the graph can be used in `capture_if()`/`capture_while()` branches.

  ⚡ Composable CUDA graph execution improves performance engineering and modularity for simulation/training kernels used across NVIDIA’s Physical AI stack.

• Thor uses DP1 for display cannot work

  nvidia-forum:robotics-edge-computing11/8/2026hardware-integrationthordisplayportdp1video-outputrobotics-edgehardware-bringup

  User reports that Thor using DP1 for display does not work. This suggests a display output/port routing or driver/firmware compatibility problem that prevents using the device with a monitor.

  ⚡ Display bring-up and IO compatibility issues on target hardware can block end-to-end Physical AI workflows from sim to deployed edge systems.

• [BUG] USD import silently drops `physxRigidBody:linearDamping` / `physxRigidBody:angularDamping`

  github:newton-physics/newton11/8/2026crashes-stabilitycrashusdhardwaremujoconewtonwarp

  USD import maps PhysX damping attributes to internal keys that are never consumed, so linear/angular damping are effectively dropped without warning. This changes dynamics (e.g., damped bodies keep velocity) and can invalidate simulations when importing PhysX-

  ⚡ USD/PhysX fidelity gaps during import undermine cross-tool asset portability, making sim results diverge from authored physics properties.

• `v.y += x` on a local vector double-counts the gradient

  github:NVIDIA/warp11/7/2026otherwarp

  Warp produces wrong gradients when using += or -= through attributes of local vectors/quaternions/transforms (e.g., w.y += x), effectively double-counting in backprop. The subscript form (w[1] += x) behaves correctly, indicating a codegen/autodiff bug.

  ⚡ Incorrect gradients in Warp’s autodiff can invalidate optimization and learning pipelines that underpin differentiable simulation and model-based Physical AI.

• LEAPP export disables TorchScript after external task imports

  github:isaac-sim/IsaacLab11/7/2026training-infrarlisaac-simisaac-lab

  LEAPP export imports external task entry points before disabling TorchScript, so scripted helpers may compile too early. This breaks tracing tensors and can make exported targets constant, causing re-entry validation to fail unless PYTORCH_JIT=0 is set.

  ⚡ Export determinism and correct TorchScript/tracing behavior are key to taking trained policies from Isaac Lab into deployable Physical AI runtimes.

• `ptxas` fails on `.ptx` files written by `wp.compile_aot_module()` and the kernel cache

  github:NVIDIA/warp11/7/2026hardware-integrationhardwarewarp

  Warp-written .ptx files include a trailing NUL byte that causes ptxas/nvcc to fail with 'Unexpected EOF', preventing external assembly to cubin. The same issue affects kernel-cache PTX outputs and even basic text tooling like grep.

  ⚡ Interoperable compilation artifacts (PTX/cubin) are important for integrating Warp kernels into larger Physical AI build and deployment toolchains.

• [BUG] SolverImplicitMPM: with the default sparse grid, a viscous film on the ground plane flows ~15 % slower than with grid_type="dense"

  github:newton-physics/newton11/6/2026renderingrenderinghardwarenewtonwarp

  Implicit MPM produces materially different viscous flow speeds on a ground plane depending on whether the sparse or dense grid is used. The discrepancy appears tied to sparse-grid node plane offsets/translation behavior, leading to ~15% slower flow with the de

  ⚡ Physics solvers that change outcomes based on internal grid representations undermine trust and block adoption for high-fidelity Physical AI simulation workflows.

• wp.from_torch() and wp.from_dlpack() fail on 0-d tensors and mishandle single-vector tensors

  github:NVIDIA/warp11/6/2026otherwarp

  Warp's PyTorch and DLPack converters fail on 0‑D tensors (raising IndexError) and mishandle single-vector tensors with vector dtypes, producing unexpected strides/contiguity and gradient shape assignment errors. This breaks common interop patterns that work wi

  ⚡ Robust tensor interop is foundational for integrating Warp into PyTorch-based Physical AI training stacks without edge-case failures.

• [Bug Report] OvPhysX: deformable object rows are ordered lexicographically, so envs ≥ 10 read/write another env's deformable

  github:isaac-sim/IsaacLab11/6/2026crashes-stabilitycrashrenderingisaac-sim

  On the OvPhysX backend, deformable object view rows are ordered lexicographically rather than by environment index once the scene has 10+ environments. As a result, reads/writes/resets for deformables can target the wrong environment, corrupting simulation sta

  ⚡ Multi-environment correctness bugs break scalable RL/simulation training, directly impacting throughput and reproducibility for Physical AI development.

• Thor yocto构建的A/B系统切换问题

  nvidia-forum:robotics-edge-computing11/6/2026deploymentthoryoctoa-b-updatesotaembedded-linuxsystem-switching

  User reports an issue with A/B system switching in a Thor Yocto build. This indicates deployment/update reliability problems in an embedded Linux workflow where slot switching should be dependable.

  ⚡ Robust OTA and A/B update workflows are critical for scalable, safe field deployment of Physical AI systems on NVIDIA edge platforms.

• [BUG] MJCF `<adhesion>` actuator is silently dropped on import

  github:newton-physics/newton11/6/2026asset-pipelineusdmujoconewtonwarp

  Newton's MJCF importer silently drops MuJoCo `<adhesion>` actuators during `add_mjcf`, leading to `nu` becoming 0 with no warning. This breaks model behavior and makes debugging difficult because the import succeeds but functionality is missing.

  ⚡ Faithful MJCF import is important for interoperability across simulators and toolchains feeding Physical AI training and evaluation.

• [BUG] Thin convex hull on a triangle mesh: downward normals at a seam between coplanar triangles, and no contacts past the volume centroid (#4766 follow-up)

  github:newton-physics/newton11/6/2026crashes-stabilitycrashusdrenderinghardwaredeploymentmujoco

  A thin convex hull resting on a closed triangle mesh loses support on coplanar seams due to downward-facing contact normals and also loses all contacts after sinking past its volume centroid. The object can fall through the mesh in scenarios where analytic pla

  ⚡ Contact robustness on meshes is foundational for reliable manipulation/locomotion simulation and training stability across diverse assets.

• Gpu error

  nvidia-forum:robotics-edge-computing11/6/2026other

  User reports a generic "Gpu error" with no additional details in the corpus. The problem indicates an unstable or failing GPU path that needs investigation and clearer error reporting.

  ⚡ GPU error visibility and actionable diagnostics are required to keep simulation, training, and edge inference workloads dependable.

• [BUG] Rigid contact writing loses precision far from the origin

  github:newton-physics/newton11/6/2026crashes-stabilitycrashnewtonwarp

  Rigid contact writing loses precision far from the origin: translating a rigid pair by 128 m changes body-local contact points by up to 9.76 µm even when relative pose is unchanged. The writer rounds world endpoints before transforming back, which can also mis

  ⚡ Large-world precision issues can undermine physically correct contacts for warehouse/factory-scale simulation and long-horizon autonomy evaluation.

• MathDx calls from a @wp.func fail to link in CUDA 13 debug builds

  github:NVIDIA/warp11/5/2026renderingrenderinghardwarewarp

  In Warp debug mode with CUDA Toolkit 13, calling a MathDx-backed tile builtin through a `@wp.func` in a backward-enabled kernel fails to link with an nvJitLink/NVVM compilation error. Calling the builtin directly from the kernel works, indicating a specific li

  ⚡ Toolchain compatibility (CUDA 13 + debug) is crucial for developer velocity when building differentiable simulation and learning kernels with Warp.

• CPU-block lanes use stale floating-point control state (FTZ, rounding)

  github:NVIDIA/warp11/5/2026otherwarp

  When CPU cooperative blocks are enabled, Warp CPU fibers can run with stale floating-point control state (FTZ, rounding, exceptions) captured at fiber creation, not the launching thread’s current state. This can cause cooperative CPU-block results to differ fr

  ⚡ Deterministic numerics across execution paths are critical for trust in simulation, robotics optimization, and reproducible training results on NVIDIA’s Physical AI platform.

• [BUG] SolverMuJoCo freezes slow joint motion: sub-spacing position increments are rounded away in float32 joint_q while qvel persists

  github:newton-physics/newton11/5/2026crashes-stabilitycrashmanipulationdxintegrationmujoconewton

  SolverMuJoCo can freeze slow joint motion because joint positions are stored as float32 and sub-spacing increments get rounded away while velocity persists. This can cause position-driven joints to stop converging once motion slows below a threshold set by dt

  ⚡ Numerical precision pitfalls in solver state plumbing can silently invalidate slow-motion control behaviors that Physical AI training relies on.

• `array_scan` that works inside conditional bodies and foreign captures (caller-provided temp storage, or a capture query)

  github:NVIDIA/warp11/5/2026renderingrenderinghardwarewarp

  Warp’s array_scan allocates and frees CUB temp storage inside the call, which breaks CUDA graph capture in conditional capture bodies and in captures started by other frameworks. The request is for caller-provided temp storage or a capture-query mechanism to m

  ⚡ Graph-capture-safe primitives are key to high-performance training and pipeline composability across CUDA frameworks in NVIDIA’s Physical AI platform.

• ParticleField (3DGS) renders blurred when added to an already open stage

  github:isaac-sim/IsaacSim11/5/2026asset-pipelinev6.2.0usdrenderinghardwaresensorsintegrationisaac-sim

  ParticleField3DGaussianSplat renders significantly blurrier when referenced into an already-open stage than when present at stage open. Rendering a few frames immediately after adding the reference is reported as a workaround, implying initialization/order-dep

  ⚡ Rendering consistency when building stages programmatically is important for scalable synthetic data and perception validation in Physical AI workflows.

• [BUG] Kamino contact examples drop a substep per frame under graph capture

  github:newton-physics/newton11/5/2026renderingrenderinghardwarenewton

  When running certain contact examples with the Kamino solver under CUDA graph capture, a Python-level state buffer swap is captured incorrectly, causing one substep to be effectively skipped each frame. With an odd substep count, each replay starts from the wr

  ⚡ CUDA Graph capture correctness issues in physics stepping can silently corrupt sim time and undermine deterministic, high-performance simulation pipelines critical for Physical AI training and testing

• Orin Nano: ~20 us memory stall on 1 s BPMP EMC tick. Can it be disabled?

  nvidia-forum:robotics-edge-computing11/5/2026deploymentorin-nanolatencymemory-stallbpmpemcreal-time

  User reports ~20 µs memory stalls on a 1-second BPMP EMC tick on Orin Nano and asks whether it can be disabled. This periodic stall may violate low-latency requirements and needs a mitigation or configurability option.

  ⚡ Deterministic latency on Jetson platforms is crucial for real-time Physical AI control and perception workloads at the edge.

• ArticulationView.get_generalized_gravity_forces() overwrites link accelerations and velocities, and returns wrong torques for floating-base articulations

  github:isaac-sim/IsaacSim11/5/2026crashes-stabilitycrashrlusdrenderinghardwarelocomotion

  In the PhysX tensor API on GPU, ArticulationView.get_generalized_gravity_forces() has side effects that overwrite later reads of link accelerations and velocities until the next simulate(). It also returns wrong torques for floating-base articulations, comprom

  ⚡ Correct and side-effect-free physics tensor APIs are necessary for trustworthy learning, control, and analytics on top of Isaac Sim/PhysX.

• CPU &GPU Frequency unnormal under super mode

  nvidia-forum:robotics-edge-computing11/4/2026hardware-integrationrobotics-edge-computingcpu-frequencygpu-frequencypower-modesperformance-stability

  CPU and GPU frequency behavior is reported as abnormal when running in "super mode". This can impact performance consistency and thermal/power management during robotics workloads.

  ⚡ Power/performance mode instability on edge platforms threatens predictable real-time behavior for deployed Physical AI systems.

• [BUG] warp.optim.linear solvers are slow on CPU and ignore use_cuda_graph=True

  github:NVIDIA/warp11/4/2026hardware-integrationhardwarewarp

  warp.optim.linear solvers are slow on CPU due to a dot-product tiling strategy that redundantly computes sums. The use_cuda_graph=True option has no effect on CPU, forcing repeated Python overhead each iteration.

  ⚡ Inefficient CPU solver paths and missing graph replay reduce throughput and raise iteration cost for optimization-heavy Physical AI workloads.

• [BUG] SolverVBD: particle-body attachments are ignored in deterministic mode when contacts are passed to step()

  github:newton-physics/newton11/4/2026crashes-stabilitynewton-physicsvbddeterministic-modecontactsforce-accumulationwarp-kernels

  In deterministic mode, SolverVBD ignores particle-body attachments when contacts are passed to step(), due to a kernel doing a plain write that overwrites accumulated forces/hessians. This breaks expected force accumulation behavior under specific stepping con

  ⚡ Deterministic simulation correctness is essential for reliable regression testing and reproducible training in Physical AI workflows.

• [BUG] SolverVBD: with particle self-contact on, a cloth pile sinks through a static ground plane

  github:newton-physics/newton11/4/2026crashes-stabilitynewtonsolver-vbdclothself-contactground-collisiondeformables

  With particle self-contact enabled, SolverVBD truncates particle motion against self-contact planes but does not robustly truncate motion into static collision shapes by default. This makes cloth piles sink through a static ground unless additional collision p

  ⚡ Accurate, stable cloth–rigid contact handling is a prerequisite for trustworthy deformable simulation in Physical AI training and testing loops.

• [BUG] SolverSemiImplicit and SolverXPBD bending: the dihedral-angle gradient is scaled by twice the triangle area, so bending depends on the mesh size (and is skipped below ~1 mm)

  github:newton-physics/newton11/4/2026crashes-stabilitynewtonsolver-xpbdsolver-semi-implicitcloth-bendingmesh-scalingdihedral-angle

  Bending in SolverSemiImplicit and SolverXPBD is incorrectly scaled (by twice triangle area), making bending behavior depend on mesh size. For very small triangles (~1 mm and below), bending can effectively be skipped.

  ⚡ Mesh-resolution-invariant deformable behavior is critical for consistent simulation fidelity across assets and scales.

• [BUG] SolverMuJoCo drops noslip_iterations and noslip_tolerance from the MJCF <option> element

  github:newton-physics/newton11/4/2026integrationnewtonsolver-mujocomjcfnoslipgraspingimport-parity

  SolverMuJoCo ignores noslip_iterations and noslip_tolerance from the MJCF <option> element with no warning. Models relying on noslip (e.g., grasps) behave differently than in MuJoCo/MuJoCo Warp.

  ⚡ MJCF option parity directly impacts sim-to-sim consistency and user trust when integrating external model formats into Physical AI stacks.

• [BUG] Kamino: joint_axis edits notified with JOINT_PROPERTIES bypass axis validation

  github:newton-physics/newton11/4/2026crashes-stabilitynewtonkaminojoint-axismodel-validationnotify-model-changedjoint-frames

  Kamino skips axis validation when joint_axis updates are notified via JOINT_PROPERTIES rather than JOINT_DOF_PROPERTIES. Invalid joint axes can then be simulated with incorrect joint frames without being caught.

  ⚡ Robust model validation pathways are necessary to prevent silent physics corruption in downstream robotics behaviors.

• [BUG] SolverVBD: dihedral bending is silently off for hinges with triangles smaller than ~1 mm (absolute degeneracy threshold)

  github:newton-physics/newton11/4/2026crashes-stabilitynewtonsolver-vbddihedral-bendingdegeneracy-thresholdsmall-scale-meshescloth

  SolverVBD’s dihedral-angle bending treats small hinges as degenerate using an absolute threshold, causing bending forces/Hessians to return zero for triangles below ~1 mm. This silently turns off bending for small-scale or high-resolution meshes.

  ⚡ Scale-robust deformable constraints are essential for consistent behavior across real-world-sized assets and high-resolution meshes.

• [BUG] SolverVBD: a free cloth's momentum does not change by the applied impulse (net residual of the per-vertex sweep)

  github:newton-physics/newton11/4/2026crashes-stabilitynewtonsolver-vbdclothmomentumimpulse-responseexternal-forces

  SolverVBD does not apply external forces in a way that changes total cloth momentum by the expected impulse, even with no gravity, contacts, or damping. The residual error depends on load location/shape and does not shrink with more iterations.

  ⚡ Conservation-law violations undermine confidence in physics-based training signals and can destabilize learned control policies.

• [BUG] MJCF geom solref and joint solreflimit with one value get damping ratio 0 instead of MuJoCo's 1

  github:newton-physics/newton11/4/2026integrationnewtonsolver-mujocomjcfsolrefsolreflimitparameter-parity

  One-value solref/solreflimit attributes (which MuJoCo interprets as (value, 1)) are read into Newton with a damping ratio of 0 instead of 1. This yields invalid solref values and can cause MuJoCo C to replace them with defaults, losing authored parameters and

  ⚡ Exact behavioral parity with MuJoCo file semantics is important to avoid hidden physics drift when users bring existing MJCF assets into the platform.

• [BUG] SolverMuJoCo copies explicit contact pair properties onto the wrong MuJoCo pairs when the compiler reorders pairs

  github:newton-physics/newton11/4/2026integrationmujocowarpcontact-pairsfrictionsolvercompiler-reorder

  SolverMuJoCo (MuJoCo Warp) can apply explicit contact pair properties (friction/solref/solimp/margin/gap) to the wrong pair when the MuJoCo compiler reorders pairs. The host mj_model is correct but the GPU-side mapping uses the pre-reorder index order.

  ⚡ Correct transfer of contact/material parameters across compilers and backends is critical for consistent physics behavior across NVIDIA’s simulation and warp-accelerated stacks.

• Float64 Grid3D PicQuadrature lookup receives a float32 distance bound

  github:NVIDIA/warp11/3/2026hardware-integrationhardwarewarp

  ## Bug description On the released Warp 1.19.0 CUDA 12 wheel, float64 particle quadrature on `Grid3D` fails to compile even when every particle is inside the grid. `Cells.element_partition_lookup` passes a float32 `max_dist`, while `Grid3D.make_filtered_cell_

• [r36.4.4] vi5_fops.c: wrong address freed in tegra_channel_capture_setup() error path → Bad page state → kernel panic

  nvidia-forum:robotics-edge-computing11/3/2026other
• isaac-sim-validator SKILL.md: Kit decision tree diagram fails to render

  github:isaac-sim/IsaacSim11/3/2026renderingrenderinghardwareisaac-sim

  ### Description The Mermaid diagram under "Kit decision tree" in `skills/isaac-sim-validator/SKILL.md` doesn't render on GitHub. It shows "Parse error on line 3". **Cause:** the Reject labels have quotes partway through the label, for example `C[Reject: "No

• AGX Orin 64GB (P3701-0005): `MSS: Failed to initialize SDRAM`

  nvidia-forum:robotics-edge-computing11/3/2026hardware-integrationhardware
• Disabled joints still produce "CreateJoint - found a joint with disjointed body transforms" warnings

  github:isaac-sim/IsaacSim11/3/2026crashes-stabilityv6.1.0crashrenderinghardwareintegrationisaac-sim

  ### Description ### Description PhysX warns about joints whose two body frames don't line up, even when the joint is disabled, durring Isaac's boot (`physics:jointEnabled = false`): [Warning] [omni.physx.plugin] PhysicsUSD: CreateJoint - found a joint wi

• Orin NX (JetPack 7.2.1 / R39.2.1): 3rd monitor on DP MST hub fails with "cannot find crtc". Is there any way to drive 3 independent displays?

  nvidia-forum:robotics-edge-computing11/3/2026hardware-integrationhardware

  On Orin NX with JetPack 7.2.1 / R39.2.1, a third display connected via a DisplayPort MST hub fails with a "cannot find crtc" error. The user is asking if there is any supported way to drive 3 independent displays.

  ⚡ Display bring-up limits on Jetson edge devices can block field deployments of Physical AI systems that need multi-monitor operator/UIs.

• Orin NX JP7.2.1 nvcompositor problem

  nvidia-forum:robotics-edge-computing11/3/2026renderingjetsonorin-nxjetpackjp7-2-1nvcompositordisplay-pipeline

  User reports an nvcompositor problem on Orin NX running JP7.2.1.

  ⚡ Display/compositing stability on Jetson affects end-to-end robotics UX and perceived platform robustness in deployed Physical AI products.

• T5000 custom carrier: The growth rate of oc3_event_cnt is much faster than that of oc2_event_cnt

  nvidia-forum:robotics-edge-computing11/3/2026hardware-integrationjetsont5000custom-carrierperformance-countersoc2-event-cntoc3-event-cnt

  On a T5000 custom carrier, user observes oc3_event_cnt increasing much faster than oc2_event_cnt and is seeking explanation or fix.

  ⚡ Hardware counter anomalies on custom carriers can block performance validation, which is foundational for trustworthy Physical AI edge compute.

• How to unbind USB 2.0 companion port from USB 3.0 port on Jetson platform

  nvidia-forum:robotics-edge-computing11/3/2026hardware-integrationjetsonusbusb2usb3companion-portdevice-bringup

  User asks how to unbind a USB 2.0 companion port from a USB 3.0 port on Jetson platforms.

  ⚡ USB topology and binding control matters for integrating real robot peripherals, a prerequisite for robust Physical AI deployments.

• Atomic mapped sparse updates fail for empty matrices

  github:NVIDIA/warp11/3/2026crashes-stabilitycrashhardwarewarp

  In Warp sparse BSR assembly, atomic mapped sparse updates error out when the mapping is empty, raising an invalid indexing RuntimeError.

  ⚡ Correct sparse/atomic update semantics are important for differentiable simulation and optimization workflows that underpin Physical AI.

• P7.2.1 agx orin fail to install jtop

  nvidia-forum:robotics-edge-computing11/3/2026deploymentjetsonagx-orinjp7-2-1jtopinstallationsystem-monitoring

  User reports that on P7.2.1 AGX Orin they fail to install jtop.

  ⚡ Smooth installation of common monitoring tools on Jetson improves operability and trust in Physical AI edge deployments.

• wp.norm_l1, norm_huber, norm_pseudo_huber and smooth_normalize fail to compile for float16/float64 vectors

  github:NVIDIA/warp11/3/2026hardware-integrationhardwarewarp

  Warp math helpers (norm_l1, norm_huber, norm_pseudo_huber, smooth_normalize) fail to compile for float16/float64 vectors due to float32 constants mixed into generic vector code.

  ⚡ Broad dtype support in math utilities reduces friction for high-precision and mixed-precision Physical AI workloads.

• Official CYPD4226 (Cypress PD controller) firmware for Jetson AGX Orin on Jetson Linux R39.2.1 / JetPack 7.2.1?

  nvidia-forum:robotics-edge-computing11/2/2026docs-onboardingjetson-agx-orinjetson-linux-r39-2-1jetpack-7-2-1cypd4226usb-pdfirmware

  Asks for official CYPD4226 (Cypress PD controller) firmware for Jetson AGX Orin on Jetson Linux R39.2.1 / JetPack 7.2.1. Lack of an official artifact or guidance blocks/complicates USB-PD controller setup.

  ⚡ Clear, official firmware distribution and guidance reduces friction integrating Jetson into production robot platforms.

• WARNING @ [platform/drivers/mailbox/ivc_link_provider/mail_imo.c]: mail imo TX timeout

  nvidia-forum:robotics-edge-computing11/2/2026crashes-stabilityjetsonmailboxivctx-timeoutkernel-warningipc

  Reports a warning indicating an IVC mailbox path is hitting a TX timeout in `mail_imo.c`. This suggests intermittent or persistent IPC/messaging failures between platform components.

  ⚡ Robust inter-processor communication is critical to stable sensor/actuator stacks on NVIDIA edge platforms.

• 【Jetson Thor】The cpufreq.off parameter causes the CPU main frequency to drop

  nvidia-forum:robotics-edge-computing11/2/2026hardware-integrationjetson-thorcpufreqkernel-boot-paramscpu-frequencyperformance-scalingpower-management

  On Jetson Thor, using the `cpufreq.off` parameter causes the CPU main frequency to drop. This can unexpectedly reduce performance when users think they are disabling cpufreq behavior.

  ⚡ Power/performance control correctness on Jetson affects real-time robot behavior and on-device model latency.

• [5.1] Multi-camera semantic/instance annotation segfaults after missing InstanceMappingInfoSDhost

  github:isaac-sim/IsaacSim11/2/2026crashes-stabilitycrashusdrenderinghardwaresensorsperception

  In Isaac Sim 5.1, headless rendering of a BEHAVIOR scene segfaults after attaching semantic/instance segmentation annotators to five cameras, after a missing `InstanceMappingInfoSDhost`. This breaks multi-camera annotation generation even though RGB/depth/norm

  ⚡ Synthetic data generation at scale (multi-camera segmentation) must be stable for training perception models and evaluation pipelines.

• Ball-joint actuators ignore zero effort limits in SolverMuJoCo

  github:newton-physics/newton11/2/2026integrationnewtonmujococonverteractuatorsball-jointeffort-limits

  Ball-joint actuators in SolverMuJoCo apply force even when `joint_effort_limit` is zero because the converter emits `forcerange=[0,0]` without enabling `forcelimited`. This causes MuJoCo to treat the range as unset and still apply force.

  ⚡ Converter correctness issues between physics engines can silently invalidate actuator constraints, undermining reliability of cross-simulator Physical AI tooling.

• SolverSteel: compliance count properties block, and raise under CUDA graph capture

  github:newton-physics/newton11/2/2026crashes-stabilitynewtonsolversteelcuda-graphswarpdevice-copycontact-compliance

  In SolverSteel, `compliance_contact_count` and `compliance_skipped_contact_count` became properties that perform a blocking device copy. When read during CUDA graph capture, they raise a Warp CUDA error 906 due to stream capture dependencies.

  ⚡ CUDA graph capture compatibility is critical for high-performance training/simulation loops, so blocking device syncs in solver APIs create platform-level fragility.

• [Bug Report] `convert_camera_frame_orientation_convention` returns NaN under TF32 (ray-caster camera reads max range)

  github:isaac-sim/IsaacLab11/2/2026training-infrav2.3rlrenderinghardwaresensorsisaac-simisaac-lab

  With TF32 enabled on CUDA, `convert_camera_frame_orientation_convention(... target="world")` returns NaNs for most orientations. This propagates into `RayCasterCamera.set_world_poses`, causing rays to read max range with no error and breaking training entrypoi

  ⚡ Numerical robustness against TF32/mixed-precision is essential to prevent silent sensor corruption that can invalidate training and sim perception pipelines.

• Clang CUDA backend (`wp.config.llvm_cuda = True`) can't load kernels on GPUs older than sm_75

  github:NVIDIA/warp11/2/2026hardware-integrationhardwarewarp

  Warp's Clang CUDA backend hard-targets sm_75, causing kernel load failures on GPUs older than sm_75 even though the +cu12 wheels support down to sm_52. On a V100 (sm_70), enabling `wp.config.llvm_cuda = True` triggers PTX JIT failures at module load.

  ⚡ Compiler and runtime backend choices must remain compatible across the deployed GPU fleet or users will be blocked from running Physical AI workloads on older but still common hardware.

• wp.utils.runlength_encode() ignores strides and reads past the end of values

  github:NVIDIA/warp11/2/2026crashes-stabilitycrashhardwarewarp

  `wp.utils.runlength_encode()` ignores array strides, so non-contiguous inputs can silently produce incorrect results. It can also read past the end of the `values` buffer when `value_count` exceeds `values.size`, since only output sizes are checked.

  ⚡ Core utility correctness and memory safety are foundational for reliable Physical AI data processing and simulation loops.

• ray_intersect_box returns a zero normal for hits on box edges

  github:newton-physics/newton11/2/2026crashes-stabilitynewton-physicsraycastcollisionnumerical-robustnessnormalspath-tracing

  `raycast.ray_intersect_box` can return a hit with a zero normal when the ray hits box edges or corners. Strict EPS and in-face checks can cause both adjacent faces to be rejected, leaving `normal_local` as (0,0,0) and propagating bad normals downstream.

  ⚡ Physics and ray-query robustness is critical for dependable simulation and rendering-based sensing in Physical AI workflows.

• Jtop not working on 36.4.3 suddenly

  nvidia-forum:robotics-edge-computing11/2/2026tooling-dxjetsonjtopmonitoringdiagnosticsl4t-36-4-3

  A forum report says Jtop stopped working suddenly on 36.4.3. No additional details are provided in the corpus.

  ⚡ Edge developer workflows depend on stable system monitoring and diagnostics to operate and debug Physical AI deployments on Jetson.

• [T5000][R__._] RTC clock resets after power cycle – suspected erratum RTC-1 / PCN 213441 (pre-PCN module)

  nvidia-forum:robotics-edge-computing11/2/2026hardware-integrationt5000rtcpower-cycleerratumpcn-213441jetson-module

  A T5000 report claims the RTC clock resets after a power cycle and suspects an erratum (RTC-1) tied to PCN 213441 on a pre-PCN module. The corpus provides no further diagnostic details.

  ⚡ Hardware errata and platform reliability issues can undermine trust in edge deployment stability for Physical AI systems.

• Suspicious code in spi-tegra124-slave.c

  nvidia-forum:robotics-edge-computing11/2/2026hardware-integrationjetsonkernelspidriversecuritytegra124

  A forum thread flags suspicious code in `spi-tegra124-slave.c`. The corpus includes no specifics on the behavior or risk beyond the title.

  ⚡ Platform security concerns in low-level drivers can block enterprise deployment of Physical AI at the edge.

• AGX orin kernel reported error

  nvidia-forum:robotics-edge-computing11/2/2026crashes-stabilityjetsonagx-orinkernelerrorstabilityedge-computing

  A forum report states that an AGX Orin kernel reported an error. No additional error logs or context are provided in the corpus.

  ⚡ Kernel and driver stability on Jetson is essential for reliable, always-on Physical AI robots in production environments.

• Jetson Thor PCIe C2 Endpoint (Common Clock) forces 100MHz output on UPHY_REFCLK5, ignoring ODMDATA

  nvidia-forum:robotics-edge-computing11/2/2026hardware-integrationjetson-thorpciecommon-clockrefclkuphyodmdata

  A report claims Jetson Thor PCIe C2 Endpoint common clock forces 100MHz output on UPHY_REFCLK5 and ignores ODMDATA configuration. The corpus provides no further details.

  ⚡ Deterministic PCIe and clocking behavior is a prerequisite for integrating high-performance sensors and accelerators in Physical AI edge systems.

• Orinnano8g cannot be set in super mode

  nvidia-forum:robotics-edge-computing11/1/2026hardware-integrationjetsonorin-nanopower-modesuper-modeedge-deployment

  A user reports that Orin Nano 8GB cannot be set to “super mode.” The post provides no additional technical details in the corpus.

  ⚡ Power/performance mode configuration issues on Jetson-class devices can block predictable deployment behavior for Physical AI at the edge.

• Isaac Sim 6.2 (Kit 110.4): main thread hangs for good during a new RTX view's first frames (hydra texture updates re-enabled)

  github:isaac-sim/IsaacSim11/1/2026crashes-stabilityv6.2crashusdrenderinghardwaresensorsintegration

  Isaac Sim 6.2 (Kit 110.4) can hang the main thread permanently during the first frames of a new RTX view triggered by hydra texture updates. Repeated creation of RTX views eventually freezes the app with no error, requiring the process to be killed; a script r

  ⚡ Stability of RTX view creation and rendering loops is foundational for synthetic data capture and interactive workflows in NVIDIA's Physical AI platform.

• [BUG] wp.erfcinv() and wp.erfinv() return inf, 0, or imprecise values on CPU for extreme arguments

  github:NVIDIA/warp11/1/2026renderingrenderinghardwarewarp

  Warp's CPU implementations of erfcinv/erfinv lose precision or return inf/0 for extreme arguments due to catastrophic cancellation. CUDA behaves correctly, leading to inconsistent results across devices.

  ⚡ Numerical parity between CPU and CUDA math primitives is important for reproducible training, validation, and sim pipelines in Physical AI.

• [BUG] Hollow capsule inertia uses a thicker shell at the end caps

  github:newton-physics/newton11/1/2026othernewton-physicsinertiarigid-body-dynamicscapsulegeometryphysics-correctness

  Newton computes hollow capsule inertia by shrinking both radius and half-height for the inner capsule, making the end caps effectively thicker than intended. This inflates mass and inertia versus the documented shell thickness behavior.

  ⚡ Accurate inertial properties in physics stacks are foundational for credible sim-to-real transfer in Physical AI workflows.

• [Question] I can not import VisualMaterial package when I use Kit visualizer

  github:isaac-sim/IsaacLab11/1/2026renderingrenderingisaac-simisaac-lab

  In Kit visualizer, the user cannot import or use the VisualMaterial package as expected when trying to animate a belt texture via code. This blocks a common workflow for procedural material control in environments.

  ⚡ Smooth Kit/Isaac Lab scripting and material APIs are key to making environment authoring and domain randomization scalable for Physical AI.

• Jetson AGX Thor MGBE: TX packet flood (~200k pkt/s) with UDP frames larger than 1500 bytes (USRP X310 / UHD)

  nvidia-forum:robotics-edge-computing11/1/2026hardware-integrationjetson-agx-thormgbeethernetudpjumbo-framesnetworking

  User reports a TX packet flood (~200k pkt/s) on Jetson AGX Thor MGBE when sending UDP frames larger than 1500 bytes, in a USRP X310/UHD context. This indicates problematic handling of jumbo/fragmented UDP traffic at the NIC/driver stack.

  ⚡ Reliable high-throughput networking on Jetson platforms is important for deployed Physical AI systems that ingest large UDP sensor/SDR streams.

• warp.optim.linear solvers captured on CPU perform no iterations on replay

  github:NVIDIA/warp10/31/2026renderingrenderinghardwaredocswarp

  Warp linear solvers captured into a CPU graph can report zero iterations on replay and leave the solution unchanged, with no warning. The behavior depends on check_every and differs from eager CPU execution and CUDA capture behavior.

  ⚡ Graph-safe optimization primitives are necessary for compiling repeatable physics/learning workloads in Physical AI pipelines.

• CPU textures reject vector-dtype Warp arrays in the constructor, copy_from(), and copy_to()

  github:NVIDIA/warp10/31/2026renderingrenderinghardwarewarp

  CPU wp.Texture{1,2,3}D rejects vector-dtype wp.array inputs (e.g., wp.vec4) in constructors and copy_from()/copy_to(), raising incompatible dtype errors. The equivalent CUDA behavior succeeds and treats vector dtypes as channel data.

  ⚡ Consistent texture IO semantics across CPU and CUDA are important for reproducible rendering/sensor pipelines used in Physical AI tooling.

• capture_launch() inside a CPU graph capture silently drops the inner graph's kernel launches

  github:NVIDIA/warp10/31/2026renderingrenderinghardwarewarp

  Nested CPU graph capture with capture_launch() does not error but silently drops the inner graph’s kernel launches during replay, producing wrong results. CUDA raises a RuntimeError in the same situation, while CPU only emits a stderr message.

  ⚡ Silent correctness failures in captured execution undermine trust in deterministic replay, which is foundational for scalable Physical AI experimentation.

• [BUG] SensorCamera skips faint Gaussian splats that a ray enters after their sort key

  github:newton-physics/newton10/31/2026sensors-perceptionnewtonsensor-camerarenderinggaussian-splatsbvhsynthetic-data

  SensorCamera rendering can miss faint Gaussian splats or blend them incorrectly due to a BVH query cutoff once the hit buffer is full. The issue is rare but can change a small fraction of pixels and produce incorrect intensity ordering.

  ⚡ Rendering/sensor correctness issues in differentiable or raytraced camera models directly affect synthetic data fidelity and downstream perception training quality.

• Array-interface kernel arguments skip the ndim check and can read out of bounds

  github:NVIDIA/warp10/31/2026hardware-integrationhardwarewarp

  Kernel arguments passed via array-interface paths bypass the ndim check, so mismatched dimensionality can launch and read out of bounds instead of raising. The same mismatch correctly errors for wp.array arguments.

  ⚡ Robust input validation is essential to prevent silent memory misuse that can corrupt results in large-scale Physical AI training and simulation pipelines.

• [BUG] SensorCamera: Gaussian splats at or under 51% opacity render as background holes, and SH above degree 0 is ignored

  github:newton-physics/newton10/31/2026sensors-perceptionnewtonsensor-cameragaussian-splatsopacityspherical-harmonicsrendering

  Newton SensorCamera renders black background holes for Gaussian splats around or below ~51% opacity and ignores spherical harmonics above degree 0, causing view-independent colors. The report ties both behaviors to shade() logic in gaussians.py and shows measu

  ⚡ Accurate appearance modeling (opacity handling and SH lighting) is a prerequisite for high-quality sensor simulation and reliable synthetic data generation from 3DGS assets.

• [Bug Report] OVRTX renderer cannot load a scene with a large Gaussian splat because the USDA hand-off cuts values longer than 2^31 - 1 characters

  github:isaac-sim/IsaacLab10/31/2026asset-pipelinev3.0.0usdrenderinghardwareisaac-simisaac-lab

  Isaac Lab 3.0.0 with the OVRTX renderer fails to load scenes containing a large Gaussian splat when the stage is handed off as inline USDA text. The OpenUSD USDA writer silently truncates very long attribute values (beyond a 32-bit length limit), causing OVRTX

  ⚡ This highlights scalability limits in the USD-to-renderer handoff path that can block large scene/asset workflows critical for Physical AI simulation at scale.

• Orin NX 8Gb update QSPI error

  nvidia-forum:robotics-edge-computing10/31/2026hardware-integrationhardware
• [MJX] mjx.step() deadlocks on ROCm (gfx1101) when the model contains an ACCELEROMETER sensor

  github:google-deepmind/mujoco10/30/2026crashes-stabilitycrashrenderingsensorsdocsintegrationmujoco

  On AMD ROCm (gfx1101), `mjx.step()` hangs indefinitely on first execution when the model includes an ACCELEROMETER sensor. Removing accelerometer sensors avoids the deadlock and restores normal step times, suggesting a GPU-side blocking issue tied to that sens

  ⚡ Cross-vendor accelerator stability problems in differentiable simulation ecosystems can limit portability of training pipelines and sensor-rich models.

• Jetson Thor failed to enter SC7 mode on the custom board

  nvidia-forum:robotics-edge-computing10/30/2026hardware-integrationhardware

  Jetson Thor reportedly fails to enter SC7 mode on a custom board. The issue suggests a platform power-management integration problem specific to a custom carrier design.

  ⚡ Reliable low-power state transitions on Jetson-class devices enable always-on robotics deployments with predictable power and thermal behavior.

• AGX Orin startup cpu error, system hangs / AGX Orin R39.2.1

  nvidia-forum:robotics-edge-computing10/29/2026crashes-stabilitycrashhardware

  AGX Orin reports a startup CPU error and the system hangs on R39.2.1. This prevents the device from booting or becoming usable without a fix or workaround.

  ⚡ Jetson boot reliability issues directly undermine confidence in deploying Physical AI workloads at the edge.

• [Orin Nano][R39.2.1] System hang when a USB HID remote-wakeup signal platform becomes unable to suspend again`

  nvidia-forum:robotics-edge-computing10/29/2026crashes-stabilitycrashhardware

  On Orin Nano R39.2.1, after a USB HID remote-wakeup signal the platform becomes unable to suspend again and may hang. This blocks reliable suspend/resume workflows.

  ⚡ Power-management regressions around USB wake/suspend can break always-on robotics edge deployments and fleet stability.

• Cpu infinite error loop during shutdown / Jetson AGX Orin R39.2.1

  nvidia-forum:robotics-edge-computing10/29/2026hardware-integrationhardware

  Jetson AGX Orin on R39.2.1 hits an infinite CPU error loop during shutdown. This indicates the platform cannot reliably power down cleanly.

  ⚡ Shutdown stability problems increase operational risk for deployed Physical AI systems that require predictable power cycling.

• Investigate OVRTX sensor frame selection when DLSS frame generation returns multiple frames

  github:isaac-sim/IsaacLab10/29/2026asset-pipelineusdrenderingsensorsdocsisaac-labnewton

  IsaacLab's replacement RTX pipeline assumes the first OVRTX output frame is the camera capture and ignores additional frames. With DLSS frame generation returning multiple frames, this may select the wrong image and break sensor data correctness.

  ⚡ Sensor timing/frame selection correctness under advanced rendering (DLSS frame generation) is critical for trustworthy perception data in sim and training loops.

• [BUG] Comparing struct values in a kernel fails with a C++ compiler error

  github:NVIDIA/warp10/29/2026otherwarp

  Comparing `@wp.struct` values in a Warp kernel passes code generation but fails later with a C++ compiler error in the kernel cache. The error surfaces far from the offending Python line, making debugging significantly harder.

  ⚡ Earlier, clearer error reporting in Warp kernels reduces iteration time for developers building Physical AI components on GPU compute.

• SolverSteel: nv_humanoid ragdolls become non-finite with joint limits off

  github:newton-physics/newton10/29/2026crashes-stabilitycrashusdrenderinghardwarenewtonwarp

  With SolverSteel, `nv_humanoid.xml` ragdolls can go non-finite shortly after landing when joint limits are off. The report ties failures to extreme joint angles (e.g., hip D6 nearing singular configurations) leading to simulation breakdown.

  ⚡ Humanoid physics stability is a core credibility pillar for Physical AI simulation; non-finite failures block scalable training and evaluation.

• Tiled BVH/mesh queries overflow their shared traversal stack (illegal memory access, hang, or missing results)

  github:NVIDIA/warp10/29/2026crashes-stabilitycrashrenderinghardwarenewtonwarp

  Warp tiled BVH/mesh query functions use a fixed-capacity shared traversal stack that can overflow, leading to illegal memory access, hangs, or missing results. The code increments the stack counter even when skipping stores on overflow, enabling out-of-bounds

  ⚡ GPU query primitives that can hang or corrupt results threaten reliability of core geometry operations used across simulation, perception, and planning stacks.

• [BUG] Illegal memory access / segfault / hang in `narrow_phase_find_mesh_triangle_overlaps_kernel` when mesh BVHs are built with `cubql`

  github:newton-physics/newton10/29/2026crashes-stabilityv3.0crashrenderinghardwareperceptionisaac-labmujoco

  Dense triangle-mesh vs convex collisions can crash, hang, or trigger CUDA illegal memory access in `narrow_phase_find_mesh_triangle_overlaps_kernel` when the mesh BVH is built using `cubql`. Switching BVH constructors to `sah` or `lbvh` avoids the failure, but

  ⚡ Physics/collision GPU stability issues in default Isaac Lab/Newton configurations can block training and simulation workflows and undermine trust in the platform’s determinism and robustness.

• Isaac Sim 6.2.0 WebRTC: nvstSetRemotePeerIceCandidate looks up server[2] after only server 1 was created

  github:isaac-sim/IsaacSim10/29/2026crashes-stabilityv6.2.0crashrenderinghardwaredeploymentintegrationisaac-sim

  In Isaac Sim 6.2.0 WebRTC streaming, nvstSetRemotePeerIceCandidate appears to look up server[2] even though only one server was created. After long uptime, the client connects but video remains black and the UDP stream port is not held.

  ⚡ Robust remote streaming is foundational for scalable sim ops; long-uptime WebRTC failures erode trust in Isaac Sim for headless/remote workflows.

• Compatibility of NVIDIA Reference Board Flash Configuration with a Custom Jetson Orin NX / Orin Nano Carrier Board

  nvidia-forum:robotics-edge-computing10/29/2026hardware-integrationjetson-orin-nxjetson-orin-nanocarrier-boardflashingboard-supporthardware-bringup

  User asks whether NVIDIA reference board flash configurations are compatible with a custom Jetson Orin NX / Orin Nano carrier board. The corpus provides no additional detail, indicating uncertainty in the official path for custom hardware.

  ⚡ Clear guidance for flashing on custom carrier boards reduces bring-up time and increases the attach rate of Jetson in commercial robotics designs.

• Jetson Orin NX R35.3.1: Official `video_encode` sample crashes when using `V4L2_ENC_CMD_STOP`

  nvidia-forum:robotics-edge-computing10/29/2026crashes-stabilityjetson-orin-nxr35-3-1v4l2video-encodesample-codecrash

  On Jetson Orin NX R35.3.1, the official video_encode sample crashes when using V4L2_ENC_CMD_STOP. This suggests a problematic stop/EOS path in the encode workflow or sample implementation.

  ⚡ Media stack stability on Jetson directly impacts robotics perception and logging pipelines, so sample crashes can block downstream adoption.

• Jetson AGX Thor R38.2.0: `nvv4l2h264enc` hangs at EOS with Baseline profile and B-frames

  nvidia-forum:robotics-edge-computing10/29/2026crashes-stabilityjetson-agx-thorr38-2-0gstreamernvv4l2h264ench264eos-hang

  On Jetson AGX Thor R38.2.0, nvv4l2h264enc hangs at EOS when using Baseline profile and B-frames. This can block pipelines from completing or releasing resources.

  ⚡ Encoder hangs at EOS undermine reliability for robotics video pipelines that depend on deterministic shutdown and file finalization.