Free Practice | The Undercut Wiki

Free Practice is a 45-minute session, and it is the single most productive hour of your weekend. It measures the fuel and tyre-wear numbers every later screen depends on, it is the only place where trait investigation runs at full rate, it converts laps into permanent part potential, and it hands both drivers a temporary pace boost for qualifying and the race.

It also costs you real parts: practice damage is written straight back into your inventory.

How to open it

Practice is weekend step 0. The flow is Weekend Loadout → Practice Plan → session → weekend repair → Qualifying Run Plan.

The plan screen is the only weekend screen with a working Back button (returns to the Hub; Go Racing re-opens it). Once practice completes, the weekend is committed — the qualifying and race run plans have no Back.

Since 0.5.2 the same screen also runs Pre-Season Testing (see the last section).

Building a run plan

Two driver columns, one per car you are fielding. A driver takes part if they are bound to a car (assigned_car), not because of their role — a Reserve with no car has no column.

Each driver gets 1 to 3 runs (Runs: n/3, + / −). Per run:

Field	Options	Default
Type	Quali Sim / Race Sim / Dev	Race Sim then Quali Sim
Tire	Soft (S) / Hard (H)	Hard for Race Sim, Soft for Quali Sim
Pace	Conservative / Standard / Attack	Standard
Laps	1 – 25	10 (Race Sim / Dev), 4 (Quali Sim)
Target (Dev runs only)	one of the 11 components	Engine
Focus (non-Dev, only if something is suspected)	— / Problem 1 … Problem N	—

Switching the type resets the lap count to that type’s default, so set the type first.

Pace, not engine map

Since 0.5.2 you pick a pace and the engine map is derived from it (PaceMode::initial_map): Conservative → 4, Standard → 5, Attack → 6. Pace also bounds what the AI director may do with the map during the run (Conservative 1–6, Standard 1–10, Attack 5–10) and multiplies the driver’s mistake probability by 0.95 / 1.00 / 1.05.

How the plan reaches the cars

Each PracticeRun becomes one QualifyingRun on that car’s session plan, staged across the 45 minutes (segment = 2700 / (n_runs + 1), run i going out at segment × (i + 0.5)), carrying its own compound, engine map and pace. The first run’s compound/map/pace are also written directly onto the car, because the very first pit exit doesn’t pass through the apply-at-pit-out transition.

This matters: without that wiring the plan is cosmetic. It is wired — what you set is what runs.

Run types

Race Sim

Longer stint, race fuel, race compound. Produces the fuel-per-lap and tyre-wear-per-lap numbers for the compound you run it on, and feeds race_pace stint accrual.

Its measurements are what the run plans, the pit-strategy generator and the in-race AI EV pit model all consume. A weekend with no Race Sim laps on the racing compound leaves the strategy planner guessing from a track-length estimate.

Quali Sim

Short, light, push. Produces best-lap and top-speed reference, and feeds quali_pace accrual at nearly twice the race rate.

Dev (Development Program)

Laps devoted to one component. No pace data — a Dev run contributes nothing to stint boosts. What it buys is permanent potential head-room.

Development programs

At the practice-done transition, apply_development_programs runs once per weekend for the player and every AI team.

Gain in R&D display points, per program:

points = dev_program_max_points
       × min(1, laps / dev_program_laps_ref)
       × ((1 − w) + w × intelligence / 20)      // w = dev_program_intel_weight

Defaults (Settings → Career, “Practice” group):

Slider	Default	Range
`dev_program_max_points`	5.0	0 – 10
`dev_program_laps_ref` (laps for max)	15	5 – 30
`dev_program_intel_weight`	1.0	0 – 1

At the defaults the intelligence weight is total: a program is worth 5 × min(1, laps/15) × INT/20 points. A 15-lap program with an INT 20 driver gives the full 5.0 points; the same program with INT 10 gives 2.5; an 8-lap program with INT 15 gives 5 × 0.533 × 0.75 = 2.0.

Laps beyond 15 are wasted — the lap fraction is capped at 1.

