🏁 SimRacingTelemetry

Open tools, documentation, and examples for sim-racing telemetry

Record your driving sessions, keep your telemetry locally, query your lap history with SQLite, and build your own analysis tools.

Record with SimTelemetry · Documentation · Examples · Contributing

Overview

SimRacingTelemetry is an open resource for recording, understanding, querying, and building applications from sim-racing telemetry data.

Telemetry can show exactly what happened during a lap:

Where you braked
How quickly you released the brake
When you returned to the throttle
How much steering input you used
Which gear you selected
How much speed you carried through a corner
Where your racing line differed
How tires, fuel, weather, and vehicle state changed

The goal of this repository is to make that data easier to understand and use—whether you are a driver trying to improve, a developer building a dashboard, or a researcher experimenting with racing data.

Tip

The easiest way to record compatible telemetry is with SimTelemetry, a local-first desktop recorder and analysis application.

Important

Project in Development

SimRacingTelemetry is currently under active development.

This repository will provide practical examples showing how telemetry recorded with SimTelemetry can be accessed, processed, analyzed, and visualized.

Planned examples include:

Querying recorded sessions and lap information from SQLite
Loading high-frequency telemetry through the local API
Comparing speed, braking, throttle, steering, and racing lines
Detecting braking points and identifying time gained or lost
Processing telemetry with Python and JavaScript
Creating charts, dashboards, and driver-performance reports
Exporting data to CSV, JSON, or other analysis formats
Experimenting with AI-powered coaching and race-engineer tools

SimTelemetry handles the recording and local organization of your sessions. This repository demonstrates what developers, data analysts, and sim racers can build using the recorded data.

Examples and documentation will be added progressively as the data-processing workflow is developed.

--

Why Sim-Racing Telemetry?

Lap times tell you what happened.

Telemetry helps explain why it happened.

Two laps can have nearly identical times while being driven very differently. One driver may gain time under braking but lose it on corner exit. Another may carry more minimum speed but use a less efficient racing line.

With telemetry, you can move beyond guessing and compare the details directly.

Driver Inputs

Analyze:

Throttle position
Brake pressure
Steering input
Clutch position
Gear selection

Vehicle Performance

Inspect:

Speed
Engine RPM
Longitudinal G-force
Lateral G-force
Fuel level
Vehicle position

Lap Analysis

Compare:

Braking points
Throttle application
Minimum corner speed
Racing lines
Sector times
Time gained or lost

Extended Vehicle Data

Depending on simulator availability:

Tire temperatures
Tire pressures
Tire wear
Brake temperatures
Suspension travel
Ride height
Engine temperatures
Brake bias
ABS and traction-control state
Vehicle damage
Weather and track conditions

Record Telemetry with SimTelemetry

SimTelemetry is a desktop application that automatically detects supported simulators and records your driving sessions in the background.

You can use it to:

Automatically detect active simulator sessions
Record high-frequency telemetry
Store sessions and laps locally
Compare laps in a local viewer
Browse session and lap history
Access telemetry through a local HTTP API
Query session metadata using SQLite
Optionally synchronize completed sessions

No manual CSV export is required after every lap.

Start SimTelemetry, enter a compatible simulator, and drive.

Your simulator data, recorded automatically.

Download SimTelemetry →

Supported Simulators

SimTelemetry currently records telemetry from:

Simulator	Recording	Lap timing	High-frequency telemetry
Assetto Corsa	✅	✅	✅
Le Mans Ultimate	✅	✅	✅
rFactor 2	✅	✅	✅

Additional simulators are planned.

Note

Telemetry channel availability varies between simulators. Some games expose more detailed tire, suspension, weather, energy, and vehicle-state information than others.

How It Works

┌──────────────────────────────────────────────────────────┐
│                      Racing Simulator                     │
│                                                          │
│      Assetto Corsa · Le Mans Ultimate · rFactor 2        │
└──────────────────────────┬───────────────────────────────┘
                           │
                           │ Live simulator telemetry
                           ▼
┌──────────────────────────────────────────────────────────┐
│                       SimTelemetry                        │
│                                                          │
│  Automatic detection · Recording · Lap segmentation     │
│  Local viewer · Session management · Optional sync       │
└──────────────────────────┬───────────────────────────────┘
                           │
                           │ Stored locally first
                           ▼
