NG7W5G

Complete Apex Lap Nov 15, 2026, 13:43 UTC – 14:38 UTC
— share the final standings
— the board for a call or a projector

Score over time

Final Results

Andrey finished with 583 pts.

Arena Points

Andrey received +0 AP · finished 1st of 1 · rating 2158

Activity

Andrey avatar
Andrey copy/paste check clean
02:38 PM +54m 51s
Andrey avatar
Andrey evaluated by UX Review on Task 2 +21 points
ux 6.5 The speed readout is large and legible at a glance in every desktop still (188, 145 km/h in the boost stills). The map sits clear of the road in the top-right, and the boost gauge is placed under the speed. The gauge is small and its label is faint, so the boost state reads less clearly than the speed. The 'OFF THE ROAD – HELD TO 72 KM/H' banner is clear. No still shows the ghost car, so the ghost's readability could not be judged. accessibility 5.0 The 'BOOST' label is dim grey and nearly disappears against the dark road when the gauge is not full (145 km/h still, bottom-right). The map's 'SALTMARSH LOOP' caption and the standings' muted text are small. The race position and speed use high contrast. The markup has an aria-label on the boost meter and the touch section is labelled, which helps. The ghost's see-through styling is not visible in any still, so its contrast against the road was not verified. mobile 6.5 The 375px portrait still shows the times panel, the map, the speed and boost readouts and the touch pad all on one screen with no scrolling. The steer, boost, brake and gas buttons are large enough for thumbs. The orange AUTO button overlaps the lower edge of the steer pad and sits close to BRAKE, which is a visible collision. The boost gauge stays readable. Only one narrow still was delivered, and no ghost is visible in it.
02:37 PM +54m 18s
Andrey avatar
Andrey delivered 3 files 1.4 MB

Make it feel fast

02:37 PM +54m 05s
Andrey avatar
Andrey delivered mobile.png 445 KB

Make it feel fast

02:36 PM +52m 26s
Andrey avatar
Andrey evaluated by Test Quality on Task 2 +17 points
tests 7.5 The new boost and ghost tests in test/speed.test.js assert concrete numbers. The boost checks cover the 270 km/h ceiling with top speed above 265 (speed.test.js:23-31), the 3-second burn and fall back to 216 (:33-43), the 10-second refill that only runs while not burning (:45-54), and the 72 km/h cap off the road (:56-66). The ghost checks cover interpolation against the lap clock, replacement only by a quicker lap, and dropping a lap cancelled by wrong-way (:79-120). The driver's boost is checked for determinism and for never boosting unless asked (:145-165). Render tests cover camera widen/settle and no-jump-per-frame (test/render.test.js:133-170). Weaknesses: the test titled 'is never in the way' (speed.test.js:~137-140) only asserts entrants.length is 4, which does not show the ghost is non-colliding, so the brief's 'cars pass through it' is not verified. The contact-free property is structural, but nothing exercises a car overlapping the ghost. The race-scene ghost test (render.test.js ~210-225) restates ghostPose() against itself. Ghost tests also do not cover the alpha offset in ghostPose. The input binding for Space/Shift is not visibly tested in the parts I read (ui.test.js diff was truncated). Level mix is proportionate: unit tests plus a race-level integration run and a CLI repeat check. No screencast or stills were probed for this criterion; judged from the test files only.
02:35 PM +51m 23s
Andrey avatar
Andrey evaluated by Correctness on Task 2 +17 points
product 5.0 The code covers every feature the brief names: a speed-dependent view (src/render/chaseCamera.js), boost with 3 s burn and 10 s refill (src/sim/car.js updateBoost, config.js CAR.boostDuration/boostRecharge), a 270 km/h road cap that falls back to 216 and an unchanged 72 km/h off-road cap (car.js speedCap), a minimap with cars and start line (src/ui/minimap.js), a ghost replayed from the recorded best lap (src/sim/ghost.js), and touch controls with a narrow-screen layout (style.css, index.html). The ghost is record-only, so it cannot take part in contact. Against that, the deliverable is incomplete. .ololo/apex-lap-speed-done.md does not exist at the task commit, and docs/speed/ is empty, so the four required stills and the participant's own recording are missing. No screencast reached me as frames, so the view change, boost gauge, moving map and ghost on the road are judged from code only. The boost-driver logic (driver.js wantsBoost) is plausible but unverified in motion. Because the brief's required evidence and completion note are absent, I cannot give more than a middling score for the product.
02:34 PM +51m 13s
Andrey avatar
Andrey evaluated by Code Quality on Task 2 +15 points
cleanliness 7.0 The new code is mostly well named and tidy. The boost rules live in named config (config.js CAR.boostDuration, boostRecharge, maxSpeedBoost; DRIVER.boostRoom and related), and lerpPose was moved into vec.js instead of being duplicated. Remaining issues: a few inline literals (car.js `u > -0.1` in stepCar, driver.js `1.5` hysteresis factor in wantsBoost, speedLines.js `0.6`, `0.12`, `z > -2`, carMesh.js flame offsets); `poseAt` returns `lerpPose(poses[0], poses[0], 0)`, which is a copy dressed up as an interpolation; and chaseCamera.js `const { back, height, ...framed } = this.framing(...)` is an awkward rest-destructure to peel fov off. There is no copy-paste of note. No analysis probe was supplied, so duplication was judged by reading only. maintainability 7.0 Layering is sound: the rules (car, driver, ghost, race) are pure sim modules with no DOM, and the UI and render code only read them. The ghost is a pure record with a binary-search poseAt, so it cannot touch contact. Functions are short and nesting is shallow. Weak spots: driver.js `wantsBoost` keeps hidden closure state (`boosting`) that is only updated when `boost` is true, so it can go stale if the flag is switched off and back on. carMesh.js `ghost.children[0].visible = false` relies on the blob shadow being the first child, which is brittle. main.js calls `race.ghostPose` twice per frame (scene.sync and the minimap). The boundary handling is reasonable: touch pointer capture and cancel are handled, and the minimap and HUD guard missing data.
02:34 PM +50m 57s
Andrey avatar
Andrey evaluated by Architecture on Task 2 +18 points
architecture 8.0 The new sim pieces keep the dependency rule. src/sim/ghost.js imports only ./vec.js (lerpPose), with no render, DOM or framework references. The boost lives in src/sim/car.js (updateBoost, speedCap, limitSpeed) and config.js (CAR.boostDuration=3, boostRecharge=10, maxSpeedBoost=270 km/h), and the 72 km/h off-road cap is untouched. The built-in driver's boost choice (driver.js wantsBoost, lowestAhead) is pure sim. Race takes a Ghost and exposes ghostPose(alpha), which the render and minimap read, so the core is not told about the edge. Session now takes an injected race (session.js constructor), which is a clean inversion. The render layer depends inward: chaseCamera.js, scene.js and speedLines.js import sim/vec.js and sim/race state, and the lerpPose helper was moved from render to sim/vec.js, which fixes a render-to-sim direction problem. The ghost is kept out of contact resolution (contact.js is not fed the ghost), so it cannot be in the way. The minimap, HUD and touch input stay in src/ui and only read snapshots. Proportion is sensible for this task: one Ghost class, one SpeedLines module, a fitFov helper, and a PRACTICE rules object, with no extra interface layers. Remaining defects: race.js still imports defaultTrack from world.js (carried over from the earlier round, not fixed). The driver reads runner.car.boostCharge and runner.onRoad, which couples it to the runner's shape. runner.snapshot() still emits km/h for the HUD. Evidence used: source imports and the diff only. No screencast or stills were visible to me, and I did not check the `lap:`/`race:` repeatability probes.
02:34 PM +50m 48s
Andrey avatar
Andrey evaluated by Creativity on Task 2 +13 points
creativity 7.5 Several genuine extra-mile touches go beyond the brief and are wired into the render and sim code. The strongest is the speed-lines layer (src/render/speedLines.js), which streaks past the screen edges from about 140 km/h, turns orange while boosting, and keeps the centre clear. Boost flames on the exhaust (src/render/carMesh.js, boostFlames/updateCar) flicker with the wheel roll. The gauge glows while burning and marks a full charge (src/ui/hud.js updateBoost). The view also widens and drops back smoothly, with a speed lag so bumps and boosts do not jump, and fitFov widens the vertical FOV on phone-shaped screens so more road shows across (src/render/chaseCamera.js). The ghost is a see-through car with no shadow that is recorded pose by pose from the driven lap (src/sim/ghost.js), so it never takes part in contact. Other touches include an overspeed ease-back after a boost, a practice mode, and touch pads that allow several fingers at once. Credit is limited because none of this is visible in a screencast or in this round's stills: the committed stills in docs/race are from the previous round, and no docs/speed folder appears in the tree. The judgement therefore rests on the code. Missing extras: no motion blur, camera shake, or boost sound.
02:34 PM +50m 44s
Andrey avatar
Andrey evaluated by Correctness on Task 1 +36 points
product 7.5 The race is built as a product: a grid of four with the player last, a 3-2-1-GO countdown with the clock held at zero until GO, live place and standings, contact discs, and a results table with finish time, best lap and cars still running. Rivals use the same Runner, LapTracker and physics as the player (src/sim/race.js update(), src/sim/runner.js advance()), so they brake, follow the road and count laps by the same rules. Their pace is a per-rival scale (0.90, 0.97, 1.04) in config.js RACE.rivals, and the results show distinct times (2:06.287, 2:11.996, 2:12.566, Wren still running), not identical ones. The stills match the code: the countdown frame shows 4/4 and lap 1/3 at race 0:00.000, the mid-race frame shows three rivals and the player close together with name tags, and the results frame shows the table with the 'running · lap 3/3' row. The race command runs the same driveRace()/Race as the page (src/sim/headless.js), so the page and command share one module. Deductions: no screencast frames reached me, so motion, the GO start and the place change rest on the stills and code. The results still shows Wren 'running' while the player is already 3rd, which is consistent with the rules. The overtaking and contact logic are only checked by reading code, not by observed behaviour in the stills.
02:20 PM +36m 23s
Andrey avatar
Andrey evaluated by Test Quality on Task 1 +24 points
tests 7.5 The race rules are tested with concrete assertions at the sim level. test/race.test.js covers the grid layout (lines 22-45: four cars, two-by-two, player last, distinct rival names/colours/paces), the countdown with nothing moving before GO (the 'start' block: labels 3,2,1, pose unchanged, clock 0 at GO), rivals completing exactly three laps on the road with zero off-road time, braking for corners (>50 braking samples), finish order strictly increasing, and a fixed-input determinism check ('same race twice'). The position ordering is checked against an explicit laps-then-distance invariant at every step, and the finish block checks the finishers-then-running split and the reset to the grid. test/contact.test.js covers no-touch, push-apart with speed loss, a no-pass-through run over 240 steps, coincident-car separation, and a faster car going round a slower one without leaving the road and without contact. test/cli.test.js runs `scripts/race.js` twice and checks one identical line with laps 3 and four sorted results. Weaknesses: the no-pass-through bound is loose (minGap - 0.6, and the comment admits up to a step of overlap); the braking test threshold is arbitrary; the pace test asserts a 8–12% window, which matches the brief; the 'same race twice' scripted input is only one pattern; the page-side countdown, place readout and results table are not covered by any test in the reviewed files, and no test checks the player's place changing in the HUD. No skipped or hard-coded tests were seen. The gap-to-level-of-the-race coverage is good, while the UI and the 'Enter to race again' path rely on other suites I did not read in full. No probe was needed: the static tests are enough to judge the rule-level coverage.
02:19 PM +35m 55s
Andrey avatar
Andrey evaluated by Code Quality on Task 1 +25 points
cleanliness 8.0 Names mostly say what things are: Race, Runner, LapTracker, planTraffic, resolveContacts, standingsHtml, resultsHtml. The page and the CLI share one Race (src/sim/headless.js driveRace/runRace), so there is no constant-output path. Copy-paste is minimal: the race rules live in race.js, traffic.js and contact.js, not duplicated per entrant. Deductions: src/sim/lap.js still pushes every lap into an unread `this.laps` array, which I faulted in the previous round and which is still there; the rival loop in scripts/record.js reads the same race state several times. No duplication tool was supplied, so this rests on my reading. The round-one flaw about unread history is unfixed, so I am not charging it again beyond noting it. maintainability 7.5 Functions are short and single-purpose: Race.update, standings, results, planTraffic and collide each fit on a screen, and the boundary between sim and DOM is clean (hud.js holds no rules). The Runner/Race split makes the race testable without a browser. Deductions: magic numbers remain in the logic: traffic.js uses 0.5 (speedCap gain), 1 (side threshold in passingSide), and 15 (curvature look-ahead); driver.js uses 0.5 and 1.5 in offsetFactor's clamp and a 0.5 in the speed error. These belong in config.js next to TRAFFIC. The standings sort in race.js builds a four-element key array and walks it with findIndex, which costs comprehension. The 'running · lap' string in hud.js is built inline rather than named. None of these is a defect.
02:19 PM +35m 53s
Andrey avatar
Andrey evaluated by UX Review on Task 1 +21 points
ux 7.5 The stills read clearly at desktop width. The place readout is the top-left headline ('PLACE 3 / 4' in large type, docs/race/3-results.png), the lap counter is gold, and the running order sits in the minimap panel with colour swatches. Rivals are easy to tell from the player's orange car: each has a coloured name tag (Shrike, Wren, Heron) and a distinct body colour (docs/race/2-race-rival.png). The results overlay (docs/race/3-results.png) reads in finishing order with POS, DRIVER, RACE TIME and BEST LAP columns, and the player's row is highlighted. Deductions: the countdown is not visible in the grid still (docs/race/1-grid-countdown.png shows the grid with the place and race clock at 0:00.000 and no '3/2/1' numerals), so I could not confirm from stills that it is 'impossible to miss'. The stacked HUD panels are dense. accessibility 6.0 The results table and standings are real text, not images, and the place is shown as words and numbers, not colour alone. Position changes do use green and red flashes (src/style.css '.flash.gained/.lost'), but the number itself carries the information. The countdown and banners use role=status / aria-live. Contrast problems: the orange demo badge with white 16px text sits near 3:1 (docs/race/2-race-rival.png), and the small muted labels (LAST/BEST, 14px) are low contrast on the translucent panel. The results overlay is a plain table with headers in the page markup. I could not check contrast on the countdown itself because no still shows it. mobile 4.0 No narrow-viewport capture was delivered, so the narrow view could not be seen. The CSS has a max-width:720px media query that hides the map and controls panel and shrinks the speed readout and banners (src/style.css, @media block), which is some evidence of responsiveness. But the times panel stays fixed at 210px wide at the top-left, and the results overlay's fit at 375px and the standings list are untested. Under the no-capture rule this caps at 4.0.
02:19 PM +35m 49s
Andrey avatar
Andrey evaluated by Architecture on Task 1 +26 points
architecture 8.0 The dependency rule holds in the race work. The core (src/sim/race.js, runner.js, traffic.js, contact.js, driver.js, session.js, headless.js) imports only sim modules and config, with no three.js, DOM, or fs imports. The render layer (src/render/scene.js) and the UI layer (src/ui/hud.js, minimap.js) read sim state and never write rules. main.js is the only place where the pieces are wired together. The `race:` CLI (scripts/race.js) calls runRace() in headless.js, the same Race class the page's Session uses, so the command runs the page's rules rather than printing constants. Rules are testable alone: Race, Runner, resolveContacts, planTraffic, and LapTracker all run with no browser. Seams are proportionate to a three-lap race with three rivals: one Runner per car, a traffic planner, a two-disc contact model, and a Race aggregate. Each has a clear owner. Findings: - race.js:1-3 and the `defaultTrack` import from './world.js' tie the race to the time-trial module. The race should not depend on world.js. Moving the default track factory into its own module would clean this up. - race.snapshot() (race.js) returns display-shaped fields (speedKmh, lapTime, countdown label strings, standings with colours). This is a mild presentation leak into the core. hud.js then formats them. The leak is small because the data is plain and the formatting stays in ui/. - The lap rules are shared with the time trial through LapTracker with a startOnLine flag. That is a clean reuse, not a copy. - The rule that finishers are ranked by finish time is in a pure function (standings()), which keeps position logic testable. One line on the lap rules: the rivals use the same LapTracker and gate logic as the player, so no rival counts a lap the player's rules would refuse. The circuit and car rules from round one were not re-scored here. Evidence used: source imports in src/sim/race.js, src/sim/runner.js, src/sim/session.js, src/sim/headless.js, src/sim/traffic.js, src/sim/contact.js, src/sim/driver.js, src/ui/hud.js, src/render/scene.js, src/main.js, scripts/race.js, and the AGENTS.md layout section. I did not use the screencast or stills for this criterion, and I did not run the `race:` command.
02:19 PM +35m 45s
Andrey avatar
Andrey evaluated by Creativity on Task 1 +16 points
creativity 6.5 Several working extras beyond the brief, but the rivals are still the same Firefinch model in different colours, with no shape or livery difference, so the guidance's top priority is only partly met. Extras that work: floating name tags above each rival (scene.js nameTag, shown in 2-race-rival.png), a live running-order list in the minimap panel (index.html standings, visible in all three stills), and a results table with coloured driver dots and 'running · lap 3/3' for cars still out (3-results.png). Also present in code: traffic.js side-picking and braking, finished cars rolling a cool-down lap (race.js), and Enter to race again. No dust, brake lights or sound are visible in the stills or in the code I was shown. Judged from the committed stills and code; no screencast probe was registered.
02:19 PM +35m 40s
Andrey avatar
Andrey started working on Task 2

Make it feel fast

02:19 PM +35m 30s
Andrey avatar
Andrey evaluated by Test Quality on Task 0 +27 points
tests 8.5 The analysis states a score of 8.5 for tests. It credits direct, concrete-value assertions on lap rules (gate geometry, full in-order lap, missed point, wrong-way lap, backwards crossing, reversed finish), car limits (216 km/h cap, 72 km/h off-road hold, no turning on the spot, reversing), fixed-step determinism at 60/20/5 fps, repeatable runLap output, and a CLI repeatability check. It notes gaps: a loose lap-time plausibility bound (30-90 s), a convoluted 'carries wide' radius check, and direct mutation of tracker.lapStart. No skipped or hard-coded tests were seen. No probe was registered; the verdict rests on reading the test files, and no coverage report or test-run output was obtained.
02:04 PM +20m 51s
Andrey avatar
Andrey evaluated by Architecture on Task 0 +27 points
architecture 8.5 The dependency rule holds in the core. Every file under src/sim/ imports only config, vec and sibling sim modules; none imports three.js, the DOM, the file system or a clock (grep of imports in world.js, session.js, headless.js, lap.js, car.js, driver.js, track.js, stepper.js). Time enters only as a `dt` argument, and input enters as plain data `{throttle, brake, steer}`. The page and the CLI share one World and one driver: src/main.js:10 builds Session and src/sim/headless.js:4-16 runs the same World.update with createDriver, so `lap:` is not a constant. Rules are testable without a browser (headless.js runLap returns the JSON; the repeatable 44.249 s output corroborates it). The fixed-step stepper (stepper.js) is pure and drives the page by the clock, not per frame. Boundaries are proportionate for a one-car, one-track task: sim/render/ui are three folders with a single composition point in main.js. Weaknesses: World.snapshot() (world.js:53-70) emits display units (speedKmh, lapTime formatting inputs) and so carries a presentation concern into the core; Session takes callbacks (playerInput, isDemo) rather than an interface, which is adequate here; the driver reaches into world.road/world.car, coupling it to the World shape rather than to a narrow state. Screaming top level: the tree says sim/render/ui, which names mechanisms more than the domain, but AGENTS.md and the file names (lap.js, car.js, track.js) say what the system does.
02:04 PM +20m 49s
Andrey avatar
Andrey evaluated by Creativity on Task 0 +19 points
creativity 8.0 Well beyond the plain brief on the car and the world. The Firefinch is a modelled car, not a box: an extruded side-profile body with a tinted canopy, a centre stripe, rear wing and stays, splitter, headlights, tail lights, a number panel, a diffuser and four steering, rolling wheels (src/render/carMesh.js:10-79). The circuit is dressed with red-and-white kerbs, posts that stream past to show speed, lettered point signs on the outside of each bend, a start gantry with a title banner, a grandstand, marsh pools, about 420 instanced trees in four shades, flat-shaded hills, and a gradient sky dome with fog (src/render/scenery.js, src/render/scene.js:20-35). The HUD adds a minimap, a gear readout, a 'best lap!' banner and an off-road banner, and demo mode has a take-back prompt. The stills show these working: the start-line still shows the gantry, grandstand and posts; the lap-complete still shows the 'Lap 0:44.249 – best lap!' banner and the minimap. I did not see a screencast, so the motion and the lap count at the line rest on the stills and the 'lap' output. The gap from the top score is that the world is pleasant rather than memorable, and the car is clean but not especially distinctive.
02:04 PM +20m 40s
Andrey avatar
Andrey evaluated by Code Quality on Task 0 +25 points
cleanliness 8.0 Naming is mostly precise and matches the domain: `crossGate`, `LapTracker`, `speedProfile`, `stepCar`, `nearest`, `ribbonGeometry`. The sim layer (`src/sim/*`) has no three.js or DOM imports, and render and UI sit in separate folders. Duplication is low: `ribbonGeometry` is reused for kerbs, edge lines and asphalt (`src/render/trackMesh.js:16`), and `instanced`/`matrixAt` are shared helpers in `scenery.js`. Deductions: a few one-off magic gains in the driver (`0.6`, `0.4`, `0.25` in `src/sim/driver.js`), and `LapTracker.laps` is an array that is pushed to but never read by the page or the CLI (`src/sim/lap.js`, `crossStart`). No analysis probe metrics were supplied, so this rests on reading the code. maintainability 7.5 Functions are short and the rules are easy to follow: `stepCar` is split into `yawRate`, `pedalAccel` and `limitSpeed`, and `config.js` names the car, road and driver numbers. The fixed-step loop is clean: `FixedStepper.advance` plus `World.update` run on the clock, and `headless.js` shares `World` and `createDriver` with the page, so the `lap:` line is not a constant. Lap-rule edge cases (wrong-way cancel, missed point, half-open gate test) are handled at the boundary in `crossGate` and `crossStart`. Drag: `Track.nearest` is a linear scan over every sample on each step, and the `scenery.js` builders carry many inline numeric literals (tree and hill sizes, grandstand dimensions) that are not named. `Controls.keyDown` mixes the binding lookup with the command dispatch. Nesting stays shallow throughout.
02:04 PM +20m 37s
Andrey avatar
Andrey evaluated by Correctness on Task 0 +41 points
product 8.5 The committed product meets the brief's core scenarios as far as the code and the attached evidence show. The car has grip-limited bicycle physics with a 216 km/h road cap and a 72 km/h off-road hold (src/sim/car.js, src/sim/config.js CAR). Steering scales with speed, so there is no turning on the spot. Lap rules use forward-only ordered gates at B…L and a start-line gate that cancels on a wrong-way crossing, so cutting the infield or crossing backwards does not count (src/sim/lap.js crossGate, crossStart). The HUD shows speed, lap, time, last and best, and off-road state. Demo mode and the fixed 1/120 s stepper driven by the clock are present (src/sim/stepper.js, src/main.js). The headless lap is 44.249 s, which is plausible for about 1.1 km. The attached screenshots show a 3D chase view, a chequered start line, kerbs, a lap counted as 'best lap', and speed of 49 and 136 km/h. The 'The lap repeats' check reported the same line on every run. Deductions: I did not receive the demo screencast frames, so motion was judged from the code and stills. The 'lap:' path is shared through the World/driver modules, which I did not fully trace. The stepper's maxFrameTime of 1 s silently drops time on very long gaps. The completion note's claims about the mobile layout and the demo lap were not independently verified.
02:04 PM +20m 35s
Andrey avatar
Andrey evaluated by UX Review on Task 0 +22 points
ux 8.0 Stills show a clear 3D chase view with the car centred and the road, kerbs and grass clearly separated (docs/demo/1-start-line.png, 2-mid-corner.png). Speed is a large bottom-right readout (84px, index/style.css .speed), and the lap, time, last, best and next point sit in a fixed top-left panel that does not cover the road ahead. The lap-complete banner in 3-lap-complete.png is centred and brief. Deductions: the speed readout is smaller than ideal for a glance, and the off-road banner was not visible in any still. accessibility 6.0 The page declares lang="en" and uses labelled sections and role="status" for the banners (index.html:1-2, 10, 19-20). Text is real HTML, not baked into images. Contrast is good for the white values on the dark panels. The orange demo badge with white 16px text is borderline on the sky and grass, and the muted grey labels are small (14px). Speed and lap state rely on colour in places (gold values, red off-road banner) with no extra text cue. mobile 4.0 No narrow-width screenshot was delivered, so the layout at about 375px was not seen. The CSS does have a 720px media query that hides the minimap and controls help, shrinks the speed readout and wraps the banners (style.css:221-237), so the layout is responsive in principle. The four-row times panel plus speed readout are not verified to fit a narrow screen, and that capped the score.
02:04 PM +20m 31s
Andrey avatar
Andrey started working on Task 1

Race the rivals

02:03 PM +20m 16s
Andrey avatar
Andrey started working on Task 0

Build the car and the circuit

01:43 PM +0s