Senior Software Engineer, Rendering Infrastructure (AV Simulation)

General Motors•Sunnyvale, CA

5d•$153,200 - $234,100•Remote

About The Position

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. 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.

Requirements

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.

Nice To Haves

Working knowledge of how autonomous driving perception stacks ingest sensor feeds — sensor scheduling, staggered exposures, rolling shutter, LiDAR packet rates, and onboard compute and transport latency budgets.
Experience designing closed-loop simulation edge cases and perturbations: schedule jitter, dropped frames, out-of-order packets, and calibration or extrinsics drift.
Experience with batched rendering, multi-viewport rendering, or multi-scenario execution on a single GPU using acceleration structure hierarchies and instancing (OptiX IAS/GAS, Vulkan/DXR TLAS/BLAS).
Strength in both domains above rather than one — GPU systems, and robotics or autonomous systems — or practical depth in ray tracing and path tracing specifically (NVIDIA OptiX, Vulkan Ray Tracing, or DirectX Raytracing).
Hands-on Linux deployment optimization: SquashFS, loop devices, memory-mapped files, zero-copy loading, container overlay layers, and cold-start reduction across compute nodes.
Experience designing high-performance texture and shader caching systems — OptiX disk cache, Vulkan pipeline cache, or PTX distribution.
Experience consuming OpenUSD in a C++ runtime and optimizing stage traversal and runtime memory layout.
Familiarity with deploying and scaling containerized simulation jobs on cloud platforms (AWS, GCP) or on-premises HPC clusters.
Exposure to autonomous vehicle or robotics simulation platforms such as NVIDIA Omniverse, Isaac Sim, DRIVE Sim, Unreal Engine, or custom in-house simulators.
Experience supporting reinforcement learning environments or Gymnasium-style simulation interfaces as downstream consumers.
Evidence of technical contribution through open-source rendering, simulation, or systems infrastructure work, internal platforms, publications, or other knowledge sharing.

Responsibilities

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.