Release Notes#

Current Release#

Version 26.10 — October 2026#

This release covers everything that landed on the 26.10 release branch since 26.09.

NuRec is now open source. The source tree and its agent skills are published at github.com/NVIDIA/NuRec under Apache-2.0, and the package, module and image names change from nre to nurec as part of that move. Most of the upgrade work below follows from the rename. See Set Up NuRec Software for how to clone the release branch and build from source.

Upgrade From 26.09

Work through these before upgrading. Each one is detailed under Breaking Changes.

Repoint gRPC imports from nre.grpc.protos.* to nurec.grpc.protos.* and regenerate your client stubs.
Repoint container image references from nre-ga and nre-tools-ga to nurec-ga and nurec-tools-ga.
Rename the nre_tools command to nurec_tools, and its in-container path to /app/apps/nurec_tools.
Build the gRPC client distribution from source; it is no longer published as an NGC resource.
If you build from source or extend NuRec in-process, move to PyTorch 2.11.
Relax any gRPC client that asserts an exact grpc_api_version patch; it now reports 0.0.5.

Breaking Changes

NuRec Is Now Open Source, and nre Is Renamed to nurec: The source tree is published under Apache-2.0 with LICENSE.md, CONTRIBUTING.md, CODE_OF_CONDUCT.md, SECURITY.md and GitHub issue and pull request templates, and the public tree carries abbreviated NVIDIA SPDX headers on every source file. The rename reaches every public surface:
- The gRPC proto packages move from nre.grpc.protos.common, nre.grpc.protos.sensorsim and nre.grpc.protos.ipc to nurec.grpc.protos.common, nurec.grpc.protos.sensorsim and nurec.grpc.protos.ipc. Generated client stubs must be regenerated against the new package names. The proto wire format is unchanged, so a client that talks to the server over the wire without importing the generated Python packages needs no change.
- The published container images are renamed from nvcr.io/nvidia/nre/nre-ga and nvcr.io/nvidia/nre/nre-tools-ga to nvcr.io/nvidia/nre/nurec-ga and nvcr.io/nvidia/nre/nurec-tools-ga. The registry path itself is unchanged; only the image names move.
- The nre_tools command is renamed to nurec_tools, and its path inside the tools image moves from /app/nre/apps/nre_tools to /app/apps/nurec_tools. The run image’s /app/run entry point is unchanged.
- The Python distribution is renamed from nre to nurec, and the source tree’s top-level nre/ package becomes nurec/, so in-process imports move from nre.* to nurec.*.
The gRPC Client Distribution Is Built From Source: The gRPC client distribution was previously downloaded as an NGC resource (nvidia/nre/nre_grpc_protos). It is now built from the published source tree with the //nurec/grpc/release:customer_distribution_tarball target. If you consumed the NGC resource, switch to building the tarball from a checkout of the release branch.
PyTorch 2.11: The runtime moves from PyTorch 2.7 to torch==2.11.0+cu128.nre1. This matters if you build NuRec from source, load NuRec in the same process as your own PyTorch code, or depend on the pinned Transformer Engine build, which is patched for 2.11. Reconstruction and rendering results are unchanged.
NCore 19.8.0: NCore moves from 19.5.1 to 19.8.0. No serialized data format changed, so datasets and reconstructions written by earlier releases load exactly as before, but NuRec now validates sensor models more strictly — see Stricter Sensor Model Validation under Core Improvements.
gRPC API Version Is 0.0.5: get_version() now reports grpc_api_version 0.0.5, up from 0.0.3 in 26.09. Every increment so far has been additive — new discovery keys, new RPCs, and new request and response fields, all with a byte-identical proto wire format for existing clients — so a client that negotiates on major.minor needs no change. A client asserting an exact patch such as (0, 0, 3) will mismatch after upgrading; relax those checks to major.minor.

Core Improvements

CUDA IPC Delivery for Same-Node gRPC Clients: serve-grpc can now hand rendered frames to a client on the same node through CUDA IPC instead of copying them over the wire, behind the same gRPC endpoint. Set cuda_ipc=true and ipc_session_id on the render request to use it. The CUDA IPC path always delivers one fixed image format and supports a single session, so it is an opt-in fast path rather than a replacement for the standard delivery path. See Use the NuRec gRPC API Server and Serve NuRec over gRPC with Multiple Processes.
Per-Request Harmonizer Control: A render request can now turn the Harmonizer on or off per request rather than only per server. Set apply_harmonizer = true on the request along with a valid harmonizer_session_id; false or omitted leaves the request’s color unprocessed. The server manages temporal Harmonizer sessions automatically, caps concurrent sessions with --max-harmonizer-sessions (default 32), and a new history reset clears temporal state without restarting the server. The temporal Harmonizer also decodes only the current frame rather than the whole window. See Use the NuRec gRPC API Server for the session lifecycle and its restrictions.
Ego-Path Protection for Camera Ground Mesh: export-camera-ground-mesh can now protect the drivable surface along the ego path from the mesh filters that would otherwise remove it. Pass the NCore sequence JSON with --dataset to enable it, and tune it with three new flags: --corridor-half-width-m (default 2.5) sets the half-width of the protected corridor around the ego trajectory, --corridor-z-band-m (default: off) limits protection to a height band around the trajectory and is worth setting to 2.0 on stacked geometry such as overpasses, and --corridor-max-edge-length-m (default 6.0) raises the long-edge limit inside the corridor. --corridor-max-edge-length-m must exceed the mesher’s own 2.5 m edge limit, and the command rejects a smaller value rather than silently protecting nothing. Protection only retains triangles the mesher already produced; no geometry is synthesized. Exports that do not pass --dataset are unchanged.
Faster Road Mesh Reconstruction: Road mesh grid reconstruction now runs on the GPU, and the grid topology defaults and the export command’s flags are documented alongside the configuration reference.
Static .ply Props as Edit Assets: Asset edits now accept a static .ply prop as the replacement asset, alongside the asset types already supported. Rigid asset insertion is also staged atomically, so a failed insertion no longer leaves partial metadata behind.
AV Benchmark Workflow Ships Its Own Configuration: The AV Benchmark workflow now carries the training preset it runs, so you can run it without an NVIDIA-internal configuration tree. The spec is workflows/av_benchmark/specs/av_benchmark_7cam.yaml — renamed from specs/ci_7cam.yaml — and its CONFIG and CONFIG_DIR variables default to the checked-in preset at workflows/av_benchmark/configs/. You no longer pass --set CONFIG= and --set CONFIG_DIR= to run the benchmark, and you still pass --set CONFIG= to point at a different preset. The spec’s defaults are now the benchmark’s own budgets, a 20-second clip (DURATION_SEC) and 30000 training samples (TRAIN_SAMPLES), rather than the much shorter continuous-integration budgets it previously carried, so a default run reconstructs the clip instead of smoke-testing it. The spec and its preset ship inside the released run image at those repo-relative paths, so you can run the workflow from the image without a repository checkout.
A Complete AV Benchmark Chain: The workflow now runs the whole chain end to end and can optionally download its own clip, so one invocation can go from a raw PhysicalAI-AV clip to a rendered and evaluated reconstruction. It also publishes object-level metrics, the camera set and the ground mesh, reduces a clip’s metrics to a single published row, renders its publication video at 2160p, and can carry a reference USDZ’s map and ECEF pose into the exported scene package.
Per-Object PSNR: Object-level metrics now report per-object PSNR alongside the existing per-instance crops of tracked actors.
One Render-Timing Schema, Attributed to Its Scene: Render timings are unified into a single metrics file schema. The metrics.yaml written by --metrics-output-dir now files each render timing under the scene that produced it, at metrics.per_sequence.<scene_id>.per_camera for render_time_ms, batch_render_time_ms and batch_render_time_per_camera_ms, and at metrics.per_sequence.<scene_id>.per_lidar for lidar_render_time_ms. Previously all four landed together under metrics.general, so a server holding several scenes pooled their timings into one undifferentiated set. Every timing now carries a metric_metadata block recording timing_method, so you can tell wall-clock numbers from CUDA-event measurements. Metric names and units are unchanged. See Use the NuRec gRPC API Server.
Direct-Mode Render Profiling: Direct-mode rendering now reports CUDA event timings and LiDAR profiling, and backward work is labelled by the loss that owns it.
Stricter Sensor Model Validation: NCore opened its camera, LiDAR, and distortion parameter hierarchies so that you can register model classes NCore does not define. NuRec cannot render such a model, so it now reports that directly when it loads the dataset — Unsupported NCore camera model for this repository: <type>, and the LiDAR and external-distortion equivalents — instead of failing later with an unrelated error. Datasets that use the camera and LiDAR models NCore ships are unaffected. See Prepare Data for Use with NuRec.
Atomic Artifact Publication: Reconstruction artifacts are now published atomically. Each numbered .usdz is written to a temporary file in the artifact directory and then moved into place, and last.usdz is hard-linked from the final numbered artifact instead of being serialized a second time. A reader can no longer observe a half-written artifact, and a failed run leaves the previously published last.usdz intact. Two consequences are worth knowing if you watch or sync the artifact directory: transient files named .<filename>.<hex>.tmp appear there during a write and are removed when it finishes, and last.usdz shares an inode with its numbered artifact rather than consuming separate disk space. Artifact contents are unchanged.
Traffic Cones and Construction Barriers: Traffic cones are now initialized from LiDAR into a dedicated spherical-harmonic layer, and construction-barrier cuboids get a random initialization from upstream labels.
Rendering and Training Performance: Vehicle-light appearance lookups are cached per timestamp and their cache misses are fused and vectorized, instead of being recomputed on every layer-data call. The Slang Gaussian collector gathers each thread block’s parameters from a block-local tile rather than striding across the whole layer, improving memory locality in the forward and backward buffer operations and in the spherical-harmonic and Fourier feature copies. The collector also bounds its timestamp work and caches shutter interpolation, cuboid association is batched with bounds checks, shared rigid motion is prepared explicitly before layer collection, and several loss paths skip work they do not need — unit-weight scaling, the mean reduction for single-value losses, and the identity road-Gaussian scalar epilogue. Arithmetic, precision, tensor layouts and allocations are unchanged, so reconstruction quality is identical.
Published Agent Skills: NuRec ships agent skills in the public tree under skills/: nurec for reconstruction workflows, nurec-onboard for onboarding a raw dataset end to end, physical-ai-av-benchmark for running one Physical AI clip through the complete AV benchmark, and physical-ai-datasets for finding and downloading a Physical AI dataset. They give a coding agent the reference material and example workflows it needs to drive NuRec. physical-ai-av-benchmark is CC-BY-4.0 AND Apache-2.0; the rest are Apache-2.0. See NuRec Agent Skills.
A Dependency-Only Image for Source Builds: The published nurec_dev_deps image now carries only the dependency layers, on an NVIDIA Ubuntu base, rather than extending an internal development image. You build the development container yourself on top of it with deps/docker/Dockerfile-dev.build, passing the dependency image as --build-arg BASE_IMAGE. This keeps development tooling out of the published image, which narrows both the CVE-hardening surface and the licensing surface. Building from source now requires Docker’s Buildx plugin, which Docker’s official install packages include. See Set Up NuRec Software for the full command.
Public Polyscope Visual Debugger: The Polyscope visual debugger is now part of the public tree.
Newer Runtime Dependencies: PyTorch moves to 2.11.0+cu128.nre1 and NCore to 19.8.0, as described under Breaking Changes. The LPIPS calibration weights used by rendering metrics now come from the PyPI lpips package rather than a separately packaged weights archive; the weights are identical, the metric values do not change, and nothing is fetched from the network at run time. The decord wheel moves from 0.6.0+nre3 to 0.6.0+nre4, which adds the LGPL notice for the ffmpeg libraries it bundles and decord’s own Apache-2.0 notice to the wheel. imageio-ffmpeg is pinned at 0.6.0+nre6, PyNvVideoCodec moves to 2.2.3 for its FFmpeg 9.0.1 rebuild, the OpenCV ffmpeg build now decodes AV1, gsplat moves past its LiDAR tiling capacity fix, ppisp moves to 1.3.0, and transformers and urllib3 move to 5.17.0 and 2.8.0. Vendored third-party code is attributed in THIRD_PARTY_NOTICES.md and third_party_licenses/.

