Physics Programmer, C++ (Modeling & Simulation)

ABOUT CODE METAL Code Metal is redefining code translation for mission-critical industries, helping defense partners move more quickly and reliably from algorithm to silicon. Our platform accelerates deployment of DSP, RF, communications, and embedded signal processing algorithms onto heterogeneous compute targets, including GPUs, FPGAs, ASICs, and edge SoCs. We also support automotive, aerospace, and semiconductor partners deploying complex algorithms onto constrained hardware with speed and rigor.

About the Role

• Own the structure, performance, and long-term health of a substantial engine codebase.
• Design and evolve an entity-component-system architecture for representing large numbers of heterogeneous simulation entities.
• Build data-oriented component storage, entity lifecycle management, system queries, execution graphs, and dependency-aware scheduling.
• Define the engine interfaces through which physics, AI, sensor, weapon, behavior, and environmental models are registered and executed.
• Create stable extension points that allow model developers to add capabilities without modifying or destabilizing the engine core.
• Design simulation loops, fixed and variable time stepping, event processing, system ordering, state transitions, and deterministic replay.
• Develop multithreaded and task-based execution systems that safely parallelize simulation workloads.
• Optimize memory layout, allocation, cache locality, component access, serialization, and data movement.
• Profile and improve CPU utilization, memory use, latency, throughput, and simulation rate against explicit performance budgets.
• Build spatial indexing, broad-phase query, collision-candidate, visibility, and proximity-query infrastructure.
• Integrate externally developed physics and mathematical models into a consistent, performant runtime.
• Develop checkpointing, snapshotting, state replication, save-and-restore, and reproducible replay systems.
• Establish clear architecture for networked and distributed simulation, including ownership, synchronization, prediction, and state transfer.
• Build tooling that allows model developers to inspect entities, debug system execution, profile model cost, and understand simulation state.
• Identify and eliminate architectural bottlenecks as simulation scale and model complexity increase.
• Lead engine design reviews, mentor other programmers, and raise the standard for C++ architecture and performance engineering.
• Remain deeply hands-on in implementation, profiling, debugging, and code review.

Qualifications

• Extensive professional C++ development experience, or equivalent experience, building performance-critical production software.
• Significant experience in commercial game development, game-engine development, or a similarly performance-constrained real-time environment.
• Experience shipping at least one commercial game, engine, platform, or interactive real-time product.
• Demonstrated ownership of foundational engine systems rather than primarily gameplay features, scripting, tools, or application-level integrations.
• Experience building or substantially extending a physics engine, game engine, simulation runtime, ECS, job system, or comparable core technology.
• Expert command of modern C++, including object lifetimes, ownership, templates, concurrency, synchronization, profiling, and low-level debugging.
• Strong understanding of data-oriented design, memory layout, cache behavior, allocation strategies, and performance-sensitive data structures.
• Experience designing or extending an entity-component system or comparable composition-based runtime architecture.
• Experience with engine loops, execution graphs, task systems, event systems, dependency management, or runtime scheduling.
• Demonstrated ability to optimize against hard CPU, memory, latency, and frame- or tick-time budgets.
• Experience using commercial profiling and debugging tools to diagnose CPU stalls, memory issues, thread contention, allocation problems, and cache inefficiencies.
• Working knowledge of real-time physics concepts such as coordinate systems, numerical integration, collision detection, spatial partitioning, constraints, and simulation stability.
• Experience designing APIs, plugin systems, SDKs, or extension frameworks used by other programmers.
• Experience maintaining and improving a large C++ codebase while continuing to deliver production capabilities.
• Experience leading major technical initiatives while remaining an active individual contributor.
• Active Secret clearance or eligibility to obtain one.

• Experience supporting very large worlds or simulations containing large numbers of active entities.
• Experience with engine-level serialization, snapshotting, replay, world partitioning, or streaming.
• Familiarity with aerospace, robotics, autonomy, and defense simulations (e.g., HLA, DIS, OneSAF, JSAF, NGTS, STK, AFISM) - Experience supporting Air Force, Space Force, joint, or broader DoW acquisition and mission-analysis programs.
• Experience developing models for sensors, weapons, electronic warfare, jamming, communications, logistics, or command and control.
• Active U.S. security clearance (Secret, Top Secret, or SCI/SAP).