Where the gain lands:

gain = points × 0.16 / 100 on the perf multiplier scale.
It is added to stats.potential on every inventory part of that component sharing the version fitted on that driver’s car — including your spares.
It is added to the matching KnownDesign, so future production and emergency replacements of that blueprint inherit it.
Everything is capped at the sim’s potential ceiling, 1.18.

A summary email lists each program’s driver, component, version and the points actually applied. The head-room shows up as hatched space on the Improve bar — a Dev program does not raise performance, it raises the ceiling you can then pay work units to reach.

If no part of that component is fitted on the driver’s car, the program is silently skipped (there is no version to anchor to).

AI teams run the same formula on their fitted part and its same-version copies (no designs — AI production reads inventory directly).

Trait investigation

Hidden car traits are learned by kilometres. Practice is the high-rate channel.

Per-session multiplier (Settings → Career, “Traits” group):

Session	Default multiplier
Practice	0.30
Qualifying	0.08
Race	0.06

Accrual for one trait on one car:

gain = slot_km × (1 + INT/20) × session_mult × dilution × focus_mult
dilution = 1 / (1 + trait_dilution × (undiscovered_on_this_car − 1))     // k = 0.5

Thresholds are per trait kind (trait_km_*, roughly 90–140 km). A trait becomes Suspected at trait_suspected_fraction × threshold (default 0.15) and Discovered at the full threshold. Engine balance (white) traits are known by default and never enter the pipeline — they don’t dilute either.

The Focus picker

Once a run’s car carries at least one suspected trait, non-Dev runs get a Focus row. It cycles — → Problem 1 → Problem 2 → … → —.

The label is deliberately anonymous: it never names the component or the trait kind, only a stable number, because naming either before the run would spoil the investigation. The badge is the same ”?” icon the Observations panel uses.

A focused run multiplies that trait’s accrual by trait_focus_mult, default 8.0 (Settings → Career, range 1–10). Combined with the practice multiplier that is 0.30 × 8 = 2.4 per km — roughly one dedicated session to confirm a trait, against 3–4 GPs of passive trickle.

Focus is per (component, trait) and collected across both drivers’ plans; duplicates are merged, so pointing both cars at the same problem does not double it.

The guaranteed suspicion per run

Km accrual alone is a dice roll against a threshold, so practice also has a floor: after the normal accrual, guarantee_practice_suspicions promotes up to N still-Unknown fitted traits to Suspected, where N = the number of runs you planned across both drivers (minimum 1). Candidates are ranked by accrued km — the most-run trait surfaces first — and each gets its km nudged up to the suspected line so the observation bars read correctly.

Confirmation is unaffected. The guarantee only creates ”?” marks; turning a ”?” into a named trait still needs the focused running.

In a live session the same thing happens one run at a time (guarantee_one_practice_suspicion) so the suspicion is announced on the HUD the moment it fires, instead of only appearing in the next session’s Observations panel. The emails are self-deduplicating: several suspicions in one session produce one unread “something feels off” notice.

More runs therefore means more suspicions surfaced. Three short runs per car surface up to six.

Stint boosts

Every driver on the grid — yours and the AI’s — banks a temporary weekend boost from their practice stints (compute_stint_boosts, applied at practice end and stored on the weekend plan).

Per planned lap:

Run type	Effect	Rate/lap
Quali Sim	`quali_pace`	0.09 × ada_f × map_f
Quali Sim	`driveability`	0.003 × int_f × map_f
Race Sim	`race_pace`	0.05 × ada_f × map_f
Race Sim	`driveability`	0.003 × int_f × map_f
Dev	nothing	—

with

ada_f = 0.4 + 0.6 × ADA/20      int_f = 0.4 + 0.6 × INT/20
map_f = 0.7 + engine_map × 0.06     (Conservative 0.94 · Standard 1.00 · Attack 1.06)

Caps: pace +2.0 (each of quali and race, separately), driveability +0.05 (i.e. +5 display points).