Bug Fixes

Ground Mesh Deleted Road Under the Ego Path: Fixed the camera ground mesh removing the drivable surface the ego vehicle drove over. A sparse band of points spanning the road width split the mesh into separate components, and post-processing then discarded the smaller component outright rather than filling the gap.
Spherical-Harmonic Coefficients Were Read Out of Order: Fixed f_rest_* PLY properties being read in lexicographic rather than coefficient order, which mis-assigned higher-order spherical-harmonic coefficients when loading a PLY.
LiDAR and Camera Renders Share One Execution Mode: Fixed a render failure when a LiDAR render preceded a camera render on the same scene with static-Gaussian caching enabled. The two sensor paths used different PyTorch execution modes, so the camera render then failed while updating the cache the LiDAR render had populated. Both sensors now render under the same no-grad context. Rendered values are unchanged.
Empty Tracks Crashed the Distance Mask: Fixed a CUDA failure when a track contained no instances.
Instance Segmentation Masks Were Misread: Fixed byte padding when reading instance segmentation masks.
Cameras Without Depth Broke Point Cloud Initialization: Camera-based point cloud initialization now skips cameras that have no depth rather than failing.
Cuboid Labels Were Matched to the Wrong Frames: Cuboid labels are now matched to camera frames per track.
Ground Mesh Initialization Was Not Repeatable: Fixed ground mesh initialization producing different results across runs with the same inputs.
Deform Tables Did Not Grow With Inserted Tracks: Fixed the deformation tables not growing when a track is inserted, and added a topology preflight that rejects an unsafe table deformation rather than corrupting it.
Failed Asset Insertions Left Metadata Behind: A failed asset insertion now rolls back its metadata.
Checkpoint RNG Restore: Fixed the restored CPU random number generator being shifted by loader creation, and restored the default random streams on checkpoint load. The RNG invariants are now documented.
CUDA Compatibility Libraries Lost Their SONAME Symlinks: Fixed the packaged CUDA compatibility libraries dropping their SONAME symlinks.
nurec_tools Masked Import Failures: nurec_tools now fails when an enabled tool cannot be imported, rather than continuing without it.

Known Issues

``dynamic_objects`` replaces the actor set for a request rather than overriding the actors it lists: A non-empty dynamic_objects list is the complete actor set for that render. The server draws the tracks you list and no others, so every recorded actor you leave out is absent from the frame, and the response still carries transport status OK. A client that sends only the actor it moved loses every other actor with no error. Send every actor whose trajectory overlaps the frame window on every request, and substitute your own pose_pair only for the actors you drive. An empty list is the separate instruction to draw all recorded actors at their captured poses. This release has no override-only mode. See gRPC API Guide.
``get_dynamic_objects`` returns an out-of-order first timestamp for actors that appear before the scene starts: When an actor’s first recorded pose predates the scene start, its negative microsecond offset wraps in the unsigned timestamp_us field and is returned as a value near 2**64, leaving the trajectory out of time order. One Physical AI scene showed this for 6 of its 30 actors. Detect it by testing timestamp_us > 2**63 or by checking that timestamps strictly increase; timestamp_us - 2**64 recovers the original offset, so the affected entry can be converted and re-sorted rather than discarded. Rendering is unaffected, because render_camera and render_lidar place actors from the DynamicObject.pose_pair supplied for every actor the request lists. An actor the request omits is not drawn at all. A fix is targeted for 26.11. See gRPC API Guide.
``render_camera`` accepts a nonfinite sensor pose and returns a distorted image with status OK: Setting any sensor_pose component to NaN or an infinity produces a badly smeared render reported at transport status OK, so the status code alone does not indicate a usable image. Validate that every pose component is finite before sending the request. Server state is unaffected: a subsequent valid request returns the expected image with no restart. A fix that rejects nonfinite pose values with INVALID_ARGUMENT is targeted for 26.11. See gRPC API Guide.
General Linux aarch64 is not a supported platform: The supported user platform for NuRec remains Linux x86_64. The published source release pins x86_64 dependencies only, and Grace-Blackwell enablement reaches you only through the -arm64 or -multiarch container tags. Those image builds do not run on release-branch pipelines by default, so an -arm64 or -multiarch tag for a given 26.10 build may not exist unless it was triggered manually. See Hardware Setup and Requirements.

