LateBrake v0.5.96 — World-Scale Rounded Circuit (SOURCE-ONLY Pre-release)

LateBrake v0.5.96 — World-Scale Rounded Circuit and Continuous Road Geometry (SOURCE-ONLY Pre-release)

SOURCE-ONLY experimental GitHub pre-release. NOT a playable game build.
No compiled Win64 EXE, Windows installer, Android APK/AAB, authored/cooked Unreal .uasset or installed 3D game is included.
The automatically generated GitHub source ZIP/tarball archives are not installers.
This publication attaches zero executable binaries and zero game assets.

Immutable development snapshot

This version snapshots the exact verified head of
unmerged development draft PR #316,
not the protected default branch. Publishing this source snapshot does
not merge the draft PR, enable a new runtime race track or imply any working
UE5.8 hardware playtest. Previous source-only milestone:
v0.5.95.

3D track work since v0.5.95

• Add an original 1.70265-km world-scale rounded track profile with
  80-m-radius bends and 9-m physical road width, while retaining a
  separately tested 170-m original prototype. Never enlarge the vehicle,
  steering or road width by the 10x longitudinal world scale.
• Specify and numerically validate 68 collision-backed slab transforms
  for an independent editor-only prototype, including original z=-1 cm
  physical surface and a distinct original 8.5-m-wide 3D visual ribbon.
• Export original continuous 4,096-vertex / 8,192-triangle OBJ+MTL
  visual track models with lap-wrapped UV and independent Python/C++
  integrity verification. These material placeholders are not
  photorealistic original assets, shader graphs or collision meshes.
• Add an isolated -WorldScale Unreal Editor lab-authoring source
  workflow, with a separate lab map, original compiled C++ numeric
  JSON contract, source-byte SHA256 handoff, 68 BlockAll actor readbacks,
  physical width and heading checks and genuine Editor map save/reload
  verification requirements. This source workflow has NOT been exercised
  in an actual licensed Unreal Editor.
• Specify a new continuous 9-m-wide physical road collision-surface
  geometry candidate, top z=-1 cm and bottom z=-43 cm, with 1,024
  centreline cross-sections, closed 4,096-vertex / 8,192-face topology,
  smooth curvature/UV-independent physical vertices and a strict
  WorldScaleSmoothCollisionSurface C++ regression test. The shape
  is not registered with an Unreal BodySetup, not cooked, not a
  verified Chaos collision shape and not used in live gameplay.
• Tighten portable editor-candidate and source-art checks, including
  cross-platform floating-point tolerance, fail-closed geometry JSON,
  separate hash-linked receipts and Windows PowerShell syntax coverage.

Verification required before publishing

1. Exact source SHA and same-repository user-owned open draft PR #316,
   base main, unchanged branch, immutable source tag and matching release
   notes from the exact source commit.
2. All strict portable C++20 CTests on Windows, Ubuntu and macOS, including
   the full-width continuous surface, full-scale JSON and original OBJ
   geometry contracts.
3. Python independent editor-source/mock test suite and Unreal Python
   py_compile; no licensed UE5.8 compiler or renderer is present.
4. Windows PowerShell syntax and safe synthetic packaging/provenance checks.
5. Full MkDocs build with navigation validation, and a zero-assets
   pre-release publish audit.

Not yet playable — next mandatory gates

The experimental track is not connected to race scoring, checkpoint gates,
player/rival driving, AI spawns or career progression. Its 68 independent
collision slabs may produce poor tyre contact at seams; the newly specified
closed physical mesh is only a source-level geometry candidate.
Real UE5.8/UHT compilation, genuine editor-authored and cooked road assets,
a properly authored continuous Chaos collision body, tested materials and
3D vehicle models, realistic trackside art, performance/handling checks
at 30/60/120 FPS and an installed Win64 EXE plus installer remain unverified.
See playability gate #148.
Draft physics #295,
racing-line #297 and
surface-detail #313
are separate unmerged investigations.

SOURCE-ONLY — NOT a playable game build — zero executable binaries
and zero attached game assets. The older cartoon-like Win32 2D Controller
Edition is NOT this Unreal 3D racing game.

LateBrake v0.5.95 — Original Circuit Art Foundation (SOURCE-ONLY Pre-release)

LateBrake v0.5.95 — Original Circuit Surface and PBR Source Foundation (SOURCE-ONLY pre-release)

SOURCE-ONLY experimental GitHub pre-release. NOT a playable game build.
No compiled Win64 EXE, Windows installer, Android APK/AAB or installed 3D game is included.
GitHub-generated source ZIP/tarball archives are not installers.
This pre-release contains zero executable binaries and zero attached game assets.

Immutable source identity

This version snapshots the exact reviewed, independently portable-tested
unmerged development draft PR #313,
not the protected main branch. The draft PR stays open; publication does not
merge experimental art or claim that real Unreal Engine 5.8 compiled.
The previous immutable source-only milestone is
v0.5.94.

The publisher must reauthenticate the same-repository owner-created open
draft PR, its exact 40-hex commit SHA, matching release-note bytes and
all five independent source qualification jobs. It refuses retagging,
wrong previous-release state, missing warning markers, changed main/PR
heads, and any attached game assets.

Real Unreal 3D course work since v0.5.94

• Add eight original straight-section edge paint lines and 48 narrow
  braking-zone rubber details on the four existing physical asphalt slabs,
  not the Win32/GDI standalone 2D Controller Edition.
• Verify the complete physical cube footprint of each of the 56 visual
  pieces, its height, finite dimensions and batch assignment. A detail
  cannot create a visually implied road off existing physical asphalt.
• Use one optional holder and two instanced 3D mesh batches, with
  collisions, overlaps, navigation and decorative shadows disabled.
  Incomplete decoration creation destroys the holder, not the actual road,
  four checkpoints, race progression or save state.
• Introduce optional original Unreal Editor-authored PBR material
  generation via real UE5.8 Editor Python, with Color, Roughness and
  Specular parameters for the genuine runtime material binding.
  This source pre-release includes the authoring SCRIPT, not an
  actual created/cooked .uasset, shader, material texture or rendered scene.
