How Big Walk’s Netcode Secrets Unleashed a Million Sales - Gematsu

The secret behind Big Walk's million-unit launch isn't just whimsical design-it's a masterclass in real-time multiplayer synchronization and low-latency voice integration that every mobile and game developer should study.

Last week, publisher Panic and developer House House announced that Big Walk, their cooperative walking-and-talking adventure, sold over one million copies in just six days. On the surface, this is an indie success story-a calm, artful game striking a chord with players hungry for genuine connection. But if you peel back the pastel hills and minimalist UI, you'll find a tightly engineered technical core: a real-time networked experience that synchronizes two players' movement, state and voice seamlessly across unpredictable consumer internet connections. As a senior engineer who has built location-based mobile collaboration apps, I'm not just impressed by the sales numbers-I'm fascinated by the distributed systems and netcode choices that made that launch scale so gracefully.

Today, we're going beyond the headline to dissect the engineering behind Big Walk. We'll examine the networking models that could underpin such a cooperative experience, the voice architecture that melds walkie-talkie intimacy with spatial presence. And the observability practices that kept a million-player flood from cratering the servers. Whether you're building a multiplayer mobile game, a real-time social app, or an IoT dashboard, the lessons here are immediately applicable. So let's lace up our virtual boots and walk through the system design.

From Untitled Goose Game to Networked Walking: A Technical Leap

House House first captured the world's attention with Untitled Goose Game, a single-player, physics-driven comedy title built in Unity. Moving from a solitary goose to a fully networked cooperative experience required a complete reimagining of their tech stack. While the studio hasn't published a post‑mortem yet, a few architectural inferences can be drawn from publicly available talks they gave at GDC and from the observable behavior of Big Walk. The jump mirrors challenges we face in mobile app development when adding real-time collaboration to a once‑offline product.

The core problem is state synchronization. In a typical single‑player game, the game loop runs locally and every animation, environmental event. And UI change is driven by the local player's input. Add a second player. And you instantly need to reconcile two different views of the world across variable‑latency connections. House House likely started with Unity's Netcode for GameObjects (NGO) or a mature third‑party solution like Photon or Mirror, then heavily customized it. The result feels as fluid as a shared single‑player game-no mean feat.

Why Big Walk's Cooperative Design Demands a New Netcode Mindset

Cooperative walking might sound low‑tech compared to a 64‑player battle royale. But the technical requirements are deceptively tricky. In a shooter, clients can use heavy prediction and correction-if a player jitters slightly, nobody notices. In Big Walk. Where the entire emotional experience hinges on staying physically together and talking, any visible desynchronization breaks the magic. You can't just teleport a companion back; players must see a smooth, continuous shared locomotion.

To achieve this, the developers probably implemented a form of deterministic lockstep or a heavily smoothed server‑authoritative model. In deterministic lockstep, both clients simulate the same frame using synchronized inputs; only the inputs travel over the network. Which keeps bandwidth minimal. But it's fragile-any clock drift or input loss causes divergence. A more robust architecture, and the one I suspect House House used, is a client‑server model where the server maintains the canonical state of the walkers, sending regular updates to each client, while each client runs local interpolation to smooth the remote player's position. This is akin to the Snapshot Interpolation used in multiplayer engines like Valve's Source or Unreal Engine's replication system.

Choosing the Right Networking Transport: UDP, TCP, or Both?

Game networking almost always settles on UDP (User Datagram Protocol) because it avoids the head‑of‑line blocking and unnecessary retransmissions of TCP. Voice and movement data are especially sensitive to stale information; a delayed position update from two seconds ago should be discarded, not resent. It's highly likely that Big Walk uses a custom reliable‑UDP layer built on top of libraries like ENet, RakNet, or Unity's own Transport Layer API, which provides both reliable and unreliable channels.

For the "talking" part, the game might use separate transport entirely-WebRTC over UDP or a dedicated voice chat service. In our mobile apps at Denver Mobile App Developer, we combine a reliable‑UDP library for real‑time collaboration events with a separate WebRTC data channel for voice, gaining fine-grained control over each stream's per‑packet priority. This dual‑channel approach is consistent with what Big Walk likely does: the walking state updates over one prioritised pipe and high‑bitrate audio over another, all multiplexed through a central relay server or direct peer connection when possible.

