DeadEye™
A proprietary Vulkan simulation and visualization engine.
DeadEye™ is our 3D simulation and visualization engine, written from scratch in C++ with a custom Vulkan rendering pipeline. We built it because the tools we needed did not exist in a form we could own, extend, and take to classification.
Out the canopy at 1,993 feet over the Na Pali coast, inbound to the Pacific Missile Range Facility. Terrain meshed from elevation tiles, waypoints and tracks overlaid live.
Real-World Terrain, Anywhere on Earth
DeadEye™ works in WGS84 geodetic coordinates over a first-party mapping stack: vector basemap tiles, satellite imagery, and terrain meshed from elevation tiles. A scenario is staged over the geography it would actually be fought over, and the same scene renders from the cockpit, from a chase camera, or from a top-down tactical picture.
The same engine in a tactical view over New York, tracking twelve objects with the scene hierarchy and entity properties alongside.
Exoatmospheric Engagement
A midcourse scenario rendered in DeadEye™, from post-boost vehicle deployment through intercept, with the engagement clock running against the Earth limb.
Built From Scratch
No external rendering dependencies. Every layer, from the physics to the interface, is ours to modify and ours to certify.
Custom Vulkan Pipeline
Roughly 100,000 lines of first-party C++17 written directly against Vulkan, with Cook-Torrance physically based shading, shadow mapping, and a hardware ray tracing path with a denoiser that falls back to software when the extension is missing. Building on the metal rather than on a game engine means no licensing constraints and no black boxes in the path to accreditation.
Validated 6DOF Flight
Thirteen-element rigid body state with quaternion attitude, fixed-step RK4 in double precision, and aerodynamics evaluated four times per step. Airframes include coefficient tables exported from the NASA GTM database and a Stevens and Lewis F-16 buildup, checked against MATLAB reference trajectories within AIAA and NESC thresholds.
Cockpit and Sensor Views
Any camera in the scene can be flown from: out the canopy of a platform, slaved to a seeker, or pulled back to a tactical overview. Operators evaluate a concept from the seat they will actually occupy rather than from a plan view.
GPU Compute Physics
Finite element soft bodies on GPU compute with a St. Venant-Kirchhoff model and tetrahedral meshing, plus penalty-based rigid body contact with friction and terrain hits through a GPU bounding volume hierarchy. These serve the editor and visual effects. The tactical simulation itself runs on the CPU.
Asset Pipeline and Plugin SDK
Full FBX import covering meshes, materials, hierarchy, skeletons, animation curves, lights and cameras, and able to parse from memory so an encrypted asset pack never touches disk. OBJ, Blender and USD readers build in when their dependencies are present. A versioned C plugin interface lets third-party modules read tracks, draw markers and write to the heads-up display.
Works Disconnected
Map tiles serve from a persistent disk cache with a strict offline mode that never touches the network, backed by self-contained PMTiles and MBTiles archives. Cursor on Target queues to disk when the link drops, survives a restart, and drains on reconnect. Fly once, replay indefinitely.
Planetary-Scale Precision
World positions are rebased on the camera before the view transform, which is what holds precision from a cockpit at 1,500 feet out to an exoatmospheric intercept without the geometry tearing itself apart. Covered by a regression test.
Intercept That Can Miss
A ballistic missile engagement flown under proportional navigation with finite burn, finite divert authority after burnout, seeker acquisition range and seeded angular seeker noise. Closest approach is solved analytically inside each integration step rather than sampled at step boundaries, so the miss distance measures the engagement and not the integrator. An engagement planner handles priority, salvo spacing, rail occupancy and magazine limits, and logs why each round was committed.
Networked Situational Awareness
Cursor on Target over UDP multicast or TCP to a TAK server, and two-way exchange with an Anduril Lattice environment, both validated against live systems. Own ship publishes once a second and remote tracks appear on the map. Runs on macOS and Linux as a single process.
Why We Own the Stack
Commercial engines are built for entertainment, and their licensing, source access, and export posture reflect that. Classified simulation has different requirements. It has to run on air-gapped infrastructure, it has to be auditable line by line, and it has to survive the accreditation process without a vendor in the loop.
DeadEye™ is built in house, which means we can extend it for a specific program, instrument it for a specific analysis, and deploy it into an environment where an external dependency would be disqualifying. It runs on our own data centers in Arizona, backed by hundreds of Xeon cores and dedicated NVIDIA GPU clusters, and we are building the dedicated facility to take it to the highest classification levels.
The engine is also where our AI work lands. DeadEye™ runs language model inference in process on its own GPU, with a tool registry the model can call, so an assistant can reason about the tactical picture without that picture leaving the machine. Training and large analysis runs happen separately on our own Arizona infrastructure, on open-weight models fine-tuned with custom LoRA adapters.
See It Run
We demonstrate DeadEye™ for government and prime contractor programs.