Inspiration
We were inspired by the incredible strategic depth of modern e-mobility races like Formula E. We noticed that victory in these events isn't just about raw speed—it's about the complex, split-second decisions drivers make to manage their limited battery and regenerative braking. While most racing simulators focus on hyper-realistic physics and graphics, they often miss this crucial strategic layer. We wanted to answer the question: "Can we build a lightweight, fast, and exciting simulator that captures the strategy of an e-race, not just the physics?"
What it does
Delta-V Sim simulates a complete e-mobility race (like Formula E or drone racing) from a purely strategic perspective. It allows multiple AI or human-controlled agents to compete on a graph-based track, where their primary challenge is managing their vehicle's battery. Agents must decide when to accelerate, when to conserve power, and when to use regenerative braking. A central "Race Master" injects live events like "Yellow Flags" or "Debris on Track," forcing agents to adapt their strategies in real-time. The entire race state and ranking are streamed to a live leaderboard API, allowing for real-time spectating.
How we built it
Since the goal was a lightweight simulator, we designed "Delta-V Sim" as an event-driven, agent-based model rather than a heavy physics engine. Graph-Based Track: Instead of a complex 3D environment, our track is a directed graph—a series of nodes (corners, straights) and edges (the track itself). This allows the simulation to run incredibly fast. The Agent Model: Each "racer" is a software agent with a simple state: position (on the graph), velocity, and, most importantly, battery_SOC (State of Charge).The Energy Model: This is the core of our project. Agent movement has an energy cost based on a function of its acceleration, the track gradient, and its current power mode (e.g., Full Power, Overtake, Regen-Braking). The "Race Master" Event Engine: A central server component acts as the "Race Master," injecting dynamic events like 'Yellow Flags' (slowing all agents) or 'Virtual Safety Cars' that all agents must react to.Live Leaderboard API: The simulator is designed to continuously update all agent states in a high-speed cache (like Redis). A separate FastAPI service would then read this data to expose a REST API, allowing any web-based frontend to poll it and display a live leaderboard.
Challenges we ran into
Our primary challenge was a design one: balancing realism and simplicity. The hardest part was modeling the energy cost function. We wrestled with how to make the trade-offs meaningful. How much extra battery should an 'Overtake' cost? How much energy should 'Regen-Braking' realistically recover? Fine-tuning this model to create real strategic choice, rather than an obvious "best" answer, was the main design hurdle. Another challenge was designing the Race Master logic. The events needed to feel impactful and dynamic, forcing players to adapt, but not so random that they felt unfair. Designing this logic to create chaos that feels like a real race was a significant part of our planning.
Accomplishments that we're proud of
(Since this is an idea submission, these following "accomplishments" are in the novelty and completeness of the design.) We are incredibly proud of successfully designing a "lightweight" simulator that doesn't sacrifice depth. Our main accomplishment is the architecture itself. We've created a concept that moves beyond the typical physics-first approach to capture the emergent strategic behavior of a real e-race. We're proud of the "Race Master" event engine concept, which turns a simple simulation into a dynamic and unpredictable game. Finally, we're proud of the design's inherent scalability; because it's graph-based and event-driven, it's designed from the ground up to be fast and efficient.
What we learned
The biggest lesson was the power of abstraction. We learned that to model a complex, exciting race, you don't need to simulate every molecule of tire smoke. By focusing on the critical state (energy) and the relationships between agents (the graph), we could design a system that produces complex, emergent strategic behavior from a few simple rules. We also learned how to design an event-driven architecture. Decoupling the core simulation loop from the live leaderboard API was a key design insight to ensure the simulation runs at high speed without being blocked by web requests.
What's next for Delta-V Sim
This idea is the blueprint, and the next step is to build it. Our roadmap is: Build the Core Engine: Develop the Python-based simulation loop, the graph-based track model, and the agent class with its core energy management logic. Implement the "Race Master": Build the event-injection engine and a simple ruleset for dynamic events like safety cars and track flags. Develop the Leaderboard API: Create the FastAPI/Redis backend to expose the live simulation data to the web. Add AI Agents: Implement a baseline AI agent with simple strategies (e.g., "Aggressive," "Conservative") to race against. Expand the Model: Add more complex features like "DRS-style" power boosts, pit stop strategies (for battery-swapping drone races), and team-based objectives.
Log in or sign up for Devpost to join the conversation.