A 1v1 race in Powderline starts with a link. You press 1V1 RACE, the game hands you an invite, you send it to a friend however you like, and a few seconds later the two of you are standing on the same start line of the same endless mountain. There is no matchmaking queue and no game server in between. This is what happens after the link is opened: how the browsers find each other, why the mountain never crosses the wire, and what it took to let the riders touch.
Two browsers, talking directly
Once your friend opens the link, the two browsers connect to each other with WebRTC, the same technology video calls use. A public broker introduces the two pages once; after that handshake it sees none of the race. The race itself travels on two channels. A reliable, ordered one carries the things that must arrive exactly once: the lobby handshake, the clock sync, the start and the finish. An unreliable one carries each rider's position about fifteen times a second, because a lost position is stale the moment the next one arrives and resending it would only add delay.
Not every network lets two browsers connect directly. Some offices, schools and mobile carriers block it, and for a long time the result was simply a race that never started. The fallback that was meant to catch those cases, a relay, depended on public relay servers that had quietly stopped existing, so in practice races only connected on friendly networks such as two people on the same Wi-Fi. Races now come with a working relay of their own, run through Cloudflare's network: when a direct connection is not possible, the two browsers route the race through it instead. It adds a little delay, but the race runs. The help page covers connections that still will not link.
The same mountain, twice
The obvious way to build a multiplayer race would be for one machine to own the world and send it to the other. Powderline does not need to, because its mountain is not stored anywhere: it is computed from arithmetic. Ask two machines for the same stretch of slope and they build the identical terrain, every ice patch, tree and kicker in the same place. So nothing about the world is sent at all. The only shared state in the whole race is the two riders.
Each browser runs a complete simulation of its own rider and is the authority over that rider alone. You decide where you are; your friend decides where they are. That has a useful consequence: a bad connection can make your rival look jittery, but it can never make your own riding lag, because nothing you do waits on the network.
Drawing your rival where they are now
A position report is old by the time it arrives: it spent part of a second travelling between the two browsers. Drawing the rival exactly where their last report said would put them a few metres back up the hill from where they really are, which is unfair the moment riders can collide.
So the game does two things with the stream of reports. First it smooths over the gaps, interpolating between the reports either side of a moment slightly in the past, so a lost or late packet shows as nothing worse than a shorter blend. Then it carries that smooth position forward to the present. The two browsers measure how long their messages take to cross, and the rival is projected ahead by that delay, following the turn they are carving and the arc of a jump under gravity, so a rider mid-carve keeps carving and a rider in the air keeps falling. When a new report disagrees with the projection, small corrections are absorbed smoothly over a few frames. Large ones, such as the rival respawning after a wipeout, jump straight there rather than sliding across the snow.
When two riders touch
Until this week the rival was a ghost you could ride straight through. Now the riders collide, and the hard part is not the physics but agreeing on it, because there are two versions of the truth: yours and theirs.
Each browser checks its own rider against the rival exactly as it draws them, and only ever moves its own rider. When a touch happens, whichever side sees it first tells the other, and the other side checks the claim against its own view before acting on it. So both riders feel the same bump even when one screen missed it by a hair, and neither browser can push the other rider around on its own say-so.
What a bump does
- Lean into someone and you are both shoved apart and lose a little speed.
- Cut hard across their line, or ram them from behind much faster than they are going, and you both go down. Ramming costs the rammer as much as the victim, so it is never a free way to win.
- Jump high enough and you sail clean over them.
- A rider who has just dropped back in after a wipeout cannot be hit for a moment, so a crash is never followed by a second one.
- Once one of you has crossed the finish, the other can no longer be knocked about.
The rules are deliberately symmetric: contact costs both riders, which keeps a race about riding. The changelog entry has the short version.
A finish line worth crossing
The race used to end between two red poles under a chequered strip. It now ends under a finish gantry built the way a real one is built, to the standard we hold every asset in the game to: what you would expect from a big-budget snowboarding game, not a prototype. Two towers of aluminium box truss, with their lacing, couplers and corner blocks, carry a beam across the run. Their feet are padded and weighed down with ballast, bedded into drifts made from the hill's own snow so nothing sits on the slope like a dropped prop. A FINISH banner is tied on under the beam, feather flags stand beside the towers, floodlights hang off the truss, photocell posts mark the line, and a red dye line runs across the snow between them.
On top of the beam a timing board runs your race clock live and holds your time once you cross. The towers are solid, so you ride between them, not through them. The changelog entry and the races guide cover the rest, including the trick battle, where the clock is the finish and the higher score wins.
How it is tested
Network features are easy to get right on one machine and wrong everywhere else, so races are tested the way they are played: two real browsers, each with its own rider, connected over the live relay rather than a simulated one. A scripted race checks the whole chain end to end. The link comes up, both sides see GO together, the rival is drawn close to where they really are, the finish gate stands across the course with its clock running, a gentle swipe shoves both riders apart, a hard crossing takes both down, and a rider who has just dropped back in cannot be hit. Every one of those has to pass before a change to racing ships.
The rest of this week's work is in A week on the mountain. The quickest way to see all of it is to send a friend a link.
