AnalyzeRL Boxcars

Labelling and analyzing Rocket League replay data

AnalyzeRL Boxcars is a Rust package mounting the detection of events and player actions onto frame-wise Rocket League replay data parsed by the powerful boxcars library.

Requirements

• Rocket League .replay files
• The compiled Windows or Linux x86-64 binary from the repository's Releases page when using the CLI directly
• Python 3.10 or newer when using the Python API
• Rust 1.85 or newer only when building the binary from source

Parsing Pipeline

• Collect replay objects from boxcars
• Arrange frame-by-frame match dataframe
• Mount EventModel and obtain interpretable frame-level events in a match

Installation

Download analyzerl_boxcars.exe from the assets attached to the latest repository release. Building locally is optional:

cargo build --release

Install the Python package when using the Python API:

python -m pip install analyzerl-boxcars

The Windows and Linux x86-64 wheels include the matching Rust binary, so Python API users do not need to download it separately.

The examples below use the downloaded release binary:

$analyzerl = "C:\path\to\analyzerl_boxcars.exe"
$replay = "C:\path\to\match.replay"

Python examples use the binary bundled with AnalyzeRLBoxcars:

from pathlib import Path

from analyzerl_boxcars import AnalyzeRLBoxcars

analyzer = AnalyzeRLBoxcars(
    n_workers=1,
)
replay = Path(r"C:\path\to\match.replay")

Usage

Parse Without Writing Files

CLI

The CLI parses silently when --export is omitted:

& $analyzerl $replay

Python

The Python API returns the frame-wise Polars dataframe directly:

frames = analyzer.parse_replay(replay, event_tagging=False)

Export Frame Data to CSV

CLI

& $analyzerl $replay --export "C:\path\to\match.csv"

Python

analyzer.parse_replay(
    replay,
    event_tagging=False,
    export="csv",
    export_dir=Path(r"C:\path\to\exports"),
)

Export Frame Data to Parquet

CLI

& $analyzerl $replay --export "C:\path\to\match.parquet"

Python

analyzer.parse_replay(
    replay,
    event_tagging=False,
    export="parquet",
    export_dir=Path(r"C:\path\to\exports"),
)

Stream or Return Frame Data

CLI

The CLI streams Parquet bytes to stdout and writes status text to stderr:

& $analyzerl $replay --event-tagging true --export stdout

Python

The Python API uses the same stdout transport internally and returns a Polars dataframe without writing a file:

frames = analyzer.parse_replay(replay, event_tagging=True)

Mount the Event Model

CLI

& $analyzerl $replay --event-tagging true --export "C:\path\to\match.parquet"

Python

labelled_frames = analyzer.parse_replay(replay, event_tagging=True)

Apply the Event Model to Frame Data

Frame data parsed with event_tagging=False retains the replay-native signals needed to mount the same event model later. Existing event columns are overwritten.

CLI

& $analyzerl "C:\path\to\frames.parquet" --apply-event-model --export "C:\path\to\labelled.parquet"

Python

from analyzerl_boxcars import EventModel, apply_event_model

labelled_frames = apply_event_model(frames)
labelled_frames = EventModel().apply(frames)

The Python API streams Parquet between Polars and the bundled Rust binary in memory; it does not create an intermediate file.

Generate Play-by-Play Data

PBP output contains one row per event instance. Replay files and existing CSV or Parquet frame tables are supported.

CLI

& $analyzerl $replay --pbp --export "C:\path\to\pbp.parquet"
& $analyzerl "C:\path\to\frames.parquet" --pbp --export stdout

Python

pbp = analyzer.parse_replay(replay, pbp=True)
pbp = analyzer.parse_replay(Path(r"C:\path\to\frames.parquet"), pbp=True)

Each PBP row includes event_type, event_id, event_start_frame, event_end_frame, and the inclusive frame count in event_duration. Stats calculation accepts PBP CSV and Parquet files directly.

Calculate Stats From a Replay

CLI

& $analyzerl $replay --calc-stats --export "C:\path\to\stats.csv"

Python

stats = analyzer.calculate_stats(replay)

Calculate Stats From Frame Data

Both CSV and Parquet frame exports are valid stats inputs.

CLI

& $analyzerl "C:\path\to\frames.csv" --calc-stats --export "C:\path\to\stats.csv"
& $analyzerl "C:\path\to\frames.parquet" --calc-stats --export "C:\path\to\stats.parquet"

Python

csv_stats = analyzer.calculate_stats(Path(r"C:\path\to\frames.csv"))
parquet_stats = analyzer.calculate_stats(Path(r"C:\path\to\frames.parquet"))

Export Stats

CLI

The CLI infers CSV or Parquet from the output extension:

& $analyzerl $replay --calc-stats --export "C:\path\to\stats.parquet"

Python

The Python API selects the format with export and writes through the Rust binary:

analyzer.calculate_stats(
    replay,
    export="parquet",
    export_dir=Path(r"C:\path\to\exports"),
)

The CLI supports .csv and .parquet export paths. The special stdout target always emits Parquet bytes. Python calls with export=False return a Polars dataframe; calls with export="csv" or export="parquet" write files and return None.

Output

The parser returns a frame-wise dataframe with replay, frame, ball, team, event, and player column groups. Player columns are kept together as the final column group so wide exports remain easier to scan.

When --pbp is supplied, the CLI returns event-wise rows and removes the frame-level *_in_progress columns. When --calc-stats is supplied, the CLI returns one row per replay_id and player_id instead of frame-level rows. Stats use all measurements available in the supplied frame or PBP dataframe.

When an export path is supplied, the CLI prints:

Parsed {replay_id}

Documentation

Information on the events tracked in the package may be found here.

Full documentation coming soon.

License

AnalyzeRL Boxcars is closed-source, proprietary software. Copyright (c) 2026 Project Signal. All Rights Reserved. No permission is granted to use, copy, modify, or distribute the software except under a separate written agreement expressly authorized by Project Signal. See the proprietary license for complete terms.