Introducing The Open Racing Setup Format (ORSF)

Over the past few months, I've been working on a common format for racing car setups. It’s called ORSF — the Open Racing Setup Format — and it’s something that grew out of necessity while building Raceday, the app for simracing teams to get organized and ready for race day.

If you’ve ever tried to move setups between games, share them across teammates, or even just keep your own notes consistent, you’ll know the pain: every simulator has its own way of representing car setups, each with slightly different names, units, and structures. Sometimes you can export a file, sometimes you can’t. Sometimes it’s plain text, sometimes it’s binary. And when you switch to another sim, you start from scratch.

ORSF is meant to solve that in a minimal, open, and future-proof way.

What ORSF is

ORSF is a simple, human-readable JSON schema that describes a racing car setup.

It defines common sections like tires, suspension, aero, and drivetrain, with consistent naming and data types. Each setup also includes a meta block — the game, car, schema version, and optional notes.

Here’s a tiny example (simplified):

That’s it — no fancy encoding, no extra dependencies. You can diff it, version it, or store it alongside telemetry and notes.

Our open source release today includes code for Swift (what we use in Raceday) and C++, for developers to adopt into their game if they do so desire.

How Raceday uses it

Inside Raceday, ORSF is the backbone of how we handle car setups and produce an interface for version history, tracking changes and rolling back to specific versions.

When you upload or create a setup, it’s stored in this format.

It doesn’t matter if it came from Assetto Corsa Evo, iRacing, or Le Mans Ultimate — Raceday maps the native format to ORSF so we can treat them the same way.

That lets us do a few things easily:

• Compare setups between sessions, drivers, or games

• Share setups with teammates without losing precision

• Track changes over time, like a version history

• Match the library with the event, so you can reference which setups were used in each session

On the technical side, Raceday uses a small set of “adapters” that read or write the native format of each simulator. Those adapters translate to and from ORSF. It’s similar to how OpenTelemetry normalizes metrics — the data stays local and private, but follows a shared contract.

We have yet to make our own adapters as correct import/exports happen once we get to test thoroughly with a given game. We have approached some of the game studios from properties mentioned above and will try to get official support from them.

Why open

We decided to make ORSF open because it’s better for everyone if this is not a Raceday-only format.

If you’re building your own telemetry tool, a car setup viewer, or even a modding utility, you should be able to use the same schema without depending on us. It’s lightweight enough to embed anywhere, and versioned so it won’t break when we add new parameters later.

It’s also an easy bridge for game studios who want to make their sims more accessible. Supporting ORSF export or import means their players can use community tools like Raceday (or anything else that implements it) without needing custom plugins or parsers. We’ve already built a few example adapters, and we’re keeping them open-source for others to extend.

For simracers

For individual simracers, ORSF mainly means your setups become portable.

You can:

• Keep all your setups — across games and seasons — in one consistent format

• Compare old setups without worrying about how the sim called each variable

• Add notes or telemetry summaries right in the file

• Share a single .orsf file with your engineer, teammate, or Discord community, and they’ll be able to read it easily

  
  

We’re building some tools around this (like a Setup Notebook app) that can even extract setups from screenshots, merge them with notes, and output a ready-to-share .orsf file. But the idea is that anyone could build their own tools using the same schema.

For studios

If you’re building or supporting a racing simulation, the Open Racing Setup Format (ORSF) offers a lightweight, open-spec way to make your car setups interoperable.

You don’t need to overhaul your game's internal setup format- you only need to expose (or consume) a simple import/export layer that speaks ORSF. It’s JSON-based, human readable, with clear schema versioning and typed fields.

Because the release today includes reference adapters and SDKs (including C++ and Swift) in the repo, we’ve eased the integration path. You can drop in our C++ implementation (or build your own) as a library or module, generate valid .orsf files, validate them and convert to/from your internal format. You can even test these workflows with the examples provided.

Once you support ORSF, your players and partner tools (analytics, telemetry, setup sharing platforms) can integrate more easily—and you open up the possibility of ecosystem-wide tools and services that expect a standard format. While you retain full control of your own format internally, embracing ORSF means less friction when players switch titles, when teams use third-party tools, or when leagues and creators want to share setups.

If you’d like partnership-level support, naming rights, or custom validation for your simulator, we’d be glad to discuss collaboration.

Where it’s going

ORSF is still evolving. Right now we’re focusing on:

• Expanding the schema to cover hybrid and electric drivetrains

• Adding metadata for weather, track temperature, and tire wear

• Improving adapters for major sims (AC Evo, LMU, iRacing)

• Building a validation tool so studios can check compatibility automatically

Everything is made available in an open repo so others can fork, extend, or comment on it.

Closing thoughts

This isn’t about locking anyone into Raceday or inventing a new format just for fun. It’s about making setups portable, transparent, and shareable- this means racers, engineers, and developers can focus on improving the craft, not fighting with file formats.

If you’re building something that touches racing setups — whether it’s a sim, a telemetry logger, or a coaching app: feel free to use ORSF.

And if you spot something missing, tell us. We’re building it in the open so we can all make better tools together.

You can find the code here:

👉 Access the repo

-Mariano.