Past Releases#

Version 26.09 — September 2026

This release covers everything that landed on the 26.09 release branch since 26.08.

Upgrade From 26.08

Work through these before upgrading. Each one is detailed under Breaking Changes.

Repoint configuration paths from configs/ to internal/configs/.
Pass --tracks-timestamp-ray-stride 1 to keep 26.08 inference behavior on non-Ampere GPUs.
Rename system.test.lidar.save_filtered_pc to system.test.lidar.floating_point_filter, and its filter_threshold key to threshold.
If you set dataset.use_real_lidar_rays as a plain boolean in a multi-LiDAR rig, confirm the per-sensor form.
If you pinned the run_grpc or run_grpc_mps images, move to the standard run image and invoke serve-grpc yourself.
If you relied on the CUDA toolkit inside the run container, switch to the dev image or a prebuilt binary.
If you drive NRM training through the public nre/nrm:run entry point, that path is inference-only now.
If you relied on the default temporal Harmonizer checkpoint, pin --harmonizer-temporal-url and --harmonizer-temporal-model-filename explicitly.
If you send DynamicObject entries without pose_pair under --enable-editing-actors, add the field.

Reconstructions trained on 26.08 are not reproduced exactly by 26.09, because checkpoint capture now reorders Gaussian rows by default and the inference ray stride changes on non-Ampere GPUs. Keep the 26.08 container to reproduce a 26.08 run.

Breaking Changes

Configuration Tree Moved to ``internal/configs``: The shipped preset tree moves from configs/ to internal/configs/, and the default configuration directory changes from ./configs to ./internal/configs. Despite the directory name, this is the customer-facing preset tree — the top-level configs/ directory no longer exists. Preset names inside the tree are unchanged, so apps/prod/Hyperion-8.1/car2sim_6cam.yaml still resolves once the configuration directory points at the new root. Update any --config-dir ./configs argument, any hard-coded configs/... path, and any load_json: reference such as configs/sensor/hesai_pandar128.json, which is now internal/configs/sensor/hesai_pandar128.json. See Customize NuRec Configuration.
Inference Ray Stride Defaults to 16 Everywhere: --tracks-timestamp-ray-stride now defaults to 16 on every GPU. In 26.08 the flag was unset by default and resolved to 16 only on Ampere (compute capability 8.0, 8.6, and 8.7) and to 1 everywhere else. Renders on non-Ampere GPUs are therefore no longer bit-identical to 26.08 output. Pass --tracks-timestamp-ray-stride 1 to restore full estimation and its cost. Affects render and serve-grpc. See Use the NuRec Render Command.
LiDAR Floating-Point Filter Configuration Renamed: The system.test.lidar.save_filtered_pc block is renamed to system.test.lidar.floating_point_filter, and its filter_threshold key to threshold. No configuration upgrade step rewrites the old name, so an older configuration fails to load until you rename it. The block also gains neighbor_source (rangeview or angle, default rangeview), elevation_resolution_deg, and azimuth_max_gap_deg.
``dataset.use_real_lidar_rays`` Is Now Per-Sensor: The field changes from a plain boolean to a per-sensor value. A single value still broadcasts to every active LiDAR, so a scalar configuration keeps working, but you can now pass a mapping keyed by lidar_id. If you pass a mapping, list every active lidar_id.
NRM Public Entry Point Is Inference-Only: nre/nrm:run always executes trainer.predict(). The Hydra mode=train, mode=val, mode=test, and mode=trainval paths, which in 26.08 dispatched to trainer.fit(), trainer.validate(), and trainer.test(), are gone from the public tree. The probe_cluster_env diagnostic binary is removed from the public NRM package.
gRPC-Only Container Images Discontinued: The run_grpc and run_grpc_mps image variants are no longer built or published. Use the standard run image and invoke serve-grpc explicitly. The MPS variant existed only to start the NVIDIA MPS control daemon before the server; if you used it for multi-process serving, start MPS yourself.
Run Container No Longer Ships a CUDA Toolkit: The run image base moves from nvcr.io/nvidia/cuda:12.8.0-devel-ubuntu24.04 to plain ubuntu:24.04. nvcc, cuobjdump, and the other toolkit components that came from the base layer are no longer present in the production container. Use the dev image or a prebuilt binary if you depended on them. Forward-compatibility driver libraries are still layered in at /usr/local/cuda/compat.
``nvdiffrast`` Removed: The nvdiffrast dependency is dropped after its last consumer was replaced with an in-tree cubemap sampler. Code importing nvdiffrast from the NRE environment breaks.
Temporal Harmonizer Default Checkpoint Changed: The defaults for --harmonizer-temporal-url and --harmonizer-temporal-model-filename move from the NGC harmonizer_temporal.pt artifact to a Hugging Face diffusion_harmonizer.pkl checkpoint. A deployment that relied on the implicit default fetches a different artifact on first use. Pin both flags to keep the previous behavior. See Use Harmonizer for Post-Processing.
Pose Is Required on Edited Dynamic Objects: With --enable-editing-actors, every DynamicObject in dynamic_objects must carry pose_pair. An entry sent without one — for example, an entry carrying only aspect_state — now fails with INVALID_ARGUMENT rather than silently re-posing the actor to the origin. See Use the NuRec gRPC API Server.
``CUDA_SYNC_DEBUG`` No Longer Honored: Setting CUDA_SYNC_DEBUG=1 no longer enables torch.cuda.set_sync_debug_mode("warn") in nre run main. Use Nsight Systems for synchronization debugging.
Removed Configuration Presets: dataset/ngp.yaml, dataset/samplers/timestamp_lidar_crop.yaml, and experimental/asset_harvesting/3dgut_lidar_base.yaml are deleted rather than relocated.

Deprecations

No new RPC, protobuf, or command-line deprecations were added in this release. The deprecations announced in 26.08 — the render_rgb and batch_render_rgb RPCs, and the --enable-difix and --difix-* flags — are unchanged and still functional.

Core Improvements

