SimPulse

Dynamic race and mobility simulator that fuses vector modeling, AI behavior & probabilistic events to recreate the thrill and strategy of real-world competitions — from Formula E to autonomous drones.

Comment

Inspiration

Modern competitive mobility systems — from Formula E and MotoGP to drone swarms and autonomous vehicle trials — require fast, reliable simulation environments to test performance and strategy under dynamic, uncertain conditions. However, most available simulators are either too resource-intensive or too domain-specific.

We were inspired to design SimPulse, a lightweight yet expressive simulation framework that captures the essence of competitive motion, decision-making, and event-driven changes in real time. The goal was to build a platform that could model both human and AI competitors while remaining interpretable, extensible, and computationally efficient.

What It Does

The Competitive Mobility Systems Simulator (SimPulse) models multiple competing entities moving within a dynamic environment. Each participant — be it a car, drone, or boat — is represented as a vector in a high-dimensional feature space, with each dimension corresponding to an influencing factor such as engine efficiency, terrain response, or decision aggressiveness.

The simulator evolves these vectors over time using probabilistic distributions that capture realistic variations in performance, fatigue, and environmental effects. Real-time events like breakdowns, weather changes, or driver decisions are handled through an event-driven system, while optional AI modules introduce strategic diversity among competitors.

In a test scenario, for example, a Formula E sprint simulation models five AI drivers adapting their energy usage as rain probabilities and tire temperatures fluctuate — producing emergent overtakes and unique race outcomes.

SimPulse outputs detailed race metrics such as lap times, position deltas, energy efficiency, and rank progression curves, visualized through a live console or basic UI showing progress and standings.

How We Built It

We began by defining a modular architecture consisting of three layers:

  1. Core Simulation Engine: Implements the vector-space representation of entities and updates their states using stochastic processes (Gaussian noise, weighted probabilistic transitions).
  2. Event and Strategy Layer: Handles real-time events (e.g., breakdowns, collisions, pit stops) and embeds strategic or AI-driven decision modules that influence each competitor’s trajectory.
  3. Visualization Layer: Provides a live console or lightweight graphical interface (built using Python + Matplotlib / Pygame) that tracks progress, standings, and performance metrics.

The architecture is designed to be stack-agnostic, allowing future extensions into web environments (e.g., React + D3.js) or reinforcement learning integration using PyTorch.

🧮 Mathematical Core of SimPulse

Each competitor (car, drone, or vehicle) is modeled as a state vector in an n-dimensional performance space:

$$ \mathbf{x}_i(t) = [v_i(t), a_i(t), e_i(t), s_i(t), \theta_i(t), ...] $$

Where:

  • \( v_i(t) \): Velocity
  • \( a_i(t) \): Acceleration factor
  • \( e_i(t) \): Energy efficiency or remaining power
  • \( s_i(t) \): Strategy parameter (aggressiveness vs. conservation)
  • \( \theta_i(t) \): Heading / orientation

⚙️ State Evolution Function

Each entity evolves based on its control inputs, the environment, and stochastic effects:

$$ \mathbf{x}_i(t+1) = \mathbf{x}_i(t) + \Delta t \cdot f(\mathbf{x}_i(t), \mathbf{u}_i(t), \mathbf{E}(t)) + \boldsymbol{\epsilon}_i(t) $$

Where:

  • \( f(\cdot) \): Deterministic transition dynamics
  • \( \mathbf{u}_i(t) \): Control vector (e.g., throttle, steering, boost)
  • \( \mathbf{E}(t) \): External environmental parameters (weather, terrain)
  • \( \boldsymbol{\epsilon}_i(t) \sim \mathcal{N}(0, \Sigma) \): Stochastic event or randomness term

⚡ Performance Index

To evaluate race outcomes dynamically:

$$ P_i(t) = w_1 v_i(t) + w_2 e_i(t) - w_3 \text{penalty}(t) $$

Where:

  • \( w_1, w_2, w_3 \): Tuned weights depending on the competition type
  • \( P_i(t) \): Dynamic performance score determining ranking

Competitors are ranked in real time by sorting these ( P_i(t) ) values.

🔁 Event Simulation Logic

for each timestep t:
    for each competitor i:
        update state: x_i(t+1) = f(x_i(t)) + noise
        if random() < breakdown_prob:
            trigger("breakdown", i)
        if random() < weather_change_prob:
            modify_environment()
    update_leaderboard()

This compact logic drives the emergent race dynamics that SimPulse models across sports and mobility systems.

🧠 Future AI Integration (MDP Framework)

SimPulse’s control policy can later be formulated as a Markov Decision Process (MDP):

$$ \langle S, A, P, R, \gamma \rangle $$

Where:

  • \( S \): State vectors of all entities
  • \( A \): Control / strategy actions
  • \( P \): Probabilistic transition function
  • \( R \): Reward function (position gain, energy savings, etc.)
  • \( \gamma \): Discount factor for long-term strategy

This lays the foundation for integrating reinforcement learning or adaptive AI behaviors in future versions.

Challenges We Ran Into

A key challenge was balancing realism and computational simplicity. High-fidelity physics models quickly became computationally heavy, while oversimplified approaches lacked dynamic richness. Another difficulty was ensuring that event randomness did not overwhelm strategic behavior — competitors needed to act believably rather than purely by chance.

Designing a flexible data structure to accommodate different competition types (Formula E, drone races, or supply-chain logistics races) also required careful abstraction.

Accomplishments That We're Proud Of

We successfully built a probabilistic simulation framework capable of handling diverse race types within a unified model. Our event-handling system can inject realistic disturbances — such as weather effects or system failures — while maintaining coherent simulation flow.

The vector-space abstraction proved powerful, allowing us to represent complex behaviors and performance interactions compactly. We’re also proud that SimPulse can be extended easily to include reinforcement learning agents or AI-based strategy modules.

What We Learned

We learned that modeling competitive mobility systems involves more than just physics — it requires integrating uncertainty, decision-making, and adaptive strategies. Representing entities in a vector space opened new ways to think about competition as a dynamic evolution through multidimensional factors.

Additionally, we gained hands-on experience with probabilistic simulation, state management, and modular software design, which are applicable far beyond this project.

What's Next for the Project

Future work includes incorporating reinforcement learning to allow AI agents to learn optimal racing strategies dynamically. We plan to add multi-agent interaction modeling, real-time visualization dashboards, and an expanded event library to simulate more complex scenarios such as team-based racing or swarm coordination.

We also envision SimPulse as an open-source toolkit for educators, motorsport teams, and mobility researchers — enabling them to experiment with AI-driven behavior, test race strategies, and explore mobility system dynamics in an accessible, computationally lightweight environment.

Share this project:

Updates