# Scaling Fish-Networking for High-Player Browser IO Experiences

*A hands-on browser-first playbook using multi-condition AOI, Bayou WebSockets, tick tuning, and multi-NetworkManager load balancing*

![Scaling Fish-Networking for High-Player Browser IO Experiences](https://pub-07fb5e4955ba485b822d6b388be96d9a.r2.dev/627e11da-a23a-494d-9964-843e8f31c507/scaling-fish-networking-for-high-player-browser-io-experiences/hero-444bf48d-25e6-4e8e-9c2c-a6360ea21a9e.jpg)

**TL;DR:**

- FishNet features no CCU caps or paywalls, allowing completely free self-hosting or custom cloud deployments.
- At 200 CCU, FishNet retains 92.6% server performance and uses up to 78% less bandwidth than older alternatives like Mirror.
- By avoiding quadratic (n²) network scaling, FishNet has been proven in production to support over 1,000 concurrent players.
- The Bayou transport enables seamless, high-performance WebSocket and secure WSS communication for Unity WebGL exports.
- Using FishNet's unique multi-condition Area of Interest system drastically reduces bandwidth by only sending relevant data to active observers.

Building a successful browser-based IO game requires balancing massive player counts with the strict technical limitations of WebGL and WebSocket communication. Traditional networking frameworks often struggle under these constraints because without optimization, multiplayer traffic scales quadratically; every player update must be sent to every other player. This **n²** scaling behavior quickly overwhelms both server CPU capacity and browser network threads. To deliver the seamless, high-density experience that IO players expect, developers need a networking solution designed from the ground up for extreme efficiency and low overhead.

This is where **Fish-Networking** (FishNet) excels as a premier choice for browser-first multiplayer in Unity. Unlike alternative frameworks that impose restrictive pricing models, FishNet features **no CCU caps** or paywalls, allowing developers to self-host or use any server host they choose. In performance benchmarks at 200 CCU, a FishNet server retained **92.6%** of its performance while older frameworks like Mirror retained only 16.8%, while simultaneously using 67% to 78% less bandwidth. Even under lighter loads of 100 CCU, a FishNet server lost a mere **1.5%** of its performance. This efficiency makes it entirely feasible to support **1,000+** concurrent players in production on standard cloud infrastructure.

By mastering FishNet's advanced features—including its multi-condition Area of Interest (Observer) system, the Bayou WebSocket transport, precise TimeManager tick tuning, and multi-NetworkManager topologies—you can bypass browser limitations and scale your IO game to support **dozens to hundreds** of active players per room. This playbook details the exact architectural steps required to optimize your game for high-performance browser deployment.

## Why Fish-Net is the Ultimate Engine for High-Player Browser IO Games

For browser-based IO games, operational sustainability hinges entirely on server efficiency. Traditional multiplayer solutions often impose artificial limitations, but with Fish-Networking, developers face **no CCU caps or CCU paywalls**. Because you can use any server host you prefer—including self-hosting, dedicated instances, or player-hosted topologies—you retain absolute control over your infrastructure overhead.

Benchmarking Efficiency: FishNet vs. Mirror

In high-density environments, the difference in resource consumption between networking libraries is stark. When scaled to 100 concurrent users (CCU), FishNet's server loses a mere 1.5% of its performance. As the player count doubles to 200 CCU, FishNet maintains an incredible 92.6% server performance, while older solutions like Mirror collapse to just 16.8% performance. This efficiency is driven by a massive reduction in data overhead; benchmarks show FishNet uses 67% to 78% less bandwidth than Mirror, sending only about 0.55 MB (adjusted) per second at 100 CCU compared to Mirror's 30.2 MB.

A Production-Ready Feature Set for Open Worlds

Achieving a smooth, responsive feel in a browser window requires more than just raw bandwidth savings. FishNet provides a suite of advanced, built-in features that are crucial for fast-paced IO mechanics:

**Client-Side Prediction & Reconciliation:** Eliminates perceived latency for player movement, making the browser game feel local.**Latency Compensation:** Ensures hit registration and fast-paced interactions remain fair, even under unstable Wi-Fi connections.**Server Load Balancing:** Distributes network processing loads across multiple cores or managers to prevent single-thread bottlenecks.**Nested Network Objects & Delta Compression:** Allows complex entity hierarchies to be synchronized while sending only the properties that actually changed.

By combining zero-allocation architecture with native support for complex synchronization, FishNet lets you deploy highly competitive, fast-paced browser worlds without hitting the performance walls that typically plague WebGL multiplayer projects.

## Connecting Browsers Reliably with Bayou WebSockets

Deploying a high-player IO game directly to the browser requires a transport layer that bypasses traditional UDP limitations. Because WebGL builds cannot open raw UDP sockets, your architecture must rely on WebSockets to establish stable, low-latency client-server pipelines. This is where Bayou becomes the critical bridge for your Unity multiplayer stack.

Bayou is the dedicated WebGL transport for Fish-Net, evolved from the reliable SimpleWebTransport to enable seamless browser communication via WebSockets. It is not bundled with the core package, so it must be downloaded separately as a dedicated addon. By integrating Bayou into your transport configuration, you unlock a highly optimized pipeline tailored specifically for WebGL's unique networking sandbox.

Securing Production Connections with WSS

When moving from local development to production, browser security policies strictly forbid unencrypted WebSocket connections (ws://) from pages served over HTTPS. Bayou fully supports secure WebSockets (wss://), which is essential for ensuring your browser builds connect reliably in the wild. Correctly configuring your SSL/TLS certificates on the hosting server or utilizing a reverse proxy is necessary to prevent browsers from blocking your network traffic.

Beyond basic encryption, basic firewall and proxy awareness is vital. Many corporate networks, public Wi-Fi hotspots, and school firewalls aggressively block non-standard ports. Routing your WebSocket traffic through standard web ports (like 443 for HTTPS/WSS) prevents these middleboxes from dropping your players' connections, eliminating the most common WebGL multiplayer connection failures before they can impact your CCU metrics.

## Taming the Quadratic Curve: Cutting Bandwidth with Multi-Condition Interest Management

Ensuring a stable connection is only half the battle. Once players are connected via secure WebSockets, the next critical hurdle is managing the sheer volume of data flying across the network. In a naive multiplayer architecture, every player's position, rotation, and action must be broadcast to every other player on the server.

The Threat of Quadratic Scaling

Without interest management, network traffic scales quadratically (**n²**) because every single player update must reach every other active player. In a high-player browser IO game targetting hundreds of concurrent users, this exponential growth quickly saturates both client bandwidth and server CPU, rendering the game completely unplayable. The golden rule of multiplayer optimization is straightforward: do not transmit what a client does not need to see.

How Fish-Net Defines Observers

Fish-Net solves this bottleneck through its highly optimized Area of Interest (AOI) system, which revolves around the concept of "observers." In this paradigm, an observer is defined as any client that can actively see a given NetworkObject and receive its network communications. Conversely, if a client is not registered as an observer of an object, that object will not activate on their client, and they will receive absolutely zero network messages or state updates for it. This selective visibility not only acts as a powerful anti-cheat mechanism by preventing clients from receiving data about hidden entities, but it also drastically reduces server bandwidth and processing overhead.

Unlocking Multi-Condition AOI

Unlike older networking frameworks like Mirror, which limit developers to single-condition visibility checks, Fish-Net's advanced AOI system allows multiple conditions to run simultaneously. You can blend several rules together to form sophisticated visibility profiles:

**Distance-Based:** Restricts updates to a radial zone around the player's camera.**Scene-Based:** Isolates network traffic to specific virtual zones or rooms.**Team-Based:** Limits sensitive updates to allied players only.**Custom Rules:** Tailors visibility based on game-specific mechanics like fog-of-war.

By combining these conditions, your server only processes and transmits the absolute minimum dataset required for each active browser tab, keeping WebGL performance smooth and server hosting costs predictable.

## Optimizing TimeManager Tick Rates for Browser Constraints

However, filtering who receives data is only half the battle; the other half is controlling how frequently that data is processed and dispatched.

In Fish-Net, this pacing is governed by the TimeManager. The tick rate represents the average number of times per second that tick events are invoked and how often data is sent or received across the network. While desktop builds can comfortably handle high-frequency updates, browser-based WebGL clients are significantly more sensitive to rapid network events. High tick rates overwhelm the browser's single-threaded WebGL execution context and quickly saturate WebSocket connections. For IO games, tuning this tick rate down to a conservative rate—combined with delta compression—keeps traffic light and manageable without sacrificing responsiveness.

When you lower the tick rate to protect browser bandwidth, ensuring smooth movement and interaction requires robust prediction. If you are implementing client-side prediction to mask this lower frequency, your physics configuration must align with Fish-Net's timing loop. Specifically, the physics mode in your project settings must be set to TimeManager. This ensures that the physics simulation steps in perfect synchronization with the network ticks, allowing the client to predict and reconcile physical interactions accurately despite the constrained browser environment.

## Responsive WebGL Gameplay: Mastering Client-Side Prediction

Perfectly aligning your physics simulation with network ticks sets the stage for the ultimate browser-based user experience: instantaneous movement response. In fast-paced IO games, even minor network latency can make a game feel sluggish or unplayable. This is where client-side prediction becomes mandatory, allowing the player's local inputs to execute immediately on their screen while the server validates the movement in the background.

Historically, implementing robust prediction and reconciliation required writing thousands of lines of complex custom rollback code. Fortunately, FishNet is the only free solution providing built-in client-side prediction with only a few lines of code, offering developers a production-ready framework out of the box.

The Tick-Based Prediction Core and Smoothing Components

At its heart, FishNet features a highly optimized, tick-based core designed for accurate simulation. When a client predicts their movement, the server processes those same inputs on the corresponding tick. If the server's calculated position differs from the client's predicted position, a reconciliation occurs, snapping the client back to the authoritative state.

To prevent these corrections from looking jarring to the player, FishNet includes dedicated components for handling desynchronization smoothing and rigidbody prediction. These components automatically interpolate the visual representation of the player avatar back to its corrected physical position, masking minor corrections and keeping the gameplay fluid even on unstable browser connections.

Balancing Prediction with Browser Constraints

To scale an IO game to hundreds of concurrent users, client-side prediction must not run in isolation. Instead, it must be combined strategically with the optimizations we have already established:

**AOI Integration:** Only predict and reconcile entities within the client's immediate Area of Interest to save local CPU cycles.**Sensible Tick Rates:** Run the TimeManager at a balanced tick rate so the client's prediction loop doesn't overwhelm the single-threaded WebGL environment.**Bandwidth Management:** Keeping network payloads small ensures that server reconciliation data arrives swiftly, preventing large, noticeable position rollbacks.

## Architecting for Scale: Load Balancing and Production Deployments

Even with optimized tick rates and tight payloads, a single server instance eventually hits its physical limits when hosting massive browser IO games. To push past these hardware bottlenecks, developers must think beyond the traditional single-server architecture. Fortunately, FishNet's architecture is uniquely suited for horizontal scaling and complex distributed topologies.

Multi-Manager Topologies and Load Balancing

One of FishNet's most powerful architectural advantages is its native support for multiple concurrent network instances. FishNet allows an infinite number of NetworkManagers to run simultaneously within the same client execution loop. This means WebGL clients can connect to multiple distinct servers at once, delegating different responsibilities—such as chat, global matchmaking, persistence layers, or distinct regional game worlds—across specialized server instances.

By distributing the load, you prevent any single CPU thread from becoming a bottleneck. While one server handles the physics-heavy local combat simulation, another can manage inventory transactions or player matchmaking lobby states.

Keeping CPU and Garbage Collection in Check

Distributing the network load is only half the battle; the local server must also process local entities efficiently. High-player IO games feature rapid entity spawning and destruction, which can quickly trigger garbage collection (GC) spikes and tank server frame rates. To maintain optimal performance, developers should pair multi-manager setups with the following built-in optimizations:

**Built-In Object Pooling:** Eliminates the runtime overhead of instantiating and destroying GameObjects by recycling inactive entities.**Delta Compression:** Drastically reduces bandwidth usage by only transmitting the differences between frame updates rather than full object states.

Proven Production Viability

These scaling techniques are not merely theoretical. In real-world production environments, FishNet has successfully supported 1,000+ concurrent players in a single, fully server-authoritative environment deployed on AWS infrastructure. By leveraging these combined strategies, developers can confidently build, launch, and scale highly responsive WebGL IO titles that remain cost-effective even under massive player loads.

## Conclusion

- FishNet Performance Advantage — Offers unmatched server performance retention and low bandwidth usage compared to traditional WebGL networking engines, making it the ideal choice for high-player browser games.
- Bayou Transport Security — Requires secure WSS protocols and port 443 standardization to reliably connect WebGL clients and bypass strict browser security and firewall restrictions.
- Multi-Condition Interest Management — Combats quadratic network scaling by combining distance, scene, and custom observer rules to drastically reduce unnecessary data transmission.
- TimeManager and Prediction Tuning — Achieves responsive gameplay on WebGL clients by balancing tick rates and utilizing FishNet's built-in client-side prediction and desynchronization smoothing.
- Multi-NetworkManager Load Balancing — Enables scaling to thousands of concurrent players on cloud infrastructure by distributing workloads across multiple NetworkManagers and leveraging object pooling.

Supercharge your browser-based multiplayer projects today by exploring our suite of highly optimized Unity URP and performance-scaling tools at bigfatgames.com.

## Frequently Asked Questions

### How many concurrent players can FishNet support in a browser environment?

With proper optimization, FishNet has been used in production to support **1,000+** concurrent players using server-authoritative networking on cloud infrastructure. Its efficient tick-based core and built-in bandwidth optimization make it highly scalable for browser-based IO games.

### Does FishNet charge licensing fees for high player counts?

No, there are **no CCU caps** or CCU paywalls in FishNet. Developers are free to host their game servers on any hosting provider, self-host, or utilize player-hosted topologies without paying licensing fees.

### How does FishNet's performance compare to older frameworks like Mirror?

In benchmark tests at 200 CCU, the FishNet server retained **92.6%** performance while Mirror retained only 16.8%. Additionally, FishNet consumed 67% to 78% less bandwidth than Mirror, making it far better suited for the resource-constrained nature of web browsers.

### What transport should be used for Unity WebGL exports in FishNet?

**Bayou** is the dedicated WebGL transport for FishNet, evolved from SimpleWebTransport. It must be downloaded separately and enables seamless browser communication using WebSockets and secure WSS protocols.

### How does FishNet prevent network traffic from scaling quadratically?

FishNet utilizes an advanced **Area of Interest (Observer)** system that allows multiple conditions to run simultaneously. This ensures that clients only receive network updates for objects they can actively see, dramatically reducing server CPU load and bandwidth.

## Sources

- [https://hackernoon.com/unity-realtime-multiplayer-part-8-exploring-ready-made-networking-solutions](https://hackernoon.com/unity-realtime-multiplayer-part-8-exploring-ready-made-networking-solutions)
- [https://fish-networking.gitbook.io/docs](https://fish-networking.gitbook.io/docs)
- [https://fish-networking.gitbook.io/docs/overview/readme/features/performance/fish-networking-vs-mirror](https://fish-networking.gitbook.io/docs/overview/readme/features/performance/fish-networking-vs-mirror)
- [https://fish-networking.gitbook.io/docs/fishnet-building-blocks/transports/bayou](https://fish-networking.gitbook.io/docs/fishnet-building-blocks/transports/bayou)
- [https://fish-networking.gitbook.io/docs/overview/readme/features](https://fish-networking.gitbook.io/docs/overview/readme/features)
- [https://fish-networking.gitbook.io/docs/guides/features/observers](https://fish-networking.gitbook.io/docs/guides/features/observers)
- [https://discussions.unity.com/t/unsure-which-networking-solution-to-choose-fish-net-or-dotsnet/1552409](https://discussions.unity.com/t/unsure-which-networking-solution-to-choose-fish-net-or-dotsnet/1552409)
- [https://fish-networking.gitbook.io/docs/fishnet-building-blocks/components/managers/time-manager](https://fish-networking.gitbook.io/docs/fishnet-building-blocks/components/managers/time-manager)
- [https://oceanviewgames.co.uk/technologies/fishnet](https://oceanviewgames.co.uk/technologies/fishnet)