Model-Free Unstructured LiDAR: A new opt-in path reconstructs and renders measured LiDAR returns directly, without requiring a spinning-sensor model. Select it with dataset.lidar_ray_mode: unstructured (default structured) paired with model.renderer.lidar_unstructured: true; the configuration validator enforces that the two agree per sensor. Ray-drop supervision is selected through dataset.lidar_unstructured_raydrop_virtual_rays, which accepts off (default), model_elements, and aggregate_lattice, and dataset.lidar_unstructured_raydrop_use_stored_no_returns consumes stored no-return rays from an NCore V4 dataset. New culling knobs under model.renderer.culling cover the unstructured path, including cull_dead_pairs_lidar_unstructured (default true), box_method_lidar_unstructured (default ut), and pbf_near_range_lidar_unstructured (default 8.0). Two reference presets ship: apps/prod/Hyperion-8.1/car2sim_6cam_unstructured_lidar.yaml and apps/AV/NV/3dgut_dynamic_unstructured_lidar.yaml. Read the Known Issues entries before enabling it. See Customize NuRec Configuration.
SimReady Asset Edits with Per-Frame Aspect Control: SimReady assets such as vehicle lights and props can be baked into a USDZ artifact and then switched on a per-frame basis at render time. The new compile-asset-edits command bakes an authoring YAML into the artifact — --artifact-path and --asset-edits-yaml are required, and --output defaults to <input>.edits_baked.usdz. At serve time, --enable-editing-actors installs the embedded manifest, and clients drive it through the new AspectState message on DynamicObject, carrying aspects and a nested AspectGain. The server is stateless: resend the full visible set on every frame. get_server_config advertises asset_edits.aspect_state as stateless-v1. Unlike the edit_assets RPC, this works under multi-process serving. Offline, render --asset-edits-schedule replays a schedule against a baked artifact. See Use the NuRec gRPC API Server.
Joint Rig-Trajectory and Camera-Extrinsics Calibration: A new rig-calib calibration mode jointly optimizes a B-spline correction to the rig trajectory and per-camera static extrinsic residuals, as an alternative to per-frame free-pose-calib. Select it with model.calib.name: rig-calib or the model/calib/rig_calib.yaml preset, which starts at global step 250 and bounds the trajectory correction to 0.25 m and 3 degrees, and the camera extrinsics to 0.10 m and 3 degrees.
Server-Side Image-Format Allow-List: serve-grpc --allowed-image-formats restricts which camera response formats the server will produce, accepting PNG, JPEG, and RGB_UINT8_PLANAR, with RGB as an alias for the planar form. A disallowed format is rejected with INVALID_ARGUMENT before the scene loads or renders, rather than after. The effective list is reported through get_server_config as allowed_image_formats.
Angle-Based LiDAR Floating-Point Filter: The test-time distance-discontinuity filter gains a sensor-agnostic neighbor source that works from ray directions instead of a 2D range-view grid, which is what makes it usable on model-free LiDAR. Select it with neighbor_source: angle and tune it with elevation_resolution_deg and azimuth_max_gap_deg. The protobuf gains a LidarFloatingFilterSource enum with LIDAR_FLOATING_FILTER_SOURCE_RANGEVIEW and LIDAR_FLOATING_FILTER_SOURCE_ANGLE, plus matching LidarRenderFilter fields. The bundled client exposes --lidar-distance-filter-neighbor-source, --lidar-distance-filter-elevation-resolution-deg, and --lidar-distance-filter-azimuth-max-gap-deg.
Morton Sort at Checkpoint Capture: Gaussian rows are reordered into Morton (Z-order) sequence before each checkpoint write, improving spatial locality in the saved model. This is on by default — checkpoint.morton_sort.enabled defaults to true, with sort_track_layers true and voxel_size 2.0. It changes row order in checkpoints and non-compact artifacts; disable it with checkpoint.morton_sort.enabled=false if a downstream tool depends on the previous ordering.
Ground-Mesh Extension to Cuboid Tracks: The road ground mesh can be extended under cuboid track positions where LiDAR ground returns are sparse. It is off by default. Enable it on export-ground-mesh with --extend-to-cuboids, tuned by --cuboids-base-margin (default 0.5), --cuboids-exclude-points-radius (default 1.0), --cuboids-exclude-points-knns (default 1), and --cuboid-point-merge-cell-size (default 0.5). The same settings exist in configuration under checkpoint.artifact.mesh.ground.extend_to_cuboids.
New ``nre_tools`` Multi-Tool Command: Auxiliary tooling is consolidated behind a single nre_tools entry point with ncore-aux-data, pai-convert, mask-annotator, and asset-harvester subcommands. ncore-aux-data moves here from its former standalone target. Group-level options are --ffmpeg-exe, which also reads the USER_FFMPEG_EXE environment variable, and --allow-ffmpeg-download to opt in to fetching a full GPL FFmpeg binary.
Parallel Auxiliary Data Generation: ncore-aux-data gains an explicit execution-mode selection. --parallel-mode processes across GPUs and requires --segmentation-backend=mask2former and --zarr-store-type=itar; --workers-per-gpu (default 1) sets how many workers share each CUDA device. --serial-mode is the default and is mutually exclusive with --parallel-mode. See Generate Auxiliary Data.
AV Benchmark Workflow Runner: A standalone runner executes the AV Benchmark workflow from a spec file, taking --spec and --work-dir, with --clip-root to override the raw clip root and a repeatable --set NAME=VALUE to override spec variables.
Checkpointed Temporal Harmonizer: The temporal Harmonizer can load .pkl research checkpoints in addition to TorchScript artifacts, which requires a Cosmos Predict2 base model and tokenizer. Three new settings supply them: --harmonizer-temporal-cosmos-base-model-url, --harmonizer-temporal-cosmos-tokenizer-url, and --harmonizer-temporal-cosmos-cache-dir. See Use Harmonizer for Post-Processing.
Readiness Now Waits for Harmonizer Load: The gRPC server binds its port before the Harmonizer finishes loading, so the health service reports NOT_SERVING until the load completes or fails, and only then SERVING. The bundled client’s --wait-server polls grpc.health.v1.Health/Check rather than treating transport readiness as readiness, falling back to the transport-only check against a server that does not implement health.
Pose Calibration with Measured LiDAR Rays: Structured LiDAR reconstruction with dataset.use_real_lidar_rays: true now supports free-pose-calib and rig-calib, with measured world rays re-expressed under the calibrated pose.
Frame-Name Padding for Benchmark Ground Truth: export-ncore-benchmark-gt gains --frame-name-width (default 0) to zero-pad camera frame filenames. Set it to 20 to match the render timestamp padding so eval-rendering-metrics pairs frames correctly.
Physical AI SQA Presets: Three presets cover SQA runs on PAI-converted sequences: apps/prod/PAI/sqa_1cam.yaml, apps/prod/PAI/sqa_lidar_1cam.yaml, and apps/prod/PAI/sqa_lidar_7cam.yaml. See Use Physical AI Data.
Retuned LiDAR Raydrop Threshold Option: A new lidar_return_filter/raydrop_threshold_65e-2 option group sets system.test.lidar.raydrop_threshold to 0.65. At 0.8 the threshold saturates precision on alpha-premultiplied raydrop output. The base schema default remains 0.5.
LiDAR Evaluation Opacity Threshold: system.test.lidar.opacity_threshold (default 0.0) is added to the LiDAR evaluation block.
Faster Track Calibration: Unicycle track-calibration kernels were reworked. On a 261-track clip, the pose and backward pass went from 2.74 ms to 0.40 ms, and a training-step probe from 5.21 ms to 0.82 ms.
Fused Multi-GPU Gaussian Parameter Gather: Multi-GPU training uses a fused field-major all-gather and reduce-scatter for compatible Gaussian layers, cutting per-field collective overhead. The path is numerically validated against the previous independent gather.
Losses Delegate to GSplat: Eight duplicated loss functions, including bce_clipped, weights_reg, and depth_inverse_mse, now call the GSplat implementations, and the local CUDA and Slang loss code is removed. Behavior is pinned by parity tests and no configuration changes.
Hermetic CUDA Build Toolchain: Builds use a pinned hermetic CUDA 12.8.0 redistributable rather than a host CUDA installation, and CUPTI for profiling comes from the same redistributable set. A host CUDA toolkit is no longer a developer prerequisite.
Asset Harvester 1.2.4: The bundled Asset Harvester wheel moves from 1.2.3 to 1.2.4, fixing dtype-aware opacity bounds during inverse sigmoid conversion so exported PLY files no longer pick up non-finite values under reduced precision. See Use Asset Harvester Output in Reconstructions.
``decord`` Built Against the Shared FFmpeg: The decord dependency moves from the stock 0.6.0 wheel to an NRE-built 0.6.0+nre3 wheel linking the same LGPL FFmpeg 9.0.1 already used by the OpenCV and imageio wheels, replacing the FFmpeg 4.1.6 the stock wheel bundled.
New Runtime Dependencies: The Physical AI conversion and Harmonizer paths add DracoPy 2.0.0 or newer, PyNvVideoCodec, remotezip 0.12.0 or newer, and cosmos-predict2 1.0.9+nre1. NCore stays at 19.5.1 and CPython at 3.13.15, unchanged from 26.08.

Bug Fixes

CUDA Forward-Compatibility Libraries Broke GPU Calls on Newer Drivers: The compat library archive flattened its SONAME symlinks into copies, which made libnvidia-container mount the compat libcuda.so.1 over the host driver’s own. On a host whose driver was newer than the bundled compat libraries, every GPU call failed with CUDA error 803, cudaErrorSystemDriverMismatch. The archive now preserves the symlinks, and a regression test asserts it. The compat layer also shrinks from roughly 544 MB to roughly 197 MB.
Ghosting at Track-Split Boundaries: Fixed synthetic visible-track splits rendering two sibling tracks at once at an internal boundary, which produced a visible double-render. Split intervals are now right-biased and half-open, and short leading or trailing invisible segments merge into the nearest visible child. Affects render, render-grpc, and gRPC playback on split-track artifacts.
Stored No-Return Rays Leaked Into Depth and Intensity: No-return payloads are excluded from depth, intensity, and point-cloud consumers while remaining available for ray-drop supervision.
Asset-Edit Failures Were Silent: Unknown aspect strings, duplicate aspect entries, manifest and checkpoint mismatches, and edit-baked artifacts served without the runtime enabled now fail loudly instead of rendering the wrong geometry.
Pose Calibration Silently Did Nothing on Unstructured LiDAR: The unstructured renderer ignores ray geometry from rendering_data.rays because it uses a prebuilt tiling, so enabling pose calibration there trained zero parameters. That combination is now blocked rather than silently accepted. The structured measured-ray path keeps the capability.
Manually Launched Collectives Were Double-Reduced: Manually launched multi-GPU collectives in the fused gather path are isolated from DDP, which previously reduced them a second time.