• Extend real Win64 candidate packaging with
  -RequireAuthoredTrackMaterial: reject untracked/modified, symlinked,
  tiny, missing or unhydrated-LFS material assets. Verify a SHA256-pinned
  reviewed material before/after Editor and UAT; record the optional digest
  in the unverified manifest without changing historical candidate schemas.

Portable verification

The exact tagged source must pass all of the following before publication:

1. Every strict portable C++20 CTest on Windows, Ubuntu and macOS.
2. All Unreal-source Python binding tests (not UE compilation).
3. PowerShell parsing and synthetic negative build/material/artifact policies.
4. MkDocs build and site navigation verification.
5. Immutable release-source preflight and exact final tag/no-assets audit.

These tests establish source-only arithmetic and build-script contracts.
They do not establish actual UE5.8 UHT compilation, renderer appearance,
material graph or shader cook success, realistic chassis driving, playable
camera/audio, production art, authentic Win64 game packaging or installed QA.

Required before merging or offering an actual 3D Windows preview

The four-slab rectangular prototype is still an early approximation, not
a realistic curved circuit. Prioritize authentic engine compilation,
owned cookable map and material, a real curved collision-backed road,
professional original 3D vehicle models, physical handling verification
and installed Windows 30/60/120 FPS playtests. Complete
gate #148.
Draft physics PR #295
and racing-line PR #297
remain separate, unmerged work.

SOURCE-ONLY — NOT a playable game build — zero executable assets.
The older cartoon-like V5 2D EXE is NOT part of this 3D release.

LateBrake v0.5.94 — Physical Reverse Overspeed Recovery (SOURCE-ONLY Pre-release)

LateBrake v0.5.94 — Physical Reverse Overspeed Recovery (SOURCE-ONLY pre-release)

SOURCE-ONLY experimental GitHub pre-release. This is NOT a playable game build.
No compiled Win64 EXE, Windows installer, Android APK/AAB or installed game is included.
The GitHub source ZIP and tar.gz archives are not installers.
This release has zero executable binaries and zero attached game assets.

Immutable source identity

The v0.5.94 publisher must tag the exact reviewed, tested commit of
unmerged development draft PR #295.
The protected main branch does not acquire the candidate vehicle
physics by publication. The previous immutable source-only milestone is
v0.5.93.

The publisher reauthenticates the same-repository owner-created open
draft PR, its full SHA and release-note bytes before and after the
exact-source CI matrix. It refuses to rewrite an existing tag or release
and publishes zero compiled assets.

Focused driving improvement since v0.5.93

Physical reverse overspeed recovery

• Replace the real player/rival Chaos pawn's hard reverse-overspeed
  SetPhysicsLinearVelocity clamp with a finite, signed, planar
  Chassis->AddForce request. Preserve actual sideways skid and
  vertical gravity, instead of instantly replacing XY momentum after
  a collision.
• Retain the original 48.6 km/h Arcade and 36 km/h Simulation
  Inspired reverse-speed values as soft targets, not guaranteed
  instantaneous hard caps. Transient collision and road/physics forces
  can legitimately exceed them.
• Limit recovery to 850 cm/s² Arcade or 650 cm/s² Simulation
  before actual surface, tire, garage, damage and supported rear-axle
  reductions. Support loss or airborne travel never synthesizes a
  braking force.
• Block new reverse-motor thrust near the measured reverse-speed
  target without blocking ordinary forward drive, low-speed reversing,
  genuine opposite-pedal braking, race time or scoring. Do not count
  blocked reverse input as engine work that generates artificial heat.
• Give service/handbrake and opposite-pedal braking precedence over
  the governor. Budget the physical reverse-correction force against
  the same-frame lateral traction instead of stacking unrealistic
  braking and sideways force.
• Preserve the old ArcadeReverseSpeedLimit.h as a pure historical
  numerical test reference; the accepted Unreal drive Tick does not
  call its velocity-projection function.

Regression and source binding improvements

• Add a strict standalone C++20 ReverseSpeedGovernor regression:
  100,000 deterministic heading/velocity/contact/grip/pedal samples;
  an additional 60,000 combined reverse-braking + lateral-grip
  force compositions against the shared friction budget; 30/60/120 FPS
  integration and settling; zero-contact, invalid-input, reverse-drift,
  service-brake and gear-transition conditions.
• Synchronize the existing actual Unreal source-binding checks for
  reverse motor, gear power, yaw steering, planar speed management,
  human/rival telemetry order and the non-shipping handling log.
• Document physical reverse-speed acceptance
  separately from the legacy instantaneous reference.

What source qualification proves — and what it does not

The publisher must independently compile and execute the entire
strict portable C++20 test suite on Windows, Ubuntu and macOS, run
all Python source/fixture tests, validate PowerShell packaging safety,
and build/verify documentation at the exact pinned source SHA.
Do not infer fixed totals from earlier PR merge previews; the actual
publisher job logs establish the counts. If any gate fails, the
source pre-release must not be published.

These isolated source-model and binding checks are not an Unreal
Engine 5.8 Editor/UHT/Game build. They do not establish tire realism,
measured Chaos deceleration, stable suspension, scene rendering, an
original cooked race circuit or installed Windows/Android gameplay.
The prototype remains a simplified chassis with experimental
four-corner spring support, not a production game.

Required before physics merge or a playable release

1. Run the manual trusted real Unreal 5.8 validation
   against this exact review commit: Editor/UHT first, then an
   authentic Win64 map cook and candidate.
2. On installed Windows hardware, drive at 30/60/120 FPS. Verify
   physical reverse targets, collision recovery without XY snaps,
   speed-vs-slip trace, full/partial/no rear contact, service and
   opposite-pedal precedence, steering, rivals and camera.
3. Capture original engine/circuit/source hashes, cooked archive,
   immutable test receipt, actual logs/video and independent hardware
   measurements. The hash-bound diagnostics report requested forces;
   they are not proof of gameplay or physics accuracy.
4. Validate Android separately and retain the unresolved
   genuine playable-game gate #148. Do not call the
   experimental physics stable or merge it merely because CI passes.