Applied by build_session_grid: the pace boost is rounded and added to the driver’s PAC for that session (clamped 1–22, so an elite driver can be pushed past the nominal 20), and familiarity_driveability is set on the car model. Practice itself gets no boost — that is where they are earned.

Practical read at the caps: with ADA 20 on Attack, 0.09 × 1.0 × 1.06 = 0.0954/lap, so about 21 Quali-Sim laps max out the qualifying boost; the race boost needs about 38 Race-Sim laps; driveability caps around 16 laps with INT 20. Since the plan allows 3 runs × 25 laps, a fully dialled-in weekend is reachable — at the cost of tyre and part wear, and with no Dev runs.

AI teams get their boosts from their own doctrine plans (see below), so skipping practice is a relative loss, not just an absolute one.

Live vs Simulate vs Quick Sim

Three buttons at the bottom of the plan screen.

Start Practice (live)

A playable qualifying-style session. Your cars are marked player-controlled, so the AI director does not auto-launch their out-laps: you launch each stint yourself from the Start Stint overlay.

The overlay lists your planned runs (type + laps, ✓ on those already launched, defaulting to the first not-yet-launched one) and lets you edit fuel, compound, hot laps (up to 15 in practice) and engine map before going out. The plan is a seed, not a straitjacket.

The live path also fires the trait-discovery radio calls and per-run suspicion announcements as they happen, and runs the first-time live HUD tutorial if you have not seen it (shared flag with qualifying, so it won’t repeat).

Simulate Practice (headless)

Multi-threaded. The field is split round-robin across your CPU cores into independent sim groups (num_groups = cpu_cores, capped at car count), each running its own RaceSim on a worker thread. Cars only interact with cars in the same group — traffic and tows across groups do not exist. practice_mode is on, which skips raycasts, crash collisions and replay recording.

You get a classification table, an events list and a minimap, then Continue to Qualifying. Per-driver fuel/wear/top-speed are aggregated from all groups into the same PracticeResult the live path produces.

Quick Sim (opt-in)

Hidden unless Settings → Career → Quick Sim is enabled. Resolves the entire session at lap granularity on the prepared grid — same plans, same part-wear formulas — then opens the Simulate screen already finished (loading bar → results → Continue).

All three paths converge on the same completion pass: damage write-back, trait accrual with focus, the per-run suspicion guarantee, development programs, stint boosts, and the weekend repair pool reset. Nothing is skipped by simulating.

Damage is real

apply_practice_completion calls collect_weekend_incidents and writes apply_race_damage_to_inventory for every car — yours and every AI team’s — using the driver’s car binding (seat_index), not their role. A Reserve’s damage is never charged to the Secondary’s car.

Consequences:

A practice crash can leave a fitted part below initial_perf × 0.5 — that car is DNS for the rest of the weekend unless you fix it.
The fix at the track is the weekend repair step that follows practice, or Swap spare with a part that travelled in the loadout. There is no buying and no rushing at a race weekend.
The weekend repair pool is reset here: weekend_wu_remaining = compute_wu_pool(engineering) / 5 — a fifth of the Engineering pool, separate from the annual R&D pool.
Incidents accumulated across practice, qualifying and race are reported in one weekend damage email after the race.

A fresh weekend clears the incident sheet at practice start, so an abandoned weekend cannot bleed its crashes into the next round.

AI practice doctrine

AI plans come from career_ai_practice, a pluggable per-team archetype registry (the same architecture as the AI finance models):

Archetype	Behaviour
RacePush	Long race stints on high maps, a sharp quali sim, full-map qualifying
Mixed	Balanced race + quali stints, mid maps
Development	Practice time spent on development programs at moderate maps
Reliability	Few short stints, low maps, conservative qualifying — forced whenever the team is financially weak (red-GP streak or thin budget)

Each model declares a risk budget and caps every driver’s engine map so the expected mistake rate stays inside it (risk_capped_map, mirroring the sim’s rate ∝ (1 − 0.8·CON/20) × (0.55 + 0.10·map)); a PAC ≥ 17 driver earns +1 map before the cap. Every decision passes through decide_with_error with an 8% chance of a deliberately sub-optimal pick, which keeps grids organic.