Known Issues

Unstructured LiDAR requires a training batch size of 1: datamodule.train_batch_size must be 1 when any sensor uses lidar_ray_mode: unstructured, because variable-size per-frame tilings cannot be collated.
Unstructured LiDAR cannot use pose calibration with measured rays: dataset.use_real_lidar_rays: true combined with unstructured mode cannot use free-pose-calib or rig-calib. The renderer does not accept world-ray input on the unstructured frame context. The structured path is unaffected.
Unstructured LiDAR rejects the overlap tile-masking strategy: active_tile_mask.strategy=valid_camera_lidar_overlap needs a structured row-and-column grid. Use camera_invalid_only or disable tile masking.
Unstructured LiDAR needs the angle neighbor source for the floating-point filter: The default neighbor_source: rangeview requires a 2D range-view grid that the unstructured path does not have, so the combination fails validation. Set neighbor_source: angle, or leave the filter disabled as the reference preset does.
Unstructured LiDAR ray-drop classes are imbalanced: Virtual ray-drop negatives are appended after return subsampling, which produces a drop-to-return ratio of roughly 30:1 to 80:1, against the natural grid ratio on the structured path.
Asset edits approximate LiDAR intensity and exclude the ``edit_assets`` RPC: Baked clusters zero the LiDAR intensity channel. The edit_assets RPC is refused on an edit-baked scene, because baking invalidates the row indices that RPC depends on.
Harmonizer does not run under distributed (multi-GPU) training: Unchanged from 26.08. Loading the Harmonizer model raises when the distributed world size is greater than 1. Run Harmonizer training with a world size of 1, or apply Harmonizer at inference through the gRPC server, which never initializes a process group. See Use Harmonizer for Post-Processing.
Temporal Harmonizer restrictions: Unchanged from 26.08. The temporal Harmonizer is inference-only, and cannot be combined with the stateless --enable-harmonizer, with multi-process serving, or with the batch render RPCs.
Asset editing is single-process only: Unchanged from 26.08. Under multi-process serving, edit_assets and restore_model_parameters return UNIMPLEMENTED. Per-request dynamic-actor re-posing through --enable-editing-actors, including the new per-frame aspect control, works in both modes.
gRPC asset replacement rendering: Carried over from 26.06 and 26.08. In some gRPC asset-edit scenarios an inserted asset may not visually replace the target scene vehicle.
The reported ``grpc_api_version`` is unchanged at ``0.0.3``: This release adds optional protobuf fields — AspectState, DynamicObject.aspect_state, and the LidarRenderFilter angle-filter fields — without bumping the reported API version. The additions are wire-compatible, so an existing client is unaffected, but a client cannot use the version string to detect whether they are available. Use the get_server_config discovery keys instead.
General Linux aarch64 is not a supported platform: Unchanged from 26.08. The supported user platform for NuRec remains Linux x86_64, and Grace-Blackwell enablement reaches you only through the -arm64 or -multiarch container tags. Those image builds do not run on release-branch pipelines by default, so an -arm64 or -multiarch tag for a given 26.09 build may not exist unless it was triggered manually. See Hardware Setup and Requirements.

Version 26.08 — September 2026

This release covers everything that landed since 26.06, including the interim 26.07 development line.

Upgrade From 26.06

Work through these before upgrading. Each one is detailed under Breaking Changes.

Rebuild any environment that runs against NRE outside the container against Python 3.13.
If you pass car2sim.yaml, switch to car2sim_4cam.yaml or accept a six-camera rig.
If you passed --renderer nrend, replace it with --renderer gsplat, and drop --no-enable-nrend.
Rename difix configuration packages, option groups, and sqa_difix_* presets to their harmonizer equivalents.
Replace model/tracks_calib: unicycle with elevation_aware_unicycle or direct.
On Ampere GPUs, pass --tracks-timestamp-ray-stride 1 to keep 26.06 inference behavior.

Reconstructions trained on 26.06 are not reproduced exactly by any 26.08 preset, because the production presets also pick up new optimizer, tile-masking, and track-splitting defaults. Keep the 26.06 container to reproduce a 26.06 run.

Breaking Changes

Python 3.13: The container and the custom wheels move from CPython 3.11.14 to 3.13.15. Code that runs against NRE outside the shipped container, including gRPC clients built from the NuRec protos, must target Python 3.13. See Software Prerequisites.
Six-Camera Car2Sim Is the Default: car2sim.yaml for Hyperion 8.1 now resolves to the six-camera preset instead of the previous four-camera rig. An unchanged command therefore trains a six-camera reconstruction, which raises VRAM use and training time and produces metrics that are not directly comparable to your 26.06 runs. Use the new car2sim_4cam.yaml to keep the four-camera rig, noting that it pins the rig only — both presets also pick up the 26.08 option-group changes, including the SelectiveAdam Gaussian optimizer, active tile masking, and five-second pedestrian track splitting. car2sim_6cam_lidar is replaced by car2sim_lidar, and car2sim_6cam_nrm is removed. See Customize NuRec Configuration.
NRend Renderer Removed: NRE now has a single GSplat-based rendering path. The gRPC and render --renderer flag accepts only default and gsplat; the nrend choice and the deprecated --enable-nrend / --no-enable-nrend flags are gone. The *_nrend configuration presets (car2sim_nrend, car2sim_6cam_nrend, car2sim_lidarfree_nrend, sqa_default_nrend) and the configs/apps/prod/options/nrend option group are removed, as is the artifact.nrend export block. Replace --renderer nrend with --renderer gsplat and drop --no-enable-nrend from existing commands. See Use the NuRec gRPC API Server and Use the NuRec Render Command.
Difix Configuration Packages Removed: The configs/difix package and the configs/apps/prod/options/difix option group are replaced by configs/harmonizer and configs/apps/prod/options/harmonizer. The sqa_difix_distill, sqa_difix_inference, and sqa_difix_distill_and_inference presets are renamed to their sqa_harmonizer_* equivalents. A configuration upgrade step (26.7.8 to 26.7.9) rewrites difix keys to harmonizer in older configs, so an older config still loads; update the keys anyway. The --enable-difix and --difix-* command-line flags are separate, are still accepted, and still emit deprecation warnings. See Use Harmonizer for Post-Processing.
Unicycle Track Calibration Replaced: The model/tracks_calib: unicycle preset and the unicycle-tracks-calib module are removed in favor of elevation_aware_unicycle (elevation-aware-unicycle-tracks-calib). No configuration upgrade rewrites the old name, and the replacement is not behavior-preserving — it starts calibration at step 500 instead of immediately and adds pitch clamping and short-gap fusion. Select elevation_aware_unicycle or direct explicitly.
Harmonizer Fails Fast Under Distributed Training: Harmonizer now raises at model load when the distributed world size is greater than 1, instead of failing partway through validation. Multi-GPU Harmonizer training runs that previously reached validation now fail at trainer setup. See the Known Issues entry for the workaround.
Asset Harvester Lifting Overrides Removed: The tokengs_lifting.use_ttt and tokengs_lifting.bbox_size overrides are no longer exposed. Remove them from existing Asset Harvester invocations.
Obfuscated Container Images Discontinued: The _obfuscated_run, _obfuscated_tools, and _obfuscated_nrm_run image variants are no longer built or published. Use the standard run, tools, and nrm_run images.

Deprecations

RGB Render RPCs Deprecated: render_rgb and batch_render_rgb are marked deprecated in the protobuf service in favor of render_camera and batch_render_camera. Both still work in this release. To match render_rgb exactly, call render_camera with render_products=[CAMERA_RENDER_PRODUCT_COLOR]. See Use the NuRec gRPC API Server.

Core Improvements