The publication does not include executable binaries, a setup
installer, completed art/audio, multiplayer or playable racing.

SOURCE-ONLY — NOT a playable game build — no executable assets.
Source archives are not installers.

LateBrake v0.5.93 — Handling Recovery and Win64 Evidence (SOURCE-ONLY Pre-release)

LateBrake v0.5.93 — Suspension Handling and Win64 Evidence (Source-only pre-release)

SOURCE-ONLY experimental GitHub pre-release. This is NOT a playable game build.
No compiled Win64 EXE, Windows installer, Android APK/AAB or installed game is included.
GitHub-generated source ZIP/tar.gz archives are not installers. This
pre-release has zero executable binaries / zero attached game assets.

Exact unmerged development source

This release freezes one reviewed revision of the still-draft
PR #295, not the
protected main branch. Publishing source does not merge four-corner
physics, complete a playable game or declare real hardware qualification.
v0.5.92
remains the preceding immutable source-only snapshot.

The version publisher must authenticate the live owner-created, same-repository
PR and exact pinned commit, confirm these release notes byte-for-byte in the
tagged source, rerun the full portable qualification, and reject attempts to
retag or silently replace an existing release.

Improvements since v0.5.92

Opposite-pedal and sideways-slide recovery

• Classify engine braking using the measured signed longitudinal speed.
  A vehicle moving almost entirely sideways can still request drive torque
  without falsely activating opposing-direction braking.
• Keep actual opposite-pedal braking when the signed forward/reverse motion
  really opposes the command; preserve rear-axle traction, grip and
  service-brake precedence.
• Avoid charging engine heat for throttle input that the opposing-brake
  policy explicitly prevents from reaching the motor. Cover forward and
  reverse regression scenarios at 30, 60 and 120 FPS.

Physically delivered drafting HUD

• Report only the drafting motor-force fraction that survives the same
  shift, rear-wheel load, surface, collision damage, engine heat and
  traction limits used for the real force submission.
• Preserve the original nitro/drafting shared budget, race authority,
  lap/checkpoint validation and saved progression.

Inspectable handling evidence for a future installed game

• Add bounded non-shipping LATEBRAKE_DRIVE v=1 diagnostics using
  the existing suspension event cadence: signed driving speeds, yaw,
  throttle/steer input, loaded axle limits and actual branch-authorized
  motor, service/opposite braking, lateral and yaw force requests.
• Add strict offline scripts/AnalyzeDriveTelemetry.py validation of
  malformed/contradictory force records. These are requested forces,
  not measured Chaos acceleration or independently proven driving feel.
• Add a drive-audit command to
  scripts/Review-WindowsPlaytest.py. It binds the exact log bytes to
  a schema-2 runtime receipt and the complete SHA256-checked Win64
  candidate, engine Build.version, original map and source commit.
  --require-player rejects logs containing only autonomous-rival
  samples. Reports always state gameplay_verified: false and
  ready_for_release: false; editable files and matching hashes do
  not authenticate a real playtest.
• Expand source-only unit tests and Windows physical driving acceptance
  guidance without introducing extra shipping physics or runtime features.

Verified scope and strict limits

The exact reviewed source must independently pass 184 C++20 CTests
on each of Windows, Ubuntu and macOS, 679 Python source/fixture
tests, PowerShell packaging-policy checks and the complete
documentation build. These checks establish source behavior and safe
test fixture interpretation only. The publishing workflow must repeat
the checks for the exact candidate SHA before making the source
pre-release visible.

None of this is a successful Unreal Engine 5.8 Editor/UHT/Game build,
a genuine cooked circuit, installed Win64 racing, rendered graphics,
Android device QA, calibrated tire physics or a verified game installer.
The prototype still uses a rigid Chaos chassis with experimental
four-corner ray springs; it is not a finished AAA racing game.

Remaining acceptance before playable release or physics merge

1. On an owner-authorized licensed UE 5.8 Windows runner, compile and
   validate the exact draft PR using
   trusted Unreal validation.
2. Build and cook a genuine original Win64 circuit, preserve the complete
   package and exact source/engine/map SHA256 provenance.
3. Drive and record 30/60/120 FPS settling, suspension travel, braking,
   reverse transitions, sideways recovery, grip-limited turns, drafting,
   camera, rival AI, pause, restart, checkpoints and save progression.
4. Inspect genuine observed gameplay and the private hash-bound diagnostic
   receipt; reject unstable physics, frame stalls, missing assets or
   unverified game binaries. Test Android separately.
5. Retain issue #148
   as the playable release blocker; do not publish a stable game or
   merge the unqualified physics simply because these source checks pass.

Original authored source: BSD-3-Clause. Unreal Engine and Epic assets are
subject to their own licenses. Project support:
https://buymeacoffee.com/sanskarIN.

SOURCE-ONLY — NOT a playable game build — zero executable binaries.
Source archives are not installers.

LateBrake v0.5.92 — Suspension and Traction Refinement (SOURCE-ONLY Pre-release)

LateBrake v0.5.92 — Suspension and Traction Refinement (Source-only pre-release)

SOURCE-ONLY experimental GitHub pre-release. This is NOT a playable game build.
No compiled Win64 EXE, Windows installer, Android APK/AAB or installed game is included.
GitHub source ZIP/tar.gz archives are not installers. This milestone
contains zero executable binaries / zero attached assets.

Branch and release identity

This freezes a tested unmerged development branch from draft
PR #295. The protected
main branch does not acquire the experimental vehicle physics by
publishing this tag. The publisher pins one full source commit, validates
the owner-created PR head twice, reruns the source checks, and refuses to
rewrite an existing tag or release. The previous experimental source
pre-release is v0.5.91.

Changes since v0.5.91

• Preserve qualified four-corner spring lift independently of optional
  driving-policy failures, using one force submission per accepted frame.
• Qualify springs by real chassis attitude, avoiding wheel support on an
  inverted body; retain aerodynamic drag but remove unsupported tire
  rolling/shoulder resistance in flight.
• Measure advisory launch speed from signed horizontal motion so vertical
  landing velocity does not count as forward acceleration.