• Architecture & Technical Knowledge: Designs and implements changes to single systems, collaborates on larger designs, and drives architecture reviews for multi-developer projects.
• Delivery, Scoping & De-risking: Works with Product to scope and de-risk work; provides reliable estimates for medium-sized projects with clear risk communication.
• Technical Leadership & Mentorship: A go-to technical reviewer for the team's codebase; mentors and onboards teammates; contributes to interviews and candidate experience.

• Architecture & Technical Knowledge: Designs cross-cutting changes across the stack; provides architectural guidance across the team; owns design docs for major multi-service or multi-surface projects.
• Delivery, Scoping & De-risking: Owns technical scoping and execution strategy for complex, multi-sprint initiatives; audits requirements for technical risk and hidden dependencies before development begins.
• Technical Leadership & Mentorship: The primary technical gatekeeper for the team's codebase; reviews most high-impact work; leads technical grooming, design spikes, and RFCs; coordinates across pods when changes cross domain boundaries.

• Architecture & Technical Knowledge: Provides architectural guidance across the department and invents paradigms that solve CodeMetal-specific domain problems (e.g., translation, optimization, deployment across target environments); a key resource on every major system.
• Delivery, Scoping & De-risking: A consistent contributor to the company's technical roadmap; gives reliable estimates for large cross-team initiatives; ensures pragmatic scoping toward the most valuable outcomes.
• Technical Leadership & Mentorship: An active driver of company-wide architectural reviews and proposals; mentors mid-level and senior staff at scale; influences others across departments toward the best technical outcome.

• Showcase C++ performance expertise on target hardware: Include a GitHub repo (or a private link) with a physics simulation written in modern C++ (C++17/20) that you’ve manually vectorized or ported to CUDA/OpenCL, HLS for FPGAs, or SYCL for heterogeneous GPUs. Document the achieved speed‑up vs a baseline scalar version and explain the profiling tools (e.g., VTune, Nsight, perf) you used—this directly mirrors Code Metal’s need to translate algorithms onto DSP, RF, and edge‑SoC compute blocks.
• Demonstrate domain knowledge in DSP/ RF physics: Prepare a brief technical write‑up (1–2 pages) describing a real‑world signal‑processing or electromagnetic problem you solved (e.g., a FIR filter design, antenna array simulation, or RF chain modeling). Highlight the mathematical formulation, numerical method (finite‑difference, spectral, etc.), and how you validated results against analytical or reference data. Attach this as a PDF or link it in your application.
• Align your testing and verification workflow with safety‑critical standards: In your résumé or interview, reference experience using unit‑testing frameworks (GoogleTest, Catch2) together with continuous integration pipelines that run regression and performance regression tests on multiple targets (CPU, GPU, FPGA). Mention any familiarity with DO‑178C, ISO‑26262, or MIL‑STD‑2020 compliance processes, which signals you can meet Code Metal’s rigor for defense and aerospace clients.
• Prepare for scenario‑based interview questions: Expect the team to ask you to walk through optimizing a physics kernel for a constrained edge SoC. Practice articulating your approach: (1) profiling bottlenecks, (2) choosing appropriate data layouts (AoS vs SoA), (3) applying template metaprogramming or constexpr to eliminate runtime overhead, and (4) generating hardware‑specific code (e.g., HLS pragmas) for FPGA deployment. Bring a small whiteboard‑ready example or a pre‑recorded screencast to illustrate the process.
• Negotiate with market data for senior remote C++ roles in defense/semiconductor: Use salary surveys (e.g., Levels.fyi, Glassdoor, H1Bdata) for “Principal/Staff C++ Engineer” positions in the defense and semiconductor sectors (average $180‑$230 k base plus RSU/equity). Emphasize the added value of your cross‑platform expertise and remote productivity tools (e.g., async code reviews, documented CI pipelines) when discussing compensation, and request a relocation‑adjusted stipend or a technology allowance if you’ll need high‑end workstations or edge‑device labs.