┌──────────────────────────────────────────────────────────┐
│                    Local RaceX Data                       │
│                                                          │
│  activities.db   → Sessions, laps, events and file index │
│  telemetry/      → High-frequency per-lap telemetry      │
└───────────────┬───────────────────┬──────────────────────┘
                │                   │
                ▼                   ▼
        SQLite queries       Local HTTP API
                │                   │
                └──────────┬────────┘
                           ▼
┌──────────────────────────────────────────────────────────┐
│                    Build Anything                         │
│                                                          │
│ Dashboards · Lap comparison · AI coaching · Data science │
└──────────────────────────────────────────────────────────┘

Local-First Storage

Every recorded session is written to your computer first.

SimTelemetry uses a hybrid storage architecture:

SQLite stores searchable session, lap, event, and telemetry-file metadata.
Compact telemetry files store high-frequency driving samples efficiently.
A localhost API converts recorded telemetry into convenient JSON.

This avoids turning the SQLite database into an unnecessarily large collection of millions of dense telemetry rows while keeping every recording indexed and manageable.

Default Data Locations

Windows

%APPDATA%\RaceX\

macOS

~/Library/Application Support/RaceX/

Linux

~/.local/share/RaceX/

The directory is structured approximately like this:

RaceX/
├── activities.db
├── activities.db-wal
├── activities.db-shm
└── telemetry/
    ├── <session-id>/
    │   ├── <lap-telemetry-file>
    │   ├── <lap-telemetry-file>
    │   └── ...
    └── <another-session-id>/
        └── ...

Important

Create a backup before modifying the database directly. The database schema may evolve while SimTelemetry is under active development.

SQLite Database

The main database is:

activities.db

You can open it using:

DB Browser for SQLite
SQLite CLI
Python
Node.js
Rust
Any SQLite-compatible application

Main Tables

`sessions`

Stores general information about each recorded session.

Common fields include:

Simulator
Track name
Track configuration
Track length
Session type
Car
Car class
Series
Start and end time
Data source
Simulator-specific metadata

`lap_times`

Stores timing and summary information for each lap.

Common fields include:

Lap number
Lap time
Sector times
Validity
Overall position
Class position
Fuel at lap start
Tire compound
Pit status
Out-lap status
Incident count
Completion time

`activities`

Stores event-based information captured during a session.

Examples include:

Incidents
Flags
Position changes
Important session events
Player-related events
Simulator-specific activity data

`telemetry_files`

Indexes the high-frequency telemetry files stored on disk.

It contains information such as:

Session ID
Lap number
Relative file path
File size
Sample count
Start time
End time
Recording source

The dense telemetry samples themselves are stored in the referenced local files rather than directly inside the database.

Quick Start

1. Install SimTelemetry

Download the desktop recorder from:

https://simtelemetry.site

2. Start a Supported Simulator

Launch:

Assetto Corsa
Le Mans Ultimate
rFactor 2

SimTelemetry will detect the active simulator and wait for a live session.

3. Drive

Your session, laps, and telemetry will be recorded automatically.

4. Open Your Local Data

Open the RaceX data directory and locate:

activities.db

5. Query Your Sessions

sqlite3 activities.db

Then run:

SELECT
    id,
    sim,
    track_name,
    session_type,
    car_name,
    started_at
FROM sessions
ORDER BY started_at DESC
LIMIT 10;

SQL Examples

Find Your Fastest Valid Laps

SELECT
    sessions.track_name,
    sessions.car_name,
    lap_times.lap_number,
    lap_times.lap_time
FROM lap_times
JOIN sessions
    ON sessions.id = lap_times.session_id
WHERE lap_times.is_valid = 1
  AND lap_times.lap_time IS NOT NULL
ORDER BY lap_times.lap_time ASC
LIMIT 20;

List Every Lap from a Session

SELECT
    lap_number,
    lap_time,
    sector1,
    sector2,
    sector3,
    is_valid,
    incident_count
FROM lap_times
WHERE session_id = 'YOUR_SESSION_ID'
ORDER BY lap_number ASC;

Find Your Fastest Lap by Track and Car

