Senior Software Engineer, Rendering Infrastructure (AV Simulation)

Job Description Role Overview As a Senior Software Engineer on the Rendering Infrastructure team, you will build the systems that turn a GPU-accelerated, physically-based sensor simulator into a production platform — one that runs reproducibly, at cluster scale, and against production-representative autonomous vehicle interfaces. This is a systems role at the boundary of rendering, simulation, perception, and distributed infrastructure. You will connect the renderer to AV software stacks and compute clusters, reproduce real sensor scheduling and vehicle timing, run many worlds concurrently on a single GPU, and make the runtime start fast and stay cheap across thousands of workers. Your work determines whether closed-loop simulation — the vehicle software in the loop with the renderer, not just offline synthetic data generation — is trustworthy and affordable: whether a run reproduces, whether synthetic sensor feeds arrive with the same timing quirks the real vehicle sees, and how many scenarios we can execute per GPU-hour. We build in modern C++ and Python on Linux, with ROS, PyTorch, CUDA, NVIDIA OptiX, NVIDIA MDL, and OpenUSD. We're looking for someone who enjoys this layer — debugging nondeterminism across a process boundary, cutting cold-start time by changing how a runtime is packaged, and reasoning about GPU memory and IPC in the same conversation. About the Team The Rendering Infrastructure team owns the foundational systems the broader Rendering team builds on top of: asset and scene ingestion, GPU memory and resource management, acceleration structure construction, packaging and deployment, profiling infrastructure, and the core engine abstractions of our physically-based sensor simulation system. We also own how the renderer connects to the AV stack and world simulator, as a library or a service, and how consumers configure it — what it produces, at what fidelity, and how it behaves when something goes wrong. We sit between the rendering algorithms team and everyone who consumes simulated sensor data — perception training, closed-loop validation and reinforcement learning. We care about determinism, throughput per GPU, iteration speed, and infrastructure that stays comprehensible as it scales. Why Join Us? Work on hard systems problems with an unusually clear definition of success — reproducibility, timing fidelity, frames per second per GPU, and worker spin-up time are all measurable, and all of them matter. Own meaningful surface area: the AV stack integration and transport layer, the sensor scheduling and timing model, multi-world rendering on a single GPU, or the runtime deployment and asset delivery path, depending on your strengths. Sit at the center of the simulation stack, where rendering, perception, and infrastructure meet, and see your work used across the organization for perception training, closed-loop simulation, and reinforcement learning. Join a team that pairs rigor — design documents, reproducibility, profiling, and regression testing — with pragmatic engineering and short feedback loops. What You'll Do You will own one or more of the following areas and contribute across the others, depending on your strengths and team priorities. Connect the renderer to AV software stacks and compute clusters — designing low-latency, high-bandwidth transport using ROS/ROS 2, shared-memory IPC, gRPC, and sockets with appropriate serialization formats, and streaming multi-sensor payloads into the autonomous vehicle stack. Integrate the renderer with learned driving models through Gymnasium-style environment APIs — stepping the simulation from Python, exchanging observations and actions efficiently with PyTorch-based models, and preserving deterministic execution while minimizing per-step overhead for eval and training at scale. Integrate the runtime with the cloud and on-premises execution environments used for large-scale closed-loop testing, continuous integration, and perception training pipelines. Improve and validate deterministic execution — establishing the required bit-accurate or frame-deterministic lock-step behavior across the simulation clock, dynamic physics updates, and the ray-traced renderer, and building the tooling that demonstrates a run reproduces to the agreed bar. Reproduce real sensor scheduling and vehicle timing — staggered camera exposures, rolling shutter behavior, LiDAR spin and packet rates, hardware clock drift, and the onboard constraints perception actually operates under, including P95/P99 compute latency, transport lag, and packet drops. Build perturbation mechanisms that inject timing jitter, dropped or out-of-order frames, and calibration drift in both extrinsics and intrinsics, and use them to stress-test downstream perception and sensor fusion robustness in closed-loop runs. Build memory-efficient multi-world and multi-scenario execution inside a single rendering process, using shared geometry and instancing — OptiX IAS/GAS, or the analogous acceleration structure hierarchies in Vulkan/DXR — so concurrent rollouts share static map geometry instead of duplicating it in GPU memory. Optimize GPU memory footprint, scene streaming, and execution scheduling to maximize frames per second per GPU across concurrent simulation workers. Improve runtime deployment and asset delivery — deterministic deployment packages (SquashFS archives, read-only container layers, memory-mapped storage) and low-overhead loaders for OpenUSD scene graphs and NVIDIA MDL materials that work against compressed, read-only filesystems without redundant decompression or copies. Build distributed caches for textures, precompiled OptiX/PTX shader pipelines, and prebuilt acceleration structures to eliminate cold-start compilation and redundant I/O at cluster scale. Profile and reduce disk, network, and memory footprints to cut worker spin-up time, binary payload size, and asset ingestion overhead. Partner with the 3D content and USD pipeline teams to set runtime budgets, automated validation rules, and compression workflows before assets enter deployment. Uphold high standards through technical design documents, code review, reproducibility and performance regression testing, and mentorship of other engineers. What You Must Have Bachelor's degree in Computer Science, Computer Engineering, a related technical field, or equivalent practical experience. 5+ years of professional software engineering experience, with a substantial portion focused on performance-critical systems software. Production proficiency in modern C++ (C++17/20), including performance optimization, memory management, and clean API and system design in a large codebase, plus working proficiency in Python for tooling and automation. Strong Linux systems programming foundation: multithreading and concurrency, memory management, IPC, and high-throughput data movement, including systems that operate across process and machine boundaries. Depth in at least one of the two domains this role bridges, and the interest to grow into the other: Robotics or autonomous systems — the architecture and integration of perception, planning, or control components, and experience with at least one interface those systems are driven through: real-time middleware (ROS/ROS 2, DDS, custom IPC, or high-rate publish/subscribe) and / or a Gymnasium-style environment API; or GPU programming through a compute or ray tracing API (CUDA, OptiX, Vulkan, DXR, or similar), with a working understanding of GPU memory and execution models. A track record of designing, implementing, and debugging reliable distributed systems, including the nondeterminism and failure modes that come with them. Experience profiling and optimizing real systems, and the instinct to measure before optimizing. Strong communication and collaboration skills, with the ability to work across rendering, simulation, perception, infrastructure, and content pipeline teams. Bonus Points Experience in one or more o