rpqueiroz/gt7-trial-mountain-962c

GT7 Telemetry — Porsche 962 C '88 at Trial Mountain

60 Hz vehicle telemetry captured from the Gran Turismo 7 UDP broadcast during a single 15-lap stint: a Porsche 962 C '88 Group C prototype (GT7 category Gr.1) around Trial Mountain Circuit. Decoded into Parquet and aligned to a distance-based track model.

Unlike most public sim-racing data, this release is not a raw packet dump: the frames are decoded and typed, every lap is resampled onto a common distance grid so laps can be compared point-for-point, and the track is segmented into straights and corners with measured radii.

At a glance

Source	Gran Turismo 7 telemetry UDP broadcast (packet_type = C)
Sampling rate	60 Hz (dt ≈ 0.01667 s)
Vehicle	Porsche 962 C '88 — Group C prototype, Gr.1, car_code = 3373
Drivetrain	5-speed, turbocharged (f_has_turbo), peak boost ≈ 1.09 bar
Track	Trial Mountain Circuit (Gran Turismo original), reverse direction not used
Laps	15 timed + 1 out-lap
Frames	95,796
Columns	113
Lap times	1:43.712 (best) – 1:49.670 (first timed lap)
Top speed seen	271.1 km/h
Conditions	dry, constant, no traffic; TCS on, ASM off
Size	~29 MB

Fuel decreases monotonically across the stint (100.0 → 77.0 L) and tyre temperatures evolve with it, so the stint is a usable subject for degradation and consistency studies, not only single-lap analysis.

Calibration against external references

Reference values here come from community databases and published specifications of the real car, not from Polyphony Digital. They are included so users can judge fidelity for themselves — including where the numbers disagree.

Quantity	External reference	Measured here	Reading
Wheelbase	2,770 mm (real Porsche 962)	2,769.5 mm (wheelbase)	Agrees to 0.5 mm. Strong signal that the packet reports the modelled geometry faithfully.
Lap length	5,434 m (centreline)	5,079–5,106 m (distance_m)	Driven distance, not centreline. The racing line runs ~6.4 % shorter. Do not use this dataset as a source for track length.
Corner count	15 (community count)	10 segments	A segmentation choice, not a contradiction — see below.
Elevation change	58 m	38.5 m (pos_y range)	Unresolved. Different measurement bases are the likely cause; treat neither figure as authoritative.

On the corner count. The 10 corners in track.json come from thresholding path curvature, so a complex of linked turns becomes one segment: C1 spans 400 m at a 36 m minimum radius, and C8 spans 330 m at 112 m. The segmentation is reproducible and consistent across all 15 laps, which is what the per-sector analysis needs, but the segment IDs here do not map onto any canonical corner numbering for Trial Mountain. Treat C1–C10 as identifiers local to this dataset.

On the track map. Trial Mountain's defining feature is elevation — it climbs and descends through tunnels — and a 2D pos_x/pos_z plot discards all of it. Use pos_y when the vertical profile matters; braking and traction figures at the low point (s ≈ 2,220 m) and the crest (s ≈ 570 m) are not comparable to flat sections.

The three tables

1. telemetry — raw frames

One Parquet file per lap (data/laps/lap_NNN.parquet), 113 columns at 60 Hz. The full decoded packet plus a small set of derived fields. Use it when you need the true time domain: transients, brake-release shapes, gear-shift dynamics.

2. grid — distance-resampled

data/grid.parquet, 15,270 rows = 15 laps × 1,018 grid points, one point every 5 m of lap distance, 32 columns. Every lap sits on the same x-axis, so grid.pivot(index="s_m", columns="lap", values="speed_kmh") gives a directly comparable speed-trace matrix. This is the table most analyses should start from.

3. sectors — per-lap × per-sector aggregates

data/sectors.parquet, 300 rows = 15 laps × 20 sectors, 30 engineered features: sector time, entry/exit/minimum speed, peak and mean brake, fraction of the sector at full throttle / coasting / trail-braking, peak lateral and longitudinal g, peak slip ratio (front and rear), peak steering, frames off-track, frames with TCS intervention, and the corner geometry markers — where braking started relative to turn-in (brake_before_turn_in_m), where the apex fell (apex_at_m), and where throttle was reapplied (throttle_at_m).

data/track.json holds the track model: total length, 5 m step, and for each sector its type, direction, start/end distance, and minimum radius.

Column notes that matter

Three things will bite anyone who assumes the obvious:

Rotation is a quaternion, not Euler angles. The fields named rot_pitch, rot_yaw, rot_roll and orientation_north are the four components of a unit quaternion — verified here, they sum in quadrature to 1.000 on every frame. The names come from the community's early reverse-engineering of the packet and are a misnomer kept for compatibility. Convert to Euler angles before interpreting them as attitude.

throttle and brake are raw bytes, 0–255, not percentages. Divide by 2.55 for percent. throttle_filtered / brake_filtered are the game's smoothed versions.

wheel_rps_* is signed and negative when moving forward. The sign convention is inherited from the packet. slip_* is derived here as wheel surface speed over vehicle speed: 1.0 is no slip, >1.0 is wheelspin, <1.0 is lockup.