So a broke rival really does run fewer laps, and a development-minded rival really is banking potential instead of pace.

Pre-Season Testing (0.5.2)

A full free-practice session before the season, using this exact screen.

When: the moment the Car Review phase completes (all three cars built and fitted). The hub stepper node reads “Car & Testing”. It runs the loadout first, then the plan screen, then the session. No qualifying or race follows.
Where: a random calendar round, preseason_test_gp_idx — a deterministic hash of start_year, season and team_name, modulo the calendar length. Stable across reloads (the briefing mail, the plan card and the launched session always name the same venue) and it changes every season because the hash folds save.season.
Duration: the standard 45 minutes, same as a GP practice.
Gate: CareerSave.preseason_test_done is persisted and blocks leaving the Development phase. Backing out only postpones it. The flag is re-armed at the season rollover, so every pre-season gets its test day — before 0.5.2 it was never reset and season 2+ silently skipped the session.

Full practice effects apply: trait discovery with focus, development programs, stint boosts, and real inventory damage. What differs is that weekend_step is forced back to 0 (no GP weekend started, so the mid-weekend resume prompt cannot fire), the loadout lock is lifted immediately, and there is no weekend repair step.

Two mails bracket it:

Chief Engineer briefing when the test opens — what testing is for and the venue. Pushed at the Car Review transition so it is already in the inbox (deduplicated by subject, so later entry paths are no-ops).
Pre-season test report afterwards: per-driver best lap and top speed, your straight-line speed rank against every car that ran, an engineers’ cornering estimate (your team’s rank on aggregate front wing / rear wing / floor / suspension performance — “a guide, not a stopwatch”), and the list of suspected issues to investigate. Then the standard weekend damage report if anything broke — after which the incident sheet is cleared, since no race debrief will consume it.

The whole grid runs, so the field context in the report is real. It is also your first read on where the new car actually stands.

Advanced

Practice is the only cheap trait channel. 0.30 vs 0.06 in the race, and focus (×8) exists nowhere else. If you are hunting a problem, spend a whole session on it.
Dilution rewards clean cars. With 3 undiscovered traits on one car each accrues at 1/(1+0.5×2) = 0.5. As traits confirm, the survivors speed back up — so discoveries arrive staggered, and finishing an investigation accelerates the next one.
Dev laps are free potential, but they cost pace. Dev runs contribute zero stint boost. A Dev-heavy weekend is a bet on the rest of the season.
Fifteen laps is the Dev ceiling. Lap 16 of a development program does literally nothing.
Run the racing compound in a Race Sim. Fuel-per-lap and wear-per-lap are measured per compound. The race fuel calculation prefers the Hard measurement and the pit planner takes max(hard, soft) per car; with no Hard data the whole thing falls back to a track-length estimate.
More runs = more guaranteed suspicions. The floor is the count of planned runs, not the laps. Three 4-lap runs per car surface up to six ”?” marks; one 25-lap run surfaces one.
Simulate is not a penalty. The completion pass is identical. The only thing you lose is the live stint control and the ability to react to a crash mid-session.
The DNS check happens before the weekend, too. Go Racing warns about destroyed or badly worn fitted parts before you commit — practice will only make them worse.

Common mistakes

Planning only Quali Sims. No race fuel or wear data → the strategy generator and the AI pit EV model both fall back to estimates, and your race pace boost stays at 0.
Setting laps before the run type. Changing the type overwrites the lap count with its default.
Expecting a Dev program to raise performance. It raises potential. You still have to pay work units in R&D → Improve to convert it.
Focusing a run on a trait whose part is not fitted. The picker only offers investigable suspicions, but if you change the fitted part after planning, the focus points at a version you are no longer running.
Treating pre-season testing as optional. It gates the Development phase, and skipping it wastes a free 45 minutes of trait discovery and potential on a brand-new car.
Forgetting that AI teams practise too. Your stint boost is a relative advantage only if it is bigger than theirs.