SELECT
    sessions.track_name,
    sessions.car_name,
    MIN(lap_times.lap_time) AS best_lap
FROM lap_times
JOIN sessions
    ON sessions.id = lap_times.session_id
WHERE lap_times.is_valid = 1
  AND lap_times.lap_time IS NOT NULL
GROUP BY
    sessions.track_name,
    sessions.car_name
ORDER BY best_lap ASC;

Count Recorded Sessions by Simulator

SELECT
    sim,
    COUNT(*) AS session_count
FROM sessions
GROUP BY sim
ORDER BY session_count DESC;

Find Telemetry Files for a Session

SELECT
    lap,
    file_path,
    file_size,
    sample_count,
    start_time,
    end_time
FROM telemetry_files
WHERE session_id = 'YOUR_SESSION_ID'
ORDER BY lap ASC;

Local Telemetry API

SimTelemetry includes a local HTTP server for accessing recorded data without manually decoding the compact telemetry files.

The default address is:

http://127.0.0.1:4061

The port can be changed in SimTelemetry preferences.

Available Endpoints

GET /api/sessions
GET /api/sessions/{session_id}
GET /api/sessions/{session_id}/laps
GET /api/sessions/{session_id}/laps/{lap_number}/telemetry
GET /api/sessions/{session_id}/extended
GET /api/sessions/{session_id}/extended/summary
GET /api/sessions/{session_id}/standings
GET /api/sessions/{session_id}/insights

List Recorded Sessions

curl http://127.0.0.1:4061/api/sessions

Get the Laps from a Session

curl http://127.0.0.1:4061/api/sessions/SESSION_ID/laps

Load Telemetry from a Lap

curl http://127.0.0.1:4061/api/sessions/SESSION_ID/laps/3/telemetry

A telemetry response can contain channels such as:

{
  "session_time": 128.35,
  "track_pct": 0.427,
  "lap": 3,
  "throttle": 0.82,
  "brake": 0.0,
  "clutch": 0.0,
  "steering": -0.14,
  "gear": 4,
  "speed_kmh": 176.4,
  "rpm": 6840,
  "fuel": 31.7,
  "world_x": 142.8,
  "world_y": -91.4,
  "lat_g": 1.21,
  "lon_g": 0.18
}

Field availability may vary by simulator and recording format.

Python Example

Use Python’s built-in SQLite support to analyze your recorded history.

import os
import sqlite3
import sys
from pathlib import Path


def get_racex_data_directory() -> Path:
    if sys.platform == "win32":
        return Path(os.environ["APPDATA"]) / "RaceX"

    if sys.platform == "darwin":
        return Path.home() / "Library" / "Application Support" / "RaceX"

    return Path.home() / ".local" / "share" / "RaceX"


database_path = get_racex_data_directory() / "activities.db"

if not database_path.exists():
    raise FileNotFoundError(f"SimTelemetry database not found: {database_path}")

connection = sqlite3.connect(database_path)
connection.row_factory = sqlite3.Row

query = """
SELECT
    sessions.track_name,
    sessions.car_name,
    lap_times.lap_number,
    lap_times.lap_time
FROM lap_times
JOIN sessions
    ON sessions.id = lap_times.session_id
WHERE lap_times.is_valid = 1
  AND lap_times.lap_time IS NOT NULL
ORDER BY lap_times.lap_time ASC
LIMIT 10
"""

for lap in connection.execute(query):
    print(
        f"{lap['track_name']} | "
        f"{lap['car_name']} | "
        f"Lap {lap['lap_number']} | "
        f"{lap['lap_time']:.3f}s"
    )

connection.close()

JavaScript Example

Load telemetry from the local API:

const sessionId = "YOUR_SESSION_ID";
const lapNumber = 3;

const response = await fetch(
  `http://127.0.0.1:4061/api/sessions/${sessionId}/laps/${lapNumber}/telemetry`,
);

if (!response.ok) {
  throw new Error(`Failed to load telemetry: ${response.status}`);
}

const telemetry = await response.json();

console.log(`Loaded ${telemetry.length} telemetry samples.`);
console.log(telemetry[0]);

What Can You Build?

Lap Comparison Tools

