PITGUN
A Generalized Telemetry Framework
While initially deployed in a racing context, the pitgun ecosystem is built as a highly-performant, real-time telemetry processing framework. It is structurally designed to handle massive data throughput across diverse domains—including automotive, financial trading, energy grids, and smart urban infrastructure. Powered by a manifest-driven engine, all logic is encoded as Abstract Syntax Trees rather than hardcoded routines.
The Distributed Vision
At its core, the pitgun ecosystem utilizes a distributed edge-computing architecture. To demonstrate the large throughput capabilities of our Rust framework, the telemetry calculations for the pitgun-game simulators are distributed directly to the players, transforming every player into a telemetry-generating edge node.
1. Edge Computing
Lap times are computed on the player's hardware, acting as a massive distributed solver grid connecting back to the server authority.
2. Telemetry Engine
Active players instantly generate raw, high-frequency telemetry streams by running the physics simulators in parallel.
3. Framework Showcase
These distributed streams are securely ingested, aggregated, and validated by the Rust core, showcasing high data throughput. These streams are normalized via a manifest built from a registry.
FIG. The overarching edge-distributed architecture of the Pitgun ecosystem
Runtime Infrastructure
Supporting the pitgun-game testbed requires an advanced microservices architecture. The lab is powered by dedicated instances interacting through secure WebSocket and HTTPS connections. Browser clients execute a strict 100ms deterministic simulation loop, streaming session envelopes directly to the pitgun-gateway.
Traffic is routed via Traefik through the main gateway to handle WASM browser clients. The backend relies heavily on pitgun-authority & pitgun-core services for validation, while Mistral models process the game state through specialized metrics. Furthermore, CI/CD pipelines automate deployments to the remote servers, ensuring rapid iteration of telemetry experiments.
| Environment | Purpose | Stability | Data Usage |
|---|---|---|---|
| Research | Fast experimentation on model assumptions. | Low | Internal calibration only. |
| Staging | Integration validation before wider exposure. | Medium | Pre-release balancing. |
| Beta | Controlled real-player signal collection. | Medium / High | Collective baseline convergence. |
| Production | Stable public experience. | High | Continuous quality refinement. |
FIG. Microservices topology underlying the Pitgun telemetry laboratory
Collective Calibration Loop
Pitgun turns player behavior into a calibration engine. As players iterate on setups, pacing, and strategy, the ecosystem receives a large volume of deterministic telemetry traces. Over time, this naturally drives convergence toward stronger baselines and reveals which parameter combinations consistently produce better lap-time outcomes.
- Run execution: player sessions generate deterministic simulation outputs.
- Validation layer: traces are checked for consistency and contract compliance.
- Aggregation layer: comparable runs are grouped into calibration datasets.
- Model refinement: updated baselines are fed back into simulation tuning.
Privacy by Design
Pitgun follows a minimal-data approach. We collect only telemetry necessary to improve simulation fidelity and balancing quality. No advertising trackers, no cross-site profiling, and no gameplay email dependency. The objective is technical: improve lap-time model accuracy through collective intelligence, not monetize personal data.
FIG. Data routing through the dual-loop analytical pipelines
The Physics Kernel
Adapted from a Python project, the simulator represents the mathematical predictiveness of the lap time system. It computes theoretical bounds based on grip, downforce, cooling, power throughput, track geometry, and driver style. The physics kernel relies on mathematically pure, immutable parameter sets to guarantee perfectly reproducible continuous equations.
FIG. High-level logic for the lap time simulator
The QSS Solver
The Quasi Steady State (QSS) solver determines maximum achievable equilibrium velocities purely using closed-form analytical mathematics rather than traditional iterative physics. The model is split into two domains: space and time.
FIG. Detailed flow of the mathematical QSS solver