• Replace the global forward/nitro planar velocity snap with bounded
  opposing force. The separate reverse-gear safety cap remains.
• Bound opposing-throttle braking by pedal demand, surface/tire/garage/
  damage grip and accepted rear-axle support; include it in the existing
  same-frame cornering budget without stacking service/handbrake forces.
• Limit the combined base, nitro and drafting propulsion to the grip
  remaining after actual planned cornering force and the measured rear
  support ceiling. Preserve ordinary under-budget straight-line thrust.
• Damp static-road spring ray-length changes using the actual corner
  velocity and hit normal. Tangential uphill/downhill motion no longer
  creates false damping in the portable model; flat heave, compression,
  rebound and angular corner motion are retained. Initial-overlap rays
  cannot supply tangent-plane road support.
• Carry the main-line Android viewport-action epoch fix into the draft.
• Add strict C++20 regressions, actual Unreal-source binding checks and
  detailed engine/driving acceptance procedures for these changes.

What the checks establish

The candidate has 184 standalone C++20 tests and 659 Python source
checks, plus documentation and PowerShell validation. The release
workflow reruns the complete candidate suite on its exact pinned commit
with Windows, Ubuntu and macOS portable jobs and verifies source-only
release labels and immutable identity before publication.

The numerical/reference tests include changing wheel support, axle grip,
boost/gear/lateral composition and independent static-plane derivative
fixtures. These are not Unreal Engine 5.8 Editor/UHT/Game builds, real
Chaos suspension measurements, installed Win64 playtests or Android QA.
The chassis remains a simplified rigid-body prototype with ray springs,
not a validated per-wheel tire/differential solver or finished racing game.

Still required before merging the physics or publishing a playable game

1. Compile real licensed UE5.8 Editor/UHT and Win64 Game targets at the
   exact reviewed source revision.
2. Author/cook the genuine circuit and produce a hash-bound Win64 package.
3. Drive the installed candidate at 30/60/120 FPS: settling/countdown,
   braking, corner exits, nitro/drafting, ramps, partial contact, airborne
   recovery, camera, rival AI, pause/restart/recovery and save regressions.
4. Capture actual logs/video, package/source/engine identity and hardware
   performance; tune the candidate values from those observations.
5. Keep original production art/audio, Android hardware, multiplayer and
   stable release acceptance behind their independent requirements.

See the PR validation guide
and suspension QA.
Issue #148 remains open
for the genuine playable-game gate. Publishing source does not close it.

Original code is BSD-3-Clause; Unreal Engine code/assets retain Epic's own
license. Support: https://buymeacoffee.com/sanskarIN.

SOURCE-ONLY — NOT a playable game build — zero executable binaries.
Source archives are not installers.

LateBrake v0.5.91 — Four-Corner Suspension Research (SOURCE-ONLY Pre-release)

LateBrake v0.5.91 — Four-Corner Suspension Research (Source-only pre-release)

SOURCE-ONLY experimental GitHub pre-release. This is NOT a playable game build.
No compiled Win64 EXE, Windows installer, Android APK/AAB or installed game is included.
GitHub-provided source ZIP/tar.gz archives are not installers, and this
pre-release intentionally has zero executable binaries / zero attached assets.

Important branch qualification: v0.5.91 freezes the tested source
from draft pull request #295.
This tag is an experimental source snapshot from an unmerged development
branch, not a new stable release or proof that the Unreal game on main
contains these changes. The protected main branch remains separate.
The release workflow must verify the exact same-repository PR head, run
source tests at that immutable SHA and refuse to move an existing tag.

New source since v0.5.90

Actual four-corner rigid-body suspension research

• Four independent, measured WorldStatic ground traces at shared
  front-left, front-right, rear-left and rear-right wheel anchors.
• Each accepted corner samples actual Chaos point velocity, validated
  road-normal slope and spring compression, then submits bounded vertical
  AddForceAtLocation forces to the physical chassis.
• Unlocked real chassis pitch and roll, limited axle-local anti-roll
  load transfer, mass/gravity-aware spring force bounds and measured
  front-steering/rear-drive axle support. Partially unloaded or airborne
  wheels never receive an invented rear motor or front steering authority.
• Visual-only spindle travel uses the same canonical corner geometry,
  without decorative wheel movement feeding back into physics probes.
• Controlled reacquisition of rear motor and front steering grip after
  genuine recontact, while immediate load losses cut authorization.
• Non-shipping LATEBRAKE_SUSPENSION v=1 diagnostic logs: first valid
  frame, rate-limited changes in measured supporting-wheel load,
  grid-to-GO transition and a low-frequency heartbeat. Brief events are
  latched until the next allowed record, but the log remains lossy and
  is not physical validation.

Handling and source safety

• Near-vertical body attitudes retain real spring/gravity momentum
  without applying undefined planar motor or steering directions.
• Finite game-frame stalls above the supported 100 ms spring interval
  suppress invalid drive calculations without hard-zeroing valid Chaos
  linear/angular momentum.
• Six optional surface/drag/braking/grip/yaw/gearbox rejection paths
  revoke driving input and stale traction without freezing valid
  previously submitted chassis spring forces.
• Strict source bounds, isolated heave/pitch/roll test models,
  120k+ stress frames and source-binding tests guard against
  nonfinite/invalid contact or fabricated wheel support.

Engineering scope: these are four spring rays and force positions on
an Unreal rigid-body prototype, not independent Chaos Vehicles
wheel/tire contact dynamics, professional vehicle art, authored track
assets, or a verified 3D racing experience.

Source-only qualification

The publisher checks the exact, pinned draft-PR commit on Windows,
Ubuntu and macOS with the complete standalone C++20/CTest suite,
Python Unreal source-binding regressions, release-script syntax
and provenance checks, and MkDocs documentation integrity. All of these
are genuine source validations, not licensed Unreal Engine 5.8
Editor/UHT/game compilation or installation tests.

The publisher verifies the existing v0.5.90 asset-free prerelease,
draft PR #295 ownership/head identity, tag immutability, exact SHA
alignment and zero attached executable assets. It never publishes
or labels a playable Win64/Android game candidate.