Other units: pos_x/y/z in metres in world coordinates with y up; speed_ms in m/s (speed_kmh derived); tyre_temp_*, water_temp, oil_temp in °C; susp_height_*, tyre_radius_*, body_height, wheelbase in metres; boost where value − 1 ≈ bar; fuel_level/fuel_capacity in litres; day_progression_ms is time of day, not elapsed time; surface_* decoded to tarmac / curb / grass; distance_m is cumulative distance within the lap; wall_time is the capture host's Unix clock.

sway, heave and surge are the packet's body-motion channels (lateral, vertical, longitudinal). Polyphony documents no units for them; magnitudes here are consistent with m/s², but treat that as an assumption rather than a fact. flags, energy_recovery and torque_vec_* are likewise community interpretations.

Quick start

from datasets import load_dataset

REPO = "rpqueiroz/gt7-trial-mountain-962c"

# lap-comparable speed traces
grid = load_dataset(REPO, "grid", split="train").to_pandas()
grid.pivot(index="s_m", columns="lap", values="speed_kmh").plot(legend=False, alpha=.5)

# which corners cost the most time, lap to lap
sec = load_dataset(REPO, "sectors", split="train").to_pandas()
print(sec[sec.kind == "corner"].groupby("sector").time_s.std().sort_values(ascending=False))

Suggested tasks

• Lap-time prediction from a partial lap. Given the first k metres of grid, predict the final lap time. A well-posed small-n regression problem with a real answer key.
• Point of no return. For each corner, find the distance before turn-in after which the outcome (clean vs. off-track / lockup) is already determined by the state. The baseline below does exactly this.
• Traction-loss detection. Label frames from off_track, f_tcs, f_rev_limiter and the slip_* channels, then detect them from the preceding window. In this stint front-wheel lockup under braking is far more common than wheelspin on exit, so the labels concentrate on corner entry - a Group C car with 1980s brakes and no ABS in Gr.1 trim.
• Driver consistency. The stint improves monotonically from 1:49.6 to 1:43.7 — model the learning curve and separate it from the fuel-load effect.
• Fuel and tyre degradation. Fuel falls 23 L over the stint; recover its effect on sector times against the confound of the driver getting faster.

Baseline analysis

An interactive baseline runs as a Space: rpqueiroz/gt7-point-of-no-return. For each corner it computes the per-metre probability of an error within the next second against the distance still available to react, with the slip thresholds that define an "error" exposed as sliders, so the parameter sensitivity is visible rather than hidden.

Result on this stint: lockup dominates. Roughly 3 in 4 events are front-wheel lockup under braking, not loss of traction on exit. The two tightest corners concentrate nearly all of it: C9 at 27 m radius shows errors on 15 of 15 laps, C6 at 36 m on 13 of 15. Corners with a radius above ~110 m produce none.

Offered as a baseline to beat, not a validated finding: n = 15 laps, one driver, one car, one track. At extreme threshold values the ranking changes, which the Space lets you check directly. Source code: the capture and analysis repository.

Limitations — read before using

• One driver, one car, one track, one session. Nothing here supports claims that generalise beyond it. A case study and a testbed, not a population sample.
• n = 15 laps. Enough for within-stint time-series work; not enough to fit anything with meaningful capacity without severe overfitting.
• Simulation, not a real vehicle. GT7's physics is good and the geometry checks out to the millimetre, but it is a model. Do not treat tyre, suspension, or aero-derived quantities as measurements of a real 962.
• Driver skill is a confound everywhere, and it is correlated with fuel load and tyre state because all three move monotonically through the stint.
• Out-lap included. lap_000 is 163 m of pit exit with last_lap_ms = -1; exclude it from timed analysis.
• The lap boundary is the packet's, not a transponder's. Lap distances spread over 5,079–5,106 m (~0.5 %) because the frame nearest the line is up to 16.7 ms off it. Do not read distance differences below ~1 m as signal.
• Sector IDs are local to this dataset and do not follow any canonical Trial Mountain corner numbering.

Provenance

Captured by the dataset author from their own PlayStation 5 by listening to the GT7 telemetry UDP broadcast on the local network — the same public interface used by third-party dashboards and lap timers. No game assets, code, audio, or imagery are included or redistributed; the dataset contains only numeric measurements of vehicle state, plus the derived tables described above. No player identifiers, account names, or network addresses are present.

The CC-BY-4.0 licence applies to the dataset author's own contribution: the decoding, the derived channels, the track model, and the aggregate tables. "Gran Turismo" is a trademark of Sony Interactive Entertainment and "Porsche" of Dr. Ing. h.c. F. Porsche AG; this dataset is unofficial and unaffiliated with either.

Capture and processing code: https://github.com/RicardoXQueiroz/gt7-trial-mountain-962c

Citation

@misc{gt7_trial_mountain_962c,
  title  = {GT7 Telemetry: Porsche 962 C '88 at Trial Mountain},
  author = {Ricardo Queiroz},
  year   = {2026},
  url    = {https://huggingface.co/datasets/rpqueiroz/gt7-trial-mountain-962c}
}