Overlay two or more laps and compare:

Speed
Throttle
Brake
Steering
Gear
RPM
Time delta
Racing line

Braking Analysis

Measure:

Initial braking point
Maximum brake input
Trail-braking duration
Brake release smoothness
Speed at turn-in

Racing-Line Analysis

Use vehicle coordinates to visualize:

Entry line
Apex position
Track usage
Exit line
Differences between laps

Consistency Analysis

Calculate:

Average lap time
Standard deviation
Sector consistency
Invalid-lap frequency
Incident frequency
Performance over a stint

Fuel and Tire Analysis

Explore:

Fuel consumption per lap
Estimated remaining laps
Tire temperature changes
Tire pressure changes
Tire wear across a stint
Pace degradation

AI Racing Coach

Telemetry can be used to build an AI assistant that explains:

Where time was lost
Which corners need attention
Whether braking was too early
Whether throttle application was delayed
How driving changed across a stint
Which lap should be used as the reference

Race Engineer Dashboards

Build local dashboards for:

Fuel strategy
Tire condition
Session progress
Lap history
Driver consistency
Vehicle health
Weather changes

Example Analysis Workflow

1. Record a session with SimTelemetry
                 ↓
2. Find the session in activities.db
                 ↓
3. Select two valid laps
                 ↓
4. Load telemetry through the local API
                 ↓
5. Align samples by track position
                 ↓
6. Calculate time delta
                 ↓
7. Compare braking, throttle and speed
                 ↓
8. Visualize where time was gained or lost

Telemetry Channels

Timing

Session time
Lap number
Lap time
Sector times
Track position percentage

Driver Input

Throttle
Brake
Clutch
Steering
Gear

Vehicle

Speed
RPM
Fuel
Vehicle position
Track-edge distance

Motion

Lateral G-force
Longitudinal G-force
World coordinates

Extended Data

When exposed by the simulator:

Individual tire temperatures
Individual tire pressures
Tire wear
Brake temperatures
Suspension travel
Ride height
Engine temperature
Brake bias
ABS
Traction control
Energy deployment
Weather
Damage
Standings

Repository Structure

SimRacingTelemetry/
├── README.md
├── LICENSE
├── CONTRIBUTING.md
├── docs/
│   ├── getting-started.md
│   ├── storage-architecture.md
│   ├── sqlite-database.md
│   ├── local-api.md
│   ├── telemetry-channels.md
│   └── supported-simulators.md
├── examples/
│   ├── sql/
│   │   ├── fastest-laps.sql
│   │   ├── session-history.sql
│   │   └── telemetry-files.sql
│   ├── python/
│   │   ├── list_sessions.py
│   │   ├── compare_laps.py
│   │   └── plot_telemetry.py
│   └── javascript/
│       ├── fetch-sessions.js
│       └── fetch-lap-telemetry.js
├── tools/
│   └── README.md
├── sample-data/
│   └── README.md
└── assets/
    ├── banner.png
    ├── local-viewer.png
    └── lap-comparison.png

Roadmap

Documentation

Explain the local storage architecture
Document the main SQLite tables
Document the local API endpoints
Publish the complete telemetry-channel reference
Add simulator-specific channel documentation
Add database migration notes

Examples

Tools

Documentation

More detailed guides will be available under the docs directory:

Getting started with SimTelemetry
Understanding the RaceX data directory
Querying activities.db
Loading high-frequency telemetry
Building a lap-comparison tool
Working with simulator-specific data
Protecting and backing up recordings

Contributing

Contributions are welcome.

You can help by adding:

SQL queries
Python examples
JavaScript examples
Data visualizations
Telemetry-analysis algorithms
Simulator documentation
Sample dashboards
Bug reports
Feature ideas

Contribution Workflow

Fork this repository.
Create a branch:

git checkout -b feature/**

Make your changes.
Add documentation or examples.
Open a pull request explaining the use case.

Note

This repository contains open documentation, examples, and community tooling. The SimTelemetry desktop application is maintained separately and may use a different license.

Privacy and Data Ownership

SimTelemetry records sessions locally first.

Your local RaceX directory contains the session database and recorded telemetry files used by the application.

Cloud synchronization is configurable and separate from local recording.

You can:

Inspect your session history
Back up your data directory
Query the SQLite database
Access telemetry through localhost
Build personal analysis tools
Delete local sessions
Move recordings between your own systems

Avoid publishing telemetry recordings that contain personal, league, or private-session information without permission.

Frequently Asked Questions

Is SimTelemetry open source?

This repository contains open documentation, examples, and community tools for working with sim-racing telemetry.

The SimTelemetry desktop application is distributed separately.

Is all telemetry stored directly in SQLite?

Session information, lap times, activities, and telemetry-file references are stored in SQLite.

High-frequency telemetry samples are stored in compact local files and can be loaded through SimTelemetry’s local API.

Does SimTelemetry require an internet connection?

Local recording and local analysis are designed to work from data stored on your computer. Some account, update, or optional synchronization features may require internet access.

Can I use the data in Python?

Yes. Query session and lap metadata using SQLite, then retrieve high-frequency telemetry through the local API.

Can I build my own dashboard?

Yes. The localhost API can be used by personal dashboards, scripts, notebooks, and other local applications.

Can I modify the SQLite database?

You can inspect and query it directly. Create a backup before making modifications because the schema may change during development.

Can I contribute support for another simulator?

Community research, documentation, channel mappings, and analysis examples are welcome. Integration into the SimTelemetry application is managed separately.

Disclaimer

This project is an independent community resource and is not affiliated with, endorsed by, or sponsored by the developers or publishers of any supported racing simulator.

Simulator names and trademarks belong to their respective owners.

Telemetry availability and accuracy depend on the data exposed by each simulator.

License

The documentation and example code in this repository are available under the MIT License unless otherwise stated.

The SimTelemetry application is a separate product and is not automatically covered by this repository’s license.

Contact and Community

Website: simtelemetry.site
Issues: Report documentation problems or request examples through GitHub Issues
Discussions: Share telemetry projects, analysis ideas, and community tools

Start Recording Your Telemetry

Automatically record compatible sim-racing sessions and keep your data available locally.

Get SimTelemetry →

Built for sim racers, developers, data analysts, and anyone who wants to understand what happens behind the lap time.

Star this repository if you find it useful. ⭐

Name		Name	Last commit message	Last commit date
Latest commit History 2 Commits
LICENSE		LICENSE
README.md		README.md

Folders and files

Latest commit

History

Repository files navigation

🏁 SimRacingTelemetry

Open tools, documentation, and examples for sim-racing telemetry

Overview

Project in Development

Why Sim-Racing Telemetry?

Driver Inputs

Vehicle Performance

Lap Analysis

Extended Vehicle Data

Record Telemetry with SimTelemetry

Your simulator data, recorded automatically.

Supported Simulators

How It Works

Local-First Storage

Default Data Locations

Windows

macOS

Linux

SQLite Database

Main Tables

sessions

lap_times

activities

telemetry_files

Quick Start

1. Install SimTelemetry

2. Start a Supported Simulator

3. Drive

4. Open Your Local Data

5. Query Your Sessions

SQL Examples

Find Your Fastest Valid Laps

List Every Lap from a Session

Find Your Fastest Lap by Track and Car

Count Recorded Sessions by Simulator

Find Telemetry Files for a Session

Local Telemetry API

Available Endpoints

List Recorded Sessions

Get the Laps from a Session

Load Telemetry from a Lap

Python Example

JavaScript Example

What Can You Build?

Lap Comparison Tools

Braking Analysis

Racing-Line Analysis

Consistency Analysis

Fuel and Tire Analysis

AI Racing Coach

Race Engineer Dashboards

Example Analysis Workflow

Telemetry Channels

Timing

Driver Input

Vehicle

Motion

Extended Data

Repository Structure

Roadmap

Documentation

Examples

Tools

Documentation

Contributing

Contribution Workflow

Privacy and Data Ownership

Frequently Asked Questions

Is SimTelemetry open source?

Is all telemetry stored directly in SQLite?

Does SimTelemetry require an internet connection?

Can I use the data in Python?

Can I build my own dashboard?

Can I modify the SQLite database?

Can I contribute support for another simulator?

Disclaimer

`sessions`

`lap_times`

`activities`

`telemetry_files`