Work still required before any playable release

1. Compile with licensed Unreal Engine 5.8 Editor/UHT and a real Win64
   game target, then cook the original project circuit and inspect errors.
2. Drive a genuinely packaged Windows candidate with keyboard/gamepad
   at 30/60/120 FPS; check curb strikes, partial support, airborne
   motion, pitch/roll, brakes, steering, traction, and frame-stall recovery.
3. Verify physics, camera, collision, gate timing, pause/recovery and
   local saves on the same exact binary and source/map identity.
4. Build original finished vehicle/track content and a Windows
   installer, then independently test an installed candidate.
5. Keep multiplayer, Android device qualification, and stable release
   promotion behind their separate acceptance gates.

The source is BSD-3-Clause; Unreal Engine code and assets are covered
by Epic's own license. Donations, if desired, use
https://buymeacoffee.com/sanskarIN.

SOURCE-ONLY — NOT a playable game build — zero executable binaries.
Source archives are not installers.

LateBrake v0.5.90 — Physical Driving and Safer Rival AI (SOURCE-ONLY Pre-release)

LateBrake v0.5.90 — Physical Driving and Safer Racing AI

SOURCE-ONLY GitHub pre-release. This is NOT a playable game build.
No compiled Win64 EXE, Android APK/AAB or installed game is included.
GitHub source ZIP/tarball archives are not installers and contain
zero executable binaries. This is a development source snapshot;
it does NOT establish successful Unreal Engine 5.8/UHT/Game compilation,
a cooked original circuit, a real Windows installer, stable performance,
working car-wheel suspension, or safe collision-free real driving.

Real source changes since published v0.5.89

PHYSICAL CHASSIS DRIVING — PRs #281–#285

• ProgressiveRoadLoad replaces excessive constant coast damping with
  bounded rolling/aerodynamic road load. Player and physical rival use
  the same policy; off-pavement still adds resistance.
• SpeedAwareYawTorque makes steering depend on actual lateral
  chassis motion and speed instead of arbitrary zero-speed turning.
• AutomaticTransmission adds a four-forward-gear/reverse automatic
  drive state, shift torque reductions and engine-speed telemetry.
• GripLimitedBraking bounds forward/reverse service braking against
  real measured planar speed, road and tire grip, damage and thermal fade.
• LateralGripBudget caps lateral force and shares an approximate
  combined traction budget with actual braking. This is a single Chaos
  rigid-body approximation, not a validated wheel/tire contact model.

RIVAL CORNER AND TRAFFIC DRIVING — PRs #286–#288

• RivalCornerBrakeEnvelope forecasts earlier corner braking from
  live previous-tick grip/thermal measurements, current measured speed
  and remaining inbound gate distance.
• RivalStraightPassAssist supplies genuine bounded steering
  for a single AI car passing a slower player only on a qualified
  original paved straight. This is not multiplayer or full opponent AI.
• RivalPassTrafficResolution fixes an unsafe conflict: the
  independent real-velocity traffic emergency brake now cancels
  overtaking and restores original route steering instead of braking
  with an active sideways passing steer. Passing starts conservatively
  only on the two longer original 5600cm straights, with adequate
  corner distance and measured closing-time margin.
• Player-authoritative checkpoints, rewards, singleplayer save
  authority, AI recovery and the independent traffic safety brake
  remain unchanged. The steering change is not proof of physical
  collision-free passes on a cooked Unreal map.

Other retained development since v0.5.89

• Physical on-track directional-guide chevrons, richer
  automatic-gear HUD instruments and actual rival finish-clock
  observational source remain in the development branch. Any
  experimental separate 2D Windows preview is not the Unreal 3D
  game and does not satisfy the Win64 candidate gate.

Immutable, tested source-only qualification

The v0.5.90 publisher runs the complete portable C++20 CTest
suite on Windows, Ubuntu and macOS and independently checks all
eight new production numerical targets: ProgressiveRoadLoad,
SpeedAwareYawTorque, AutomaticTransmission,
GripLimitedBraking, LateralGripBudget,
RivalCornerBrakeEnvelope, RivalStraightPassAssist and
RivalPassTrafficResolution. These are actual source tests, not
UE5.8 game builds.

Editor Python source-binding tests, MkDocs rendering, PowerShell syntax,
synthetic candidate/provenance rejection policies and immutable
same-main-SHA release checks must also pass. Its GitHub tag is
created only after all four independent release qualification jobs
succeed and the published v0.5.89 predecessor is validated. The
pre-release must have zero attached executable assets.

Prior published system gates retained

The full source regression and pre-existing individually required
targets still include:

SOURCE-ONLY, ARCADE TIRE, NITRO BOOST, SLIPSTREAM, RIVAL GRIP, OFF-PAVEMENT TRACTION, BRAKE HEAT, IMPACT DAMAGE, ENGINE HEAT, RIVAL HEAT PACE, VERIFIED GATE GAP, UNREAL PIT SERVICE, MENU INPUT, SIX-CAR BODY KITS, RacePitService, RacePitVehicleService, VehicleBodyKit, PIT RADAR, ANDROID PIT HOLD, SIX-CAR PAINT, RacePitRadar, TouchPitHold, TouchControlLayout, VehiclePaintRecipe, GATE PROGRESS, GARAGE COMPARISON, RIVAL SPLITS, RIVAL DIFFICULTY, RaceGateProgressGauge, GarageCatalogView, GarageComparisonView, RivalMatchedGateSplits, RivalDifficultyPreset.

These older named source systems (including ARCADE TIRE, NITRO BOOST,
SLIPSTREAM, RIVAL GRIP, OFF-PAVEMENT TRACTION, BRAKE HEAT,
IMPACT DAMAGE, ENGINE HEAT, RIVAL HEAT PACE, VERIFIED GATE GAP,
UNREAL PIT SERVICE, MENU INPUT, SIX-CAR BODY KITS, PIT RADAR,
ANDROID PIT HOLD, SIX-CAR PAINT, GATE PROGRESS, GARAGE COMPARISON,
RIVAL SPLITS and RIVAL DIFFICULTY) are retained, not new evidence
of a functioning installed product. RacePitService,
RacePitVehicleService, VehicleBodyKit, RacePitRadar, TouchPitHold,
TouchControlLayout, VehiclePaintRecipe, RaceGateProgressGauge,
GarageCatalogView, GarageComparisonView, RivalMatchedGateSplits
and RivalDifficultyPreset remain independently qualified.

Not included, and what is required next

• No real Unreal Engine 5.8 Editor/UHT/Game compilation, cookable
  validated circuit, independently simulated contact wheels,
  suspension or tire telemetry.
• No compiled Win64 EXE, Windows installer, Android APK/AAB,
  installed game, controller/device QA or actual visual proof.
• No multiple developed circuit maps, full racing grid,
  matchmaking, invitations, professional car art or
  validated collision-free overtaking.
• A licensed Unreal Engine Windows build machine and authentic
  cooked original map, followed by instrumented 30/60/120fps
  driving, contact, brake and AI passing checks, are mandatory
  before any playable build announcement.

See real playable-release qualification #148
and Android device qualification #13.

The authored source is under BSD-3-Clause; Unreal Engine and
engine-provided assets are under Epic's separate terms.

SOURCE-ONLY — NOT a playable game build — zero executable binaries.
GitHub source archives are not installers.

LateBrake v0.5.89 — Racing Instruments, Garage and Rival AI (SOURCE-ONLY Pre-release)

LateBrake v0.5.89 — Racing Instruments, Six-Car Garage, Matched Rival Splits and AI Difficulty

SOURCE-ONLY GitHub pre-release. This is NOT a playable game build.
No compiled Win64 EXE, Android APK/AAB or installed game is included.
GitHub source ZIP/tarball archives are not installers and contain
zero executable binaries. This milestone is source-level development
and does NOT prove Unreal Engine 5.8/UHT compilation, cookable project
maps, rendered car materials, installed Windows gameplay or Android QA.

Source improvements since published v0.5.88

GATE PROGRESS: discrete real-race HUD gauge — PR #261

• The expanded desktop race instruments show accepted checkpoint/lap
  progress as GATES completed/total with a bounded fraction. Only
  player-authoritative RaceProgress checkpoint counters are used.
• Real checkpoint collisions/physical running, record qualification and
  finish classification remain unchanged. It does not pretend to be a
  continuous physical distance indicator or a leaderboard.
• Targeted C++20 RaceGateProgressGauge and Python source-binding tests
  reject bad counters, invalid/unfinished boundaries and overflow.

GARAGE COMPARISON: six original fictional cars — PR #262

• Every existing Arrow/Kestrel/Phantom/Tempest/Glider/Nova catalogue row
  now includes a signed relative comparison against the equipped car
  for arcade acceleration, grip and speed multipliers, not measured
  0–100 km/h performance. Locked cars remain read-only previews.
• The next engine/grip upgrade tier displays its exact established
  GarageState cost, affordability, shortage or MAX indication.
• Existing two-press purchase confirmation, SaveGame rollback, vehicle
  ownership and credit authority remain untouched.
• Qualified targets: GarageComparisonView, GarageCatalogView.

RIVAL SPLITS: accepted same-lap/same-gate time — PR #263

• The local rival and human car may present
  SPLIT L1 G2: RIVAL +2.00s (NOT PLACE) after both have physically
  passed the same forward directional gate for the same lap.
• A fixed-memory, 32-sample-per-driver ring protects against crossed
  attempts, stale ring slots, reversed timestamps and malformed samples.
  Uses a shared post-GO timing source without artificial player recovery
  penalties for the observation only; official Race clock and
  penalties are unchanged.
• These are retrospective gate timestamps, not live vehicle position,
  official standings, opponent track distance or network race results.
• Qualified target: RivalMatchedGateSplits.

RIVAL DIFFICULTY: Rookie, Standard, Expert quick race — PR #264

• Reuse existing BROWSE/N (keyboard, gamepad D-pad right and mobile
  menu Browse) to select the next Quick Race local rival tier.
  Changing a pending selection never retunes a running race.
• ROOKIE reduces physical rival planner throttle, STANDARD preserves
  the original tuning, EXPERT slightly increases planned acceleration
  on eligible moderate-speed straights only.
• Career always retains STANDARD regardless of Quick Race selection.
  Existing tire/road/traffic/heat/yaw/spin governors and accepted
  checkpoint rules still override the difficulty policy as necessary.
• No new SaveGame fields, event rewards or server multiplayer.
• Qualified target: RivalDifficultyPreset.

Retained earlier source policies

All v0.5.88 source policies are retained: ARCADE TIRE, NITRO BOOST,
SLIPSTREAM, RIVAL GRIP, OFF-PAVEMENT TRACTION, BRAKE HEAT,
IMPACT DAMAGE, ENGINE HEAT, RIVAL HEAT PACE,
VERIFIED GATE GAP, UNREAL PIT SERVICE, MENU INPUT,
SIX-CAR BODY KITS, PIT RADAR, ANDROID PIT HOLD and
SIX-CAR PAINT. A conventional dynamic mesh Color material
parameter remains unverified in Unreal Editor.

Mandatory immutable source publication checks

The v0.5.89 publisher must build and pass the complete C++20 CTest
suite on Windows, Ubuntu and macOS, and individually require
RaceGateProgressGauge, GarageComparisonView,
RivalMatchedGateSplits, RivalDifficultyPreset plus the prior
physical-pit, Android-touch and six-car paint targets to exist/pass.
The previous v0.5.88 gameplay policy targets are individually
required as well: RacePitService, RacePitVehicleService,
VehicleBodyKit, RacePitRadar, TouchPitHold,
TouchControlLayout and VehiclePaintRecipe. Their exact CTest names
are audited before any source-only publication.

Python Unreal-source binding tests, real documentation rendering,
PowerShell syntax and synthetic packaging/provenance rejection tests
must pass. The release requires an unchanged, CI-qualified main SHA,
published asset-free v0.5.88 predecessor and immutable v0.5.89 tag.

The source code license remains BSD-3-Clause; Unreal and any underlying
engine assets have their own terms.

What is not in this release

• No compiled Win64 EXE, Windows setup installer, macOS/Linux executable,
  Android APK/AAB or tested installed game.
• No proven licensed UE 5.8 Editor/UHT/Game compilation, original cooked
  circuit .umap, controller/touch hardware testing or GPU performance.
• No mature 3D art, online match invitations or official rival race results.

The GitHub Pages documentation site is a documentation deployment,
not game software or an executable release.

SOURCE-ONLY — NOT a playable game build — zero executable binaries.
GitHub source archives are not installers.

See Windows playable-release gate #148
and Android hardware qualification gate #13.

LateBrake v0.5.88 — Pit Radar, Android PIT HOLD and Six-Car Paint (SOURCE-ONLY Pre-release)

LateBrake v0.5.88 — Pit Radar, Android PIT HOLD and Six-Car Paint Identities

SOURCE-ONLY GitHub pre-release. This is NOT a playable game build.
No compiled Win64 EXE, Android APK/AAB or installed game is included.
GitHub-created source ZIP/tarball archives are not installers. This
pre-release contains zero executable binaries and is NOT evidence
of Unreal Engine 5.8/UHT compilation, cooked maps or installed gameplay.

Source changes since published v0.5.87

PIT RADAR — real pit position, non-authoritative UI

• The optional expanded desktop north-up radar draws a PIT marker
  at the exact published south-shoulder RacePitBay world coordinates.
  It uses the same normalized map transform as the actual player/rival
  markers; it never computes official track placement, gate progress or
  race rewards.
• Portable RacePitRadar C++ tests exercise paved position, gate
  separation, viewport normalization and invalid-coordinate safety.
  Unreal-source binding tests assert that this HUD-only code cannot
  teleport, repair or alter checkpoints.
• The road and the separate physical service zone are unchanged.

ANDROID PIT HOLD — real Unreal player-pawn mobile input source

• Add a dedicated, non-overlapping PIT HOLD touch rectangle with the
  same shared layout used for visible touch HUD rendering and hit testing.
• Only a fresh, eligible physical finger-down can acquire its independent
  held-input owner. Dragging out, finger-up, invalid coordinates, malformed
  duplicate presses, app background, menu/pause, restart, lost controller
  or viewport rotation/resize cancels the hold.
• PIT touch makes a request, not a service award. The existing physical
  RacePitService still checks a real local player, post-GO race,
  measured bay position, speed at most 120 cm/s, neutral throttle,
  unheld nitro, actual maintenance need and 2.5 seconds continuous hold.
  Service keeps existing one-stop-per-entry restrictions.
• The touch pad can display the true held service progress.
  Keyboard P and controller Y remain supported.
• Portable TouchPitHold and expanded TouchControlLayout C++ tests
  exercise independent finger ownership, invalid IDs and 50,000
  press/move/release cycles. Source checks verify actual Unreal pawn/HUD
  wiring. No Android device, APK or multitouch hardware QA is claimed.

SIX-CAR PAINT — original procedural car identities

• Existing fictional cars Arrow, Kestrel, Phantom, Tempest, Glider,
  Nova have source-defined colors SKY BLUE, EMBER ORANGE,
  ELECTRIC VIOLET, RACING SCARLET, SEA GLASS, SOLAR YELLOW.
• Pure VehiclePaintRecipe C++ policy gives each fixed garage ID its own
  bounded body, trim and canopy palette; invalid IDs use the free Arrow
  palette without implying paid-car ownership.
• The real Unreal player pawn attempts a Color vector material
  override on component-owned dynamic instances, created only at actor
  BeginPlay and reused on garage selection. The expanded garage menu
  labels paint independently of kit and performance.
• Rendering caveat: source CI does not establish that Unreal 5.8's
  built-in primitive parent material exposes a Color vector parameter.
  If it does not, project-owned parameterized materials and genuine
  installed Unreal rendering QA are still required. This release is
  not proof of working colored 3D cars in a playable game.
• No additional car ownership mask, save fields, purchases, power,
  physics contacts, collisions, rewards, unlocks or art assets are added.
  Original kits remain non-colliding engine-primitive geometry.

Prior source gameplay preserved

v0.5.88 retains the previous source policies and warnings:
ARCADE TIRE, NITRO BOOST, SLIPSTREAM, RIVAL GRIP,
OFF-PAVEMENT TRACTION, BRAKE HEAT, IMPACT DAMAGE,
ENGINE HEAT, RIVAL HEAT PACE, VERIFIED GATE GAP,
UNREAL PIT SERVICE, MENU INPUT and SIX-CAR BODY KITS.
These remain arcade approximations and source integration, not verified
Unreal packaged driving or an official leaderboard result.

Publication qualifications

The exact merged main SHA must independently pass complete portable
C++20 builds and nonempty CTest suites on Windows, Ubuntu and macOS,
including targeted RacePitService, RacePitVehicleService,
VehicleBodyKit, RacePitRadar, TouchPitHold,
TouchControlLayout and VehiclePaintRecipe targets.
Unreal source-only Python contracts, PowerShell packaging/provenance
synthetic rejection tests and documentation rendering must pass, too.

The publisher must verify the earlier v0.5.87 is published,
non-draft, prerelease and asset-free. It must refuse a stale main SHA,
an existing v0.5.88 tag pointing elsewhere, missing source warnings,
failed/absent tests and executable release attachments.

Required for a genuine installed racing game

• Licensed Unreal Engine 5.8 Editor/UHT/Game compilation, original
  authored and cooked circuit, verified Win64 package and installer.
• Real on-device/Windows inspection of paint materials, six car
  silhouettes, PIT radar, physical pit placement and actual Android
  multitouch release/focus/rotation. Test full race laps, controller,
  menus, saves, physics contacts and acceptable frame performance.
• Keep playable-release gate #148,
  Android hardware gate #13
  and production UI gate #236 open without installed QA evidence.

SOURCE-ONLY — NOT a playable game build — zero executable binaries.
GitHub source archives are not installers.

LateBrake authored source is BSD-3-Clause; the licensed Unreal Engine
and third-party dependencies remain subject to their own licenses.

LateBrake v0.5.87 — Race Pit Service, Menu Input and Six Car Body Kits (SOURCE-ONLY Pre-release)

LateBrake v0.5.87 — Race Pit Service, Menu Input and Six Car Body Kits

SOURCE-ONLY GitHub pre-release. This is NOT a playable game build.
No compiled Win64 EXE, Android APK/AAB or installed game is included.
GitHub-created source ZIP/tarball archives are not installers. This
pre-release contains zero executable binaries and is NOT evidence
of Unreal Engine 5.8/UHT compilation, a cooked map or a tested installed game.

Changes since v0.5.86

UNREAL PIT SERVICE — real chassis-qualified arcade racing source

• The actual production Unreal car pawn now observes measured body position
  and planar chassis speed at an inner-south-shoulder pit zone, rather
  than implementing the gameplay solely in the separate native 2D preview.
• Hold P or gamepad Y for a valid, continuous 2.5 seconds at
  no more than 120 cm/s (4.32 km/h) with neutral throttle and no held
  nitro. A real possessed local driver, physically ready chassis and
  unpaused post-GO race are mandatory.
• Each successful stop repairs up to 25 percentage points of bounded
  race-local collision damage, replaces the synthetic tire wear/temperature
  state, refills up to 40 percentage points of nitro, and cools the
  boost policy. A player must physically exit and re-enter the bay before
  another service; invalid samples, released hold and interruptions reset
  incomplete progress.
• A non-colliding marker and a read-only expanded desktop HUD guide pit
  placement and hold progress. The mandatory existing circuit collision
  and checkpoint actor count is not changed.
• Race clock, checkpoint authority, rewards, purchases, garage saves and
  ownership masks are not affected by the pit. This is not a finished
  racing pit lane, real tire replacement or real-game tested feature.
  Unreal pit service QA.

MENU INPUT — independent keyboard and mouse control

• Fix a malformed Unreal legacy-input configuration row that concatenated
  Enter menu activation with the left-mouse mapping; both now
  have separate valid configuration entries.
• Add full-row mapping parsing and pawn binding coverage, not just string
  substring tests; controller face-button menu confirmation is preserved.
• Controller Y can also trigger pit service in a closed menu without
  a stray menu action erasing the held racing input. Open-menu confirmation
  still clears driving controls and uses GameMode authorization.
  Desktop menu QA.

SIX-CAR BODY KITS — original engine-primitive visual identity

• All six existing garage IDs have immutable cosmetic 3D recipes:
  STREET, SPRINT, GT, TRACK, TOURING, APEX.
• Each Unreal car pawn adds a front splitter, paired side skirts, rear
  diffuser, optional hood scoop, and optional paired rear fins; dimensions
  and visibility change with the existing garage vehicle selection.
• Seven decorative primitives never modify the physically simulated
  chassis, collision/overlap responses, power curves or saved progress.
  The non-compact garage menu exposes the current body-kit identity.
• These are additional geometric details, not artist-created or
  photorealistic vehicle models, and have not been checked in an installed
  Unreal package.
  Body-kit verification.

Experimental Win32 2D preview: separate personal test work

• The independent native 2D Windows preview gained an offline pit-service
  mechanic, keyboard/gamepad input, HUD progress, personal QA documentation
  and Windows synthetic self-test coverage.
• That preview is not an Unreal Engine build or proof that installed
  production 3D racing works. Preview binaries produced by Windows CI are
  unverified temporary artifacts, not assets in this release.
  Preview-only QA.

Previously published race systems preserved

The v0.5.87 source snapshot also retains the existing ARCADE TIRE,
NITRO BOOST, SLIPSTREAM, RIVAL GRIP, OFF-PAVEMENT TRACTION,
BRAKE HEAT, IMPACT DAMAGE, ENGINE HEAT, RIVAL HEAT PACE
and VERIFIED GATE GAP policies from earlier source pre-releases.
These remain source-only arcade approximations and advisory readouts,
not proof of real installed Unreal game behavior. The new pit and car
visuals do not grant a new race result or bypass the established
checkpoint and saved-progression restrictions.

Tested SOURCE qualifications required before publishing

1. Full standalone C++20 source policy builds and nonempty CTest suites
   on Windows, Ubuntu, macOS, all at the exact publication commit.
   Explicitly require passing RacePitService, RacePitVehicleService,
   VehicleBodyKit, ArcadeCollisionDamage, ArcadeTireCondition,
   ArcadeNitroBoost, RivalGripPace, RivalGateGap,
   ArcadeEngineHeat and existing race progression safeguards.
2. Unreal source-only Python binding tests including
   UnrealInputMappingIntegrityTests,
   UnrealPitServiceBindingTests and
   UnrealVehicleBodyKitBindingTests. They are not Unreal UHT
   compilation or hardware UI tests.
3. PowerShell packaging/provenance synthetic rejection fixtures,
   documentation site rendering and source-status checks.
4. Reject main-branch drift after qualification; require the previously
   published v0.5.86 asset-free source pre-release; refuse to change an
   existing v0.5.87 tag that points to another commit; verify that a
   published release is a non-draft pre-release with zero game assets.
   Do not create a stable release or attach EXE/APK/installer files.

Still REQUIRED for a genuine playable LateBrake game

• Compile Unreal Engine 5.8 with a qualified UHT/Editor/Game toolchain,
  author and cook the genuine project-owned circuit and package a real
  Win64 installation candidate with immutable build-source provenance.
• Playtest race controls, a full three-lap event, actual 3D car visibility,
  simulated chassis collisions, pit position/time, garage changes, menus,
  save continuity, real gamepad, focus changes and frame time on Windows.
• Qualify Android APK/AAB and physical multitouch behavior separately.
• Do not close playable-release gate #148
  or Android hardware gate #13
  without genuine installed-game evidence.

SOURCE-ONLY — NOT a playable game build — zero executable binaries.
GitHub source archives are not installers.

LateBrake authored source code is BSD-3-Clause; Unreal Engine and
separately licensed dependencies remain under their own licenses.