CameraRender gRPC API: New render_camera and batch_render_camera RPCs replace the RGB-only render calls. A single request selects one or more render products through render_products — CAMERA_RENDER_PRODUCT_COLOR, CAMERA_RENDER_PRODUCT_DISTANCE_COLORIZED, and CAMERA_RENDER_PRODUCT_SEMANTICS_COLORIZED — and all requested products share one render pass. Responses carry one CameraRenderOutput per product, in request order, with per-product metadata such as the semantic class mapping and the distance colormap bound. Requests can also draw cuboid wireframes on every product through overlay_bounding_boxes. The reported grpc_api_version moves from 0.0.1 to 0.0.3; the change is additive, so clients that negotiate on major.minor are unaffected.
Multi-Process gRPC Serving: serve-grpc --multiproc-workers N runs the server as an owner process holding one read-only copy of the weights, shared to N workers over CUDA IPC behind a front proxy. New flags cover startup and admission control: --multiproc-bringup-concurrency, --multiproc-max-in-flight, --multiproc-admission-timeout-s, --multiproc-require-scene-cache, and --require-mps. The pool is validated for the gsplat renderer only, requires externally managed NVIDIA MPS for throughput scaling, and refuses asset editing and temporal-Harmonizer sessions. See Serve NuRec with Multiple Worker Processes.
Temporal Harmonizer for gRPC Inference: serve-grpc --enable-harmonizer-temporal enables an autoregressive Harmonizer that conditions each frame on up to four previously enhanced frames. Clients open a session with the new create_harmonizer_session RPC, pass the session ID on each render, and close it with end_harmonizer_session; --max-harmonizer-sessions (default 32) bounds concurrent sessions. The bundled client exposes --temporal-harmonizer-session. The temporal model is inference-only and mutually exclusive with the stateless --enable-harmonizer. See Use Harmonizer for Post-Processing.
Artifact-Aware Backend Cache Keys: NRE records the artifact SHA256 in backend cache keys, so newly downloaded bytes cannot reuse a stale loaded backend when different content is published at the same artifact URL. On-demand scene registration through the x-nre-scene-url and x-nre-scene-id metadata headers, which was already available on the single-process server, is now supported by the multi-process server as well. See Use the NuRec gRPC API Server.
Scene Cache Introspection and Limits: The new get_loaded_scenes RPC returns a point-in-time snapshot of cached scene instances, with per-scene loaded and reusable instance counts plus the global cache capacity. --max-backends-per-scene caps how many cached backends a single scene may hold; requests that reach the limit wait for and reuse a checked-in backend instead of building another.
Compact USDZ Artifacts: Optional Gaussian tensor compression writes a smaller .compact.usdz artifact. Enable it with artifact.compression.enabled (default: disabled, level 9, opacity threshold 0.005, with an exclude list). The artifact reader detects and loads compact artifacts automatically, and uncompressed artifacts are unchanged.
Inference Ray-Stride Tuning: The new --tracks-timestamp-ray-stride flag on render and serve-grpc subsamples the per-track rolling-shutter timestamp-estimation ray grid at inference time. Left unset it resolves to 16 on Ampere GPUs (compute capability 8.0, 8.6, and 8.7), where that kernel dominates a 4K frame, and to 1 everywhere else. Because the resolved timestamps differ slightly from stride 1, renders on an Ampere GPU are not bit-identical to 26.06 output; pass --tracks-timestamp-ray-stride 1 to restore the previous behavior and cost. See Use the NuRec Render Command.
Selective Tile Rendering: A new model.renderer.active_tile_mask option skips rendering tiles that are entirely invalid, which reduces training and inference time. It is off in the base schema, and several Hyperion 8.1 presets now select it. Masking changes what is supervised and optimized, not only what is rendered, so read the strategy table before enabling it on a custom configuration. See Customize NuRec Configuration.
Parallel-Batch GSplat Rasterization: A new model.renderer.renderer_config option parallelizes both the forward and the backward rasterization pass across the training batch, reducing per-step time. It is now the default for 3DGUT configurations and requires the 3DGUT path. See Customize NuRec Configuration.
Component-Only Training: A new component_only configuration overlay trains a subset of model layers and leaves the rest frozen. Six presets ship under configs/component_only, covering background-only, deformables-only, and combined variants with optional calibration and post-processing.
Track Calibration Options: Direct track calibration can now operate in local coordinate space through delta_frame: local, with world preserved for older checkpoints. New reusable presets include direct_lr1e-4 and elevation_aware_unicycle, exposed for Hyperion 8.1 as the dynamic_rigids_track_calibration option group. The default six-camera preset selects direct.
Pedestrian Visible Track Splitting: A new visible_track_split option group splits long pedestrian tracks by visible duration. The pedestrians_5s preset caps visible duration at 5 seconds for pedestrian and person classes and is selected by the production Hyperion 8.1 presets; disabled turns it off.
Road-Quality Metrics: eval-rendering-metrics gains four road sub-metrics selectable through --metrics: ref (road edge fidelity), rlcf (road local contrast fidelity), lm (lane-marking IoU), and rmtf (road multi-scale texture fidelity). Pass per-frame road masks with the new --road-masks-dir flag.
Object-Level Occlusion Estimation: Object-level rendering metrics now compute per-object occlusion ratios, reported as occlusion_gt and occlusion_ren. The new --occlusion-filter-threshold flag drops heavily occluded objects from the aggregate and reports occlusion_filtered.
NCore V4 Dataset Support: Object-level rendering metrics accept an NCore V4 dataset through the new --dataset-path flag as an alternative to --shard-pattern.
Ground-Mesh Export and Evaluation: A new export-camera-ground-mesh command exports a camera-derived ground mesh from four flags: --input, --output, --road-class-id (repeatable, default 0), and --postprocess/--no-postprocess. eval-ground-mesh adds cuboid-coverage and point-cloud hull-area KPIs behind the new --cuboid-tracks-path, --point-cloud-path, --point-cloud-margin, --point-cloud-max-range, and --hull-grid-resolution flags, and moves its diagnostic output into a diagnostics/ subdirectory so metrics files stay at the output root.
Point-Cloud Export Options: export-point-cloud adds --include-dynamic-points to keep points flagged dynamic, and --coordinate-system to choose between the scene-centered nre frame (default) and the world frame.
Heterogeneous Multi-LiDAR Reconstruction: Structured multi-LiDAR reconstruction supports per-sensor nominal model overrides keyed by lidar_id, so rigs that mix LiDAR types can be reconstructed together.
NRM Improvements: NRM resolves its PLY initialization path automatically from the NCore dataset layout when no explicit path is set, consumes NCore JSON paths directly, and gains a keep_movable_gaussians option (default: disabled) to retain MOVABLE Gaussians in LiDAR PLY export.
Per-Class Binary Mask Export: The NCore diagnostic tool adds --per-class-binary-masks to export one binary mask per requested semantic class.
Coverage Frame Sampler: A new dataset/samplers: coverage_image_crop option selects a coverage-based frame sampler, which can be combined with the existing hold-out split to validate on frames the model never trained on.
Asset Harvester Output Layout Documented: The Asset Harvester output contract is now written down rather than inferred: metadata.yaml plus one <label_class>/<track_id>/ directory per asset, each containing gaussians.ply and 3d_lifted.mp4, with assets.<track_id>.ply_file in metadata.yaml naming the PLY path. The layout itself is unchanged from 26.06. See Use Asset Harvester Output in Reconstructions.
gRPC Client Robustness: The bundled render-grpc client adds --wait-server to block until the server is reachable instead of relying on a fixed delay, --max-concurrent-renders to bound its own fan-out against an admission-limited server, and --repeat-count. It also gains the camera-product flags --output-type, --overlay-bboxes, --bbox-color, and --colorization-max-distance.
GSplat Kernel Migration: Fused SSIM, road Gaussian, deformation-smoothness, semantic cross-entropy, and grouped BCE losses now run through GSplat and CUDA dispatch kernels, and the MCMC strategy uses the GSplat stateless owner API. Gaussian topology mutation schedules are exposed, and the CUDA cache purge during mutation is configurable.
Distributed Training Scalability: Multi-GPU synchronization overhead is reduced. Gaussian count metadata is coalesced into a single all-gather instead of one per layer, backward gradient reduce-scatters are fused into one call, visibility index computation reuses the fused gather counts rather than issuing separate per-layer collectives, and pre-backward CUDA synchronization is avoided when computing training PSNR.
Newer Runtime Dependencies: NCore moves from 19.1.1 to 19.5.1 (19.5.4 internal), the bundled FFmpeg in the OpenCV and imageio wheels moves from 8.1.1 to 9.0.1, PyTorch Lightning moves from 2.4.0 to 2.6.5, and Transformers moves from 4.48.3 to 5.13.1. The pycuda and pytorch3d dependencies are dropped. System cuDNN is removed from the dev and run base images and is now supplied through the PyTorch wheels.
GB300 (Blackwell Ultra) Runtime Compatibility: NRE adds runtime support for GB300 Grace-Blackwell systems. Because CUDA 12.8 cannot emit SM 10.3 code, the custom wheels ship SM 10.0 native kernels plus embedded compute_100 PTX for forward compatibility, and an LD_PRELOAD shim remaps the reported SM 10.3 capability to SM 10.0 for PyTorch, Triton, and NVRTC. The same shim covers DGX Spark and GB10 (SM 12.1 to SM 12.0). GB300-specific runtime fixes align DAV3 LayerNorm numerics with the reference implementation. This is Grace-Blackwell enablement on aarch64, not general Linux aarch64 support — see the platform note under Known Issues.

Bug Fixes

Multi-GPU SelectiveAdam Correctness: Fixed a multi-GPU training bug where an owner rank skipped the optimizer update for Gaussians that were visible only on a different rank, even though the owner received a nonzero reduced gradient for them. Visibility is now unioned across ranks before the optimizer step. This affected model quality, not only training speed.
LiDAR RGB Projection: Fixed camera-valid LiDAR RGB projection in NCore data loading.
LiDAR Metrics: Corrected LiDAR metric computation, fixed sensor routing so metrics are attributed to the right LiDAR, and fixed the NRM initialization override used by LiDAR metrics.
LiDAR Rendering Origin: Fixed render-grpc rendering LiDAR at the rig origin instead of the sensor pose.
Cuboid Track Poses Under TF32: Fixed frame conversion corrupting cuboid track poses when TF32 is enabled.
Rigid Track Clamping: Per-track cadence metadata is now precomputed for rigid track clamping, reducing repeated recomputation.
Dropped Boundary Objects: Fixed obstacles being dropped in the first frame and rigid objects being dropped in the last frame, and guarded object-metric pose interpolation at clip boundaries.
Ground Mesh with Rig Offset: Fixed ground-mesh reconstruction when the rig has a non-zero z_offset, and included z_offset in the reconstruction settings.
Track Calibration Device Placement: Fixed unicycle and static track calibration mixing devices when tracks live on the GPU, and made StaticTracksCalib means deterministic.
Scene Cache Keying: Scene caches are keyed by both scene ID and URL, so two artifacts registered under one ID no longer collide.
Composite Radiance Scaling: Fixed Gaussian USD radiance scaling for composite models, and fixed GRT linear radiance when post-processing is disabled.
Empty Loss Handling: Fixed empty fused-loss handling, and guarded node-semantic and background-in-track reference losses against masked-out non-finite logits.
Validation Render Synchronization: Selected-node DDP renders are synchronized so ranks produce symmetric validation output.
Progressive Artifact Levels: Progressive levels are restored when loading an artifact.
Auxiliary Data Generation: Fixed a squeeze on single-point camera frames during auxiliary data generation, and fixed auxiliary shard discovery to use sequence_id as the file prefix.
Semantic Auxiliary Access: Guarded semantic auxiliary access during validation when auxiliary data is disabled.
Gaussian Seeding and Relocation: Gaussian initialization is seeded from every training LiDAR rather than only the first, optimizer moments are reset for relocated Gaussians, and a fused point-cloud scene extent is used as a fallback.
Range Request Fallback: Fixed the S3 range probe when the server does not advertise Accept-Ranges.
Asset Harvester Symlinks: Asset Harvester resolves Hugging Face blob symlinks correctly when locating cached weights.
Checkpoint Completeness: Post-batch model state is saved in final checkpoints, and NRM mounted model cache compatibility is restored.

Known Issues

Harmonizer does not run under distributed (multi-GPU) training: Harmonizer now fails fast instead of producing a device-mismatch error partway through. When a distributed process group is initialized with a world size greater than 1, loading the Harmonizer model raises Harmonizer does not support multi-GPU execution (world_size=N). Its TorchScript model is not multi-GPU-safe because of a shared model-cache download race and device-baked constants; 26.08 guards this condition rather than fixing the underlying model. The check keys on the distributed world size, not on how many GPUs are visible, and it runs when the model loads — at trainer setup for Harmonizer training, and at the first validation epoch for Harmonizer inference during a training run. Workaround: run Harmonizer training with a world size of 1, for example by restricting CUDA_VISIBLE_DEVICES, or apply Harmonizer at inference through the gRPC server. serve-grpc never initializes a process group, so --enable-harmonizer works on a multi-GPU host with no need to restrict visible GPUs. This replaces the 26.06 known issue describing the same limitation as a validation-time CUDA error. See Use Harmonizer for Post-Processing.
Temporal Harmonizer restrictions: The temporal Harmonizer is inference-only and is not available for training. It cannot be combined with the stateless --enable-harmonizer, with multi-process serving (--multiproc-workers > 0), or with the batch render RPCs — send a session’s frames one at a time, in trajectory order, awaiting each render. Component-only masks that need per-pixel semantics are also rejected for Harmonizer novel-view training.
Asset editing is single-process only: Under multi-process serving, edit_assets returns success=False with an UNIMPLEMENTED message and restore_model_parameters aborts with gRPC status UNIMPLEMENTED. Use a single-process serve-grpc for in-place asset edits. Per-request dynamic-actor re-posing through --enable-editing-actors works in both modes.
Listed scenes may not be renderable under multi-process serving: Unlike the single-process server, a multi-process get_available_scenes entry may be registered but not yet attached or validated, so a listed scene’s first render can return NOT_FOUND or UNAVAILABLE. Use get_loaded_scenes as the render-readiness check.
gRPC asset replacement rendering: In some gRPC asset-edit scenarios, an inserted asset may not visually replace the target scene vehicle in rendered output (for example, a grey van edit on Hyperion 8.1 scenes). Reported on RTX PRO 6000. This issue is carried over from 26.06.
General Linux aarch64 is not a supported platform: The supported user platform for NuRec remains Linux x86_64. The GB300 and DGX Spark enablement described under Core Improvements is targeted Grace-Blackwell support, not general aarch64 support, and it carries these caveats. It reaches you only through the -arm64 or -multiarch container tags; pulling an unsuffixed tag on an aarch64 host gives you the x86_64 image, which does not include the compatibility shim. The aarch64 and multi-architecture image builds run as non-gating nightly or on-demand CI jobs, so those tags can lag the x86_64 ones, and container security scanning covers the x86_64 image only. See Hardware Setup and Requirements.

Version 26.06 — July 2026

Core Improvements

Harmonizer gRPC Naming: gRPC server flags are renamed from --enable-difix / --difix-* to --enable-harmonizer / --harmonizer-*. Legacy difix flags still work and redirect to their Harmonizer equivalents but emit deprecation warnings. See Use Harmonizer for Post-Processing and Use the NuRec gRPC API Server.
Harmonizer Checkpoint Downloads: Harmonizer checkpoints can be fetched from the Hugging Face model registry at runtime (default: nvidia/Harmonizer).
GSplat as Default Renderer: GSplat is now the default renderer for NRE inference and NRM training. The gRPC --renderer flag still supports default, gsplat, and nrend backends. See Use the NuRec gRPC API Server.
Semantic Render Outputs: The render CLI adds --output-type, --colorization-max-distance, and --semantics-legend. Camera renders can include semantic_image output, and artifacts export semantic class names and colors metadata for downstream visualization.
PPISP Library Update: Adopts the latest PPISP library with improved controller distillation, checkpointing, and HDR responsivity scaling. PPISP USD export adds SPG-runtime and SH-optimized integration modes. The PPISP controller is disabled by default in new configs.
Ground-Mesh Road Initialization: Improved camera ground-mesh road initialization for lidarfree training, with reduced multi-GPU initialization stalls and deduplicated ground-mesh work during training.
Hyperion 8.1 Eight-Camera Config: New car2sim_8cam production config for Hyperion 8.1 (no cross cameras). See Configuration.
Joint Camera and LiDAR Training: New default config for joint camera and lidar training workflows.
Multi-Camera SFM Initialization: Structure-from-motion initialization now supports multi-camera rigs.
Dynamic Car Masks: Supports dynamic car masks for arbitrary camera setups during auxiliary data generation and training prep.
Render During Training: New Lightning callback renders validation frames during training without a separate post-training step.
Asset Harvester Hugging Face Integration: Asset Harvester fetches models from Hugging Face Hub and ships as the GA asset-harvester wheel (v1.0.1). See Use NuRec with Asset Harvester Output.
Novel Rig Camera Export: USD and trajectory export supports cameras defined in rig.json that are not present in the reference artifact.

Bug Fixes

Harmonizer Multi-GPU Device Placement: Fixed Harmonizer (formerly Difix) model device placement so multi-GPU gRPC rendering places the post-processing model on the correct GPU.
Pinhole FOV Clamp: Clamps pinhole field-of-view to the camera’s max_angle to avoid invalid negative focal lengths during NRM rendering.
Cubemap Envmap TV Regularization: Fixed total-variation regularization for cubemap environment maps.
Ground Mesh Initialization: Fixed ground-mesh initialization edge cases in lidarfree road-layer setup.
Config Upgrade Robustness: Config upgrades tolerate null model.post_processing values without failing.
Asset Insertion Scale: Preserves asset scale when inserting harvested assets via gRPC or the render pipeline.
Asset Extra-Signal Buffers: Expands empty extra_signal buffers on asset insertion to prevent shape mismatches.
LiDAR Novel-Pose Zero Rays: Fixed a zero-ray bug when rendering lidar from novel poses.
NRend Fisheye Tiling: Fixed tiled-splat artifacts in NRend fisheye camera rendering.
LiDAR Validation: Fixed a lidar validation metric routing bug.
Instant NuRec PLY Viewer: Fixed ply_viewer crashes when opening Instant NuRec (and other) PLY files.

Known Issues

Harmonizer training on multi-GPU nodes: Training with Harmonizer enabled (configs that run Harmonizer distillation or inference during train/val) on multi-GPU systems—especially 8-GPU nodes such as H20—can fail during validation with a CUDA device-mismatch error in the Harmonizer model probe (tensors split across cuda:0 and cuda:N). This is a regression from 26.04. Workaround: run Harmonizer training on a single GPU, or disable training-time Harmonizer and apply Harmonizer at inference via the gRPC server (--enable-harmonizer). See Use Harmonizer for Post-Processing.
gRPC asset replacement rendering: In some gRPC asset-edit scenarios, an inserted asset may not visually replace the target scene vehicle in rendered output (for example, a grey van edit on Hyperion 8.1 scenes). Reported on RTX PRO 6000.

Version 26.04 — May 2026

Core Improvements

Instant NuRec: Added a new instant_nurec config that allows for faster NuRec training and higher quality output. Generate gaussians with Instant NuRec for input to NuRec to optimize for training speed and quality.
Harmonizer: Released Harmonizer, an online diffusion enhancer that improves temporal consistency, appearance harmonization, artifact correction, and lighting realism on neural-reconstruction renderings. Pretrained checkpoints are on Hugging Face (nvidia/Harmonizer). See Use Harmonizer for Post-Processing.
GSplat Renderer — Lidar Rendering: GSplatRenderer now supports lidar rendering, including direct use of gsplat’s own lidar preprocessing and removal of legacy transpose workarounds. Adds antialiased camera mode by default, saturate_radiance support, and sensor-type-specific output configs.
GSplat Training Recipes: New car2sim_gsplat and car2sim_6cam_gsplat config YAMLs, plus an end-to-end Waymo-on-gsplat training recipe.
Unified gRPC Renderer Selection: New --renderer flag on the gRPC server selects the rendering backend (default for the artifact’s trained renderer, gsplat to force GSplatRenderer, or nrend for the fast C++/CUDA JIT). The legacy --enable-nrend and --use-gsplat flags are deprecated and emit a DeprecationWarning when used.
Lidarfree — Colored Ground-Mesh Init: Lidarfree now initializes the road layer from a colored ground mesh, with sparsity compensation, optional random road points, and a clearer projection-type config to disambiguate it from the newer projection mode.
Lidarfree — Traffic Light Layer: Traffic light layer is now enabled in lidarfree mode.
Stateless Track Edits: Track edits applied via the gRPC API and render command are now stateless, simplifying composition with other edits and avoiding cross-request leakage.
Demo Transform in Lidar Render: render_lidar requests now apply the demo actor transform consistently with camera rendering.
Per-Step Validation Render Directories: New separate_val_dir_per_step config prevents validation renders from being overwritten across training steps.
Direct S3 Reading: nvs_ncore and aux_gen can now read scenes / data directly from S3 paths without an intermediate download step.
NCore Upgrade: Adopts NCore’s native time-restriction API, exposes cuboid_loading_max_workers (defaulting to serial in V3 to avoid contention), adds caching for loaders and sensors, and enhances cuboid data-processing options.

Bug Fixes

Static Rigids Rainbow Artifacts: Reduced rainbow artifacts that appeared on static_rigids layers.
NCore Pose Dtypes: Fixed pose dtypes and made world_global optional in NCore loading; extended batch tests.
Frame Transform Pose Dtype: Preserved T_poses dtype in frame_transform_pose to avoid silent precision loss.
Static Tracks Failure: Fixed an initialization failure path for static tracks.
Lidarfree on NCore V4: Removed the hard requirement of a lidar sensor for lidarfree training when migrating to NCore V4.
USD Export Track Filtering: Refined track filtering and logging during USD export.
Celsius Output Range: Fixed the celsius output range in temperature post-processing.
gRPC Lidar Rendering Without Lidar: Returns a clear error message when an artifact has no lidar sensor; up to one lidar sensor is now supported (zero allowed).

Version 25.07 — July 28, 2025

Version Highlights

PPISP Production Ready - Physically plausible image signal processing now in production
Blackwell GPU Support - Full support for NVIDIA’s latest B100/GB100 architecture
Enhanced Temporal Appearance - Improved handling of dynamic lighting changes
MCMC Memory Cap
Stability enhancements

New Features

PPISP Integration Now Production Ready (NRE-485)

Full production integration of Physically Plausible Image Signal Processing
Supports exposure compensation, vignetting correction, color correction, and camera response functions
Ported to Slang for improved performance
Available for both camera and post-processing pipelines
Missing : nRend integration

Blackwell GPU Support (NRE-1191)

Full support for NVIDIA B100/GB100 GPUs
Optimized CUDA kernels for Blackwell architecture
Support for FP4 precision on new tensor cores
Compatibility from CC80 to CC100

Enhanced Temporal Appearance Changes

Improved handling of traffic lights and vehicle brake lights
Better temporal consistency for dynamic lighting
Reduced flickering in time-varying scenes

MCMC Promoted to Default Strategy

MCMC sampling strategy moved from experimental to default configuration
Improved convergence and quality over previous default
Legacy strategy still available via config override

Bug Fixes

Fixed multi-GPU training crashes - Resolved the ~5% crash rate issue promised in 25.06
Fixed lidar scan direction - Carried over fix from 25.06, now verified
Fixed quaternion initialization - Resolved NaN issues in rotation computations
Fixed road loss gradient NaN - Improved numerical stability
Fixed Bilarf camera resolution bug - Resolved issues with multiple camera resolutions
Fixed MCMC NaN covariance - Improved stability in MCMC sampling
Fixed gRPC linear_cde support - Added missing proto definitions
Fixed calibration issues during rendering - Disabled calibration workaround
Fixed actor pose interpolation - Corrected track pose updates in artifacts

Known Issues

High memory consumption - Progressive Distillation now requires >192GB RAM (increased from 96GB)
Render gRPC limitations - Limited to 25.07 data format, breaks backward compatibility
Multi-GPU edge cases - Still crashes when using dataset.aux_data=false (carried from 25.06)
Night time performance - Limited quality with active light handling (ongoing issue)
PPISP not fully integrated in nRend - Recommended to disable nRend for PPISP workflows
Fixer for Tesla not included - Model integration postponed to 25.08