Voice Communication: More Than Just a Walkie‑Talkie Feature

The game's signature mechanic is "talking while walking. " From a pure feature perspective, that's voice chat. But the way Big Walk integrates voice feels less like a VOIP add‑on and more like a spatial, always‑on companion. Implementing spatial voice typically involves adding 3D attenuation and panning so that voices sound like they're coming from the other character's position. This requires low‑latency audio encoding, ideally using Opus codec via WebRTC. And a real‑time mixing engine inside the game client.

If we were to replicate this on mobile (where 5G and Wi‑Fi 6 are making spatial audio viable), we'd turn to the WebRTC API and its Opus support. On Unity, the Vivox library provides integrated 3D voice with a WebRTC-like stack. But House House might have rolled a custom WebRTC integration to avoid licencing costs and retain control. The audio stream itself is sensitive to the same network impairments as the walking sync. So the engineering team likely streams voice over a separate media track with forward error correction (FEC) and packet loss concealment, as outlined in RFC 3550 (RTP)The result is that even on dodgy Wi‑Fi, you hear your friend clearly as you meander through the hills.

State Machines, Determinism, and the Dance of Two Walkers

Behind the serene visuals, every interaction between the two characters is governed by a stack of state machines. Consider a simple act like one player turning to look at a bird: that rotation must be communicated, interpolated. And possibly even deterministically animated on both clients to avoid the "skating" effect. A common technique is to define an authoritative motion state on the server, stream the compressed state (position, rotation, animation blend weights) at a fixed tick rate (e g., 20-30 Hz), and let clients apply Hermite curve interpolation to smooth the motion between updates.

In mobile engineering terms, this is no different from syncing a shared whiteboard or a live GPS marker on a map. We regularly use similar interpolation when displaying a friend's location in a ride‑sharing app-except here, the tolerance for error is measured in millimetres of visual offset, not meters. The state machine also needs to handle disconnection gracefully: if your walking partner drops out, the game must pause or seamlessly transition to an AI companion without jarring the remaining player. This graceful degradation is something many mobile apps get wrong; credit to House House for nailing it.

The Server‑Side Challenge: Scaling a Million Walkers in Under a Week

Six days to a million copies sold means a massive concurrent player spike. Even if average session length is just 30 minutes, the launch day peak likely hit tens of thousands of simultaneous two‑player sessions. Each session requires a persistent server instance or at least an allocated relay with state management. The publisher Panic is known for robust infrastructure (they host the Playdate catalogue, after all). So I'd bet on a cloud‑native architecture using Kubernetes clusters on AWS or GCP, with each game session running inside a lightweight container that spins up and down dynamically.

For the network relay, they might use something like Agones, an open‑source game server orchestrator. Or a custom matchmaking and relay service. The key numbers: each session generates roughly 2-3 KB/s of movement state updates and 10-15 KB/s of compressed voice. So a 10,000‑session peak demands about 150-200 Mbps of sustained bandwidth. That's manageable, but the real scaling challenge is connection scheduling and stateful server lifecycles-problems every mobile backend team knows intimately. If they did this without major outages, I tip my hat to their SRE practices.

Observability and LiveOps: Monitoring a Living Virtual Park

With that many sessions, telemetry becomes critical. A launch of this scale demands distributed tracing, real‑time alerts on matchmaking queue depth. And audio bitrate dashboards. The engineering team likely deployed the OpenTelemetry standard, emitting traces from the game server, voice relays, and even client‑side (via Unity's logging). Aggregated in tools like Honeycomb or Datadog, these traces let the on‑call team pinpoint exactly where latency spikes occur-whether it's in the relay's initial connection handshake or during a sudden spike in voice packet retransmissions.

In our mobile multiplayer projects, we've found that instrumenting the client as heavily as the server pays off when debugging issues that only occur on certain device‑network combinations. For Big Walk, since the PC and Mac client experiences are homogeneous, they may have focused more on server‑side metrics. But the same principles hold. Observability is what lets a small indie team support a million‑player game without melting down-something every mobile developer building real‑time features should prioritize from day one.

Could Big Walk's Technology Work on Mobile Today?

As a mobile app developer, the natural question is: can this exact experience run on iOS and Android? The short