Real-Time Games: How To Build A Real-Time Multi-User Unity Game From Scratch

Community is one of the strongest ties video games can offer to keep players engaged. So it stands to reason that many business people with a game idea would be interested in how to make a multiplayer game from scratch. If you’re reading this, you’re probably one of them, and you’re in the right place.

We’ve built multiplayer games before, here at Mind Studios Games. There’s CyberHero, our sci-fi RPG PvP third-person shooter; and we also have a racing game for children — Beetle Riders — where players can compete with friends as well as race against AI-generated opponents. So we’re not strangers to integrating multiplayer functionality into mobile games.

Whichever game idea you have, with an experienced team of game developers by your side, it will be quite easy to select a workable architecture for multiplayer game development. And in this article, we’ll be offering some pointers for those who have an idea and wish to know more about the process to build real-time multiplayer games so that you don’t go in blind.

Key takeaways:

• 77% of all gamers play multiplayer games, as per Unity’s 2022 report;
• According to Uswitch 2023 study, about 46% of players in the UK prefer multiplayer games over single-player ones;
• Multiplayer games show high engagement and retention rates in part due to community building and competition elements;
• Multiplayer functionality can be implemented in a number of ways, depending on the game’s genre and type;
• Among the challenges unique to multiplayer games are the networking functionality and synchronization;
• Mobile games with multiplayer functionality require more effort put into optimization and testing.

Building a real-time multiplayer mobile game

Building a multiplayer game is, in many ways, similar to building any other game, and many steps overlap. At the same time, planning for multiplayer functionality also means certain things will be different — some to a degree, others completely. In this section, we’ll briefly walk you through the real-time multiplayer game development process the way we usually do it, and we hope this information will be of help to you.

Step 1. Concept and planning

The very first thing to do in any type of game development is defining the game concept. You need to choose the game's genre, mechanics, and overall theme. There are plenty of options for real-time multiplayer game development:

• Massively multiplayer games (MMOs), where players are always in multiplayer mode and will randomly meet in-game, usually in open world;
• Location-locked battle multi-user games, where players get into a party, drop onto a map (limited area, but sizes vary), and compete till the last one team/player standing — typically used in real-time shooter games, both third- and first-person, MOBA, and Battle Royale;
• Real-time strategy (RTS) games, where players develop plots of land into cities and kingdoms, and occasionally clash with other players for conquest;
• Survival and sandbox games, where cooperation is necessary to beat the odds;
• Co-op modes and multiplayer mini-games in single-player games, where players can come together to scavenge materials or beat a difficult opponent;
• Player-versus-player (PVP) tabletop online games — card games, chess, mahjong, etc.;
• Sports competitions (real and fictional) for teams and PVP;

Create a game design document (GDD) outlining gameplay, features, art style, and target audience. Alongside that, do a thorough market research, analyze similar games in the market to identify unique selling points (USPs) and areas for improvement.

Step 2. Setting up the development environment

Pick a game engine for your future game. The most popular choice for mobile game development is currently Unity, and that’s also the game engine we at Mind Studios Games work with. A big reason why we chose Unity is to take advantage of its vast support for integrating monetization networks, since mobile games earn money in different ways compared to console/PC or web-based ones.

However, there are other options.

• Unreal Engine is popular overall but is rarely used in mobile games, since it shines the most in projects with stunning 3D graphics, and mobile devices rarely can do such titles justice.
• Another of your options is Godot, an open-source game engine with a relatively simple visual scripting.

There are a bunch of other engines, but these three are the most widely used when it comes to multiplayer games.

After choosing the engine, install all the tools required to build real-time multiplayer games. In case of Unity, this includes Unity Hub, Unity Editor, and a number of relevant modules.

Step 3. Making a prototype

Before going all out, start with developing the basic/core gameplay mechanics of your game. Focus on player controls, basic interactions, and core gameplay loop. You can use placeholder assets for characters, environments, and UI elements at this stage.

The goal here is to see whether the game idea you have can be implemented as is, or if it needs adjustments. (It probably does need them, and that’s okay.)

Step 4. Implementing networking functionality

Networking is the process of connecting multiple devices into a single system to transmit, exchange, and otherwise share information and resources with one another. It is a critical aspect of mobile game development, especially for real-time multiplayer games. After all, in multiplayer games, you need two or more players to be able to see each other’s actions in real time and possibly respond to them. This means you’ll need to sync game states — ensure positions, actions, etc. are synchronized across all players.

There’s a selection of networking solutions suitable for live multiplayer game development. At Mind Studios Games, we prefer using Photon, Firebase, or sometimes custom solutions.

• Photon is easy to use, supports matchmaking and room management, has a Unity SDK. You can set up Photon Cloud, create and join rooms, synchronize player movements.
• Firebase offers a real-time database and is good for simpler games.

For custom solutions, you’ll need to implement server-client architecture, handle socket connections, and message passing.

Step 5. Designing mobile-friendly user interfaces

Responsive design is important in all types and kinds of games, but especially so in mobile titles. Mobile devices differ significantly, and you need to make sure that UI elements in your game scale and position correctly on different screen sizes.

Implementing high-quality intuitive touch controls for gameplay is another critical part of designing. Follow mobile design guidelines, ensure buttons are large enough to be tapped easily, minimize clutter.

Step 6. Developing game features

Here comes the biggest part of work. Here, you’re implementing the all the features you’ve decided on while prototyping: all the mechanics, controls, game loops, and so on. You’ll also be adding advanced features, of course.

Advanced gameplay features include additional mechanics, power-ups, levels, etc. When we’re talking about real-time multiplayer game development, depending on your game’s type, you might need to work on matchmaking and lobby systems for players to find and join games, or social features like friend lists, chat, and leaderboards.

Step 7. Optimizing performance for mobile devices

As a mobile game development company, for us at Mind Studios Games, optimization is a big deal. Sure, some mobile devices these days can probably compare to a mid-level laptop, performance-wise. But not may. The multiplayer functionality alone is a big issue when it comes to mobile games.

To pull it off successfully, you need to:

• Optimize graphics: use level of detail (LOD) techniques, optimize textures and shaders, reduce draw calls.
• Manage memory usage to prevent crashes and improve performance.
• Test on multiple devices to ensure good performance and compatibility.

Step 8. Testing and debugging

Here’s another time- and effort-consuming activity in real-time multiplayer game development. (Or any game development, to be honest.)

The mobile gaming market is huge, and the competition here is fierce. Players abandon games at the drop of a hat — the smallest bug can be the reason, since often, there’s a similar game somewhere on the app store. Which is why, testing should not be undervalued.

Release alpha and beta versions to gather feedback from players and identify bugs. Set up CI/CD pipelines for automated builds and testing. Use tools like JIRA or Trello to keep track of and manage bugs. Do all you can to eliminate possible disturbances for players before you release publicly.

Step 9. Launch and promotion

Finally, it’s time for release! Your game is optimized, everything works perfectly. Now it’s time to create app store listings and put together marketing materials. App store optimization is your best chance to get noticed early on, so dedicate some time to research proper techniques and keywords to craft an enticing description for players. Choose the best screenshots that will lure people in. Categorize your game properly to hit the optimal target audience.

As you submit your multiplayer mobile game to app stores, follow the guidelines for the Google Play Store and Apple App Store carefully. The fewer mistakes there are in your application, the sooner your game will go live.

After the game is approved and listed in your chosen app store(s), use social media, game forums, and influencer partnerships to promote your game. In some cases, there’s value in launching marketing before the game release, to build up anticipation in players. Consider hiring professional marketing specialists if you have no experience in the field.

Step 10. Post-release support

Keep track of user feedback and analytics, release updates to fix bugs, and add new content regularly. While there’s no one-size-fits-all in how often a game needs to release new content to stay relevant, it’s generally recommended that you offer players something new at least once a month. It can be a timed event, a mini-game, or some kind of competition with in-game rewards.

When possible, engage with your player base through social media, forums, and in-game events.

Challenges in mobile network environments

Live multiplayer game development is a task riddled with challenges, and it takes a skilled team of developers to tackle them all. Aside from choosing the right protocols and using sockets for communication, there are also mobile-specific challenges.

At Mind Studios Games, we’ve built two multiplayer mobile games so far — or debut, third-person shooter CyberHero, and a cartoonish IO racing game for kids, Beetle Riders. For both of these games, we had to deal with the traditional challenges. So here they are, and the solutions we stand behind.

Latency	Latency is the time it takes for data to travel from the client to the server and back. High latency can cause lag, affecting the gameplay experience, particularly in fast-paced games. Mitigation: Techniques like client-side prediction and lag compensation are used to hide latency effects.
Packet loss	Data packets can be lost in transmission due to network issues, it’s called packet loss. Packet loss can cause stuttering, rubber-banding, or lost game actions. Mitigation: Using UDP with techniques like error correction and retransmission can help. Among well-known titles, "League of Legends" uses UDP and has mechanisms to handle packet loss gracefully.
Bandwidth limitations	This is the maximum rate of data transfer across a network. Limited bandwidth can result in slow data transmission, impacting game updates and performance. Mitigation: Optimize data packets to be as small and infrequent as possible. Compressing game state updates in "Clash Royale" allowed developers to reduce bandwidth usage.
Network variability	Mobile networks can vary significantly in quality due to factors like signal strength, network congestion, and user movement. Inconsistent connectivity can disrupt gameplay, causing frequent reconnects or temporary loss of connection. Mitigation: Implement robust reconnection logic and state synchronization to handle intermittent connectivity.
Security	Ensuring secure data transmission to prevent cheating, hacking, and data theft is of utmost importance in multiplayer games that deal with any kinds of competition. Mitigation: Encrypt data using protocols like SSL/TLS and implement server-side validation. For example, "Clash of Clans" uses SSL/TLS for secure data transmission and server-side checks to prevent cheating.
Power consumption	High network activity can drain battery life quickly, and multiplayer games do have that drawback. Mitigation: Optimize network calls to minimize power usage. A multiplayer AR game, "Ingress" minimizes background data transmission to conserve battery.

These all might seem daunting, but a team that has encountered these issues before will have no problems resolving them. Besides, there are tools modern game engines offer that, among other things, also help deal with these challenges. Which brings us to our next section.

Unity multiplayer solutions for real-time games

Our team’s game engine of choice is Unity. There are multiple reasons for that, from its active community and smoother learning curve to its capabilities when it comes to integration of ad networks. The latter is incredibly important for monetization of free-to-play mobile games. However, for this article, we’ll be talking about tools that Unity offers to those who want to build a live multiplayer game.

Netcode for GameObjects (NGO)

Unity's official solution for multiplayer networking, previously known as MLAPI (Mid-Level API), it aims to provide a modular, extensible networking library that integrates tightly with Unity.

Since it’s an official tool, its integration with Unity’s ecosystem is seamless and the long-term support and updates are practically guaranteed. It also offers a flexible architecture so that developers can extend and customize as needed.

Photon Multiplayer

Photon offers powerful networking solutions that are robust, scalable, and high-performance. Their current flagman products are Fusion and Quantum.

Fusion provides a solid client-side prediction, lag compensation, and overall high performance for multiplayer games of any complexity. Quantum, on the other hand, has in-built cheat protection, replay and spectating functionality, as well as a bot add-on SDK to fill in spectating rooms. Quantum is the perfect choice for eSports games.

Mirror

Mirror is a community-driven open-source networking library for Unity, born from the no longer supported UNET (Unity Networking). It focuses on simplicity and performance for real-time multiplayer games. Its API is similar to that of UNET, so if you or your hired developers have ever worked with Unity's built-in networking, mastering Mirror will be easy.

Being open-source, it allows for extensive customization. And it also tackles one of the mobile challenges as it is optimized for high performance with low-latency communication.

DarkRift 2

DarkRift 2 is a fast, flexible, and powerful networking solution that focuses on high performance and scalability. It was designed for Unity, acquired by Unordinal in 2022, and released as an open-source initiative.

The key features of DarkRift 2 include its tools for server management and deployment, high levels of customization, and optimization for low-latency and high-throughput.

Nakama by Heroic Labs

Here’s another open-source solution to create your own real-time multiplayer game in Unity. Nakama (Japanese for “comrade/buddy”) is a social multiplayer backend developed to provide a complete solution for real-time multiplayer, social, and competitive gaming. It offers matchmaking, chat, and real-time multiplayer capabilities, as well as leaderboards, friends, and groups.

As a backend solution, Nakama provides cloud functions, storage, and authentication.

This is quite the selection, isn’t it? Here are the pros and cons to make it easier to choose:

Solution	Pros	Cons
Netcode for GameObjects	Free Tight integration with Unity Supported and maintained by Unity Technologies Modular and extensible	Still evolving, with some features in development Requires learning new APIs and paradigms
Photon	Scalable and reliable High level of support and documentation Easy integration with Unity	Paid and can be expensive at higher scales Some developers may prefer more control over the server infrastructure
Mirror	Free and open-source Active community and regular updates Easy transition for those familiar with UNET	Requires more effort for hosting and server management Less support compared to commercial solutions
DarkRift 2	Extremely performant Flexible architecture Good documentation Community support	More complex to set up and configure Paid solution
Nakama	Open-source Extensive features Integrates social and multiplayer functions Scalable and performant	Can be complex to set up and manage Requires knowledge of backend services and infrastructure

Client-server architecture for real-time multiplayer mobile games

When you’re about to build a live multiplayer game, especially for mobile platforms, choosing the right client-server architecture is crucial. The right architecture will ensure high performance, scalability, and a fair gaming experience. Here are the most common architectures multiplayer game developers use today.

Authoritative server

In this architecture, a central server maintains the true state of the game. Clients send their actions to the server, which processes them and updates the game state. The server then broadcasts the updated state back to all clients.

The advantages of this architecture model include its high security and consistency, since the server controls the game logic. It’s also easier to perform game state management and debugging with an authoritative server.

On the other hand, this model comes with potentially high latency and can be hard to scale, since server resources are limited.

Peer-to-Peer (P2P)

In P2P architecture, all clients communicate directly with each other to exchange game state information. There is no central server. As opposed to the authoritative server, this model usually has low latency. It’s also saving costs on game servers. However, the security is more challenging to maintain in a serverless architecture, and the scalability is also an issue.

Overall, we’d say P2P architecture is best-suited for prototyping real-time multi-user games of smaller scale with no harsh competitions between players — casual and hyper-casual titles, local network games, etc.

Hybrid

A combo of the two models above, hybrid server architecture divides and conquers. Any critical game logic in this architecture is handled by a server, whereas less critical data is exchanged directly between clients.

If handled expertly, the hybrid architecture can indeed be a great solution: it can offer low latency of P2P for less critical operations, while providing high security for more important ones. Surprisingly enough, it’s also quite flexible, despite both its “parents” being… not much of that. With a hybrid architecture, developers can optimize performance and reduce server load by offloading non-critical tasks to clients.

But it’s not easy to achieve that balance. Implementing and maintaining a hybrid architecture requires experience. If not done correctly, it will introduce inconsistency into the game.

Client-server with local prediction

This model is often used for racing and shooter games, as it’s responsive and consistent. Here, clients predict the results of actions locally and display the results immediately. The server then validates these actions and corrects any discrepancies.

Instant action displaying makes for better player experience, and since there’s a server, the game state is sufficiently secure.

The disadvantages of this architecture model are the possible correction overhead (visible corrections or "rubber-banding" if predictions are incorrect) and its implementation complexity. The prediction and correction logic should be done by a seasoned professional.

Server-client with deterministic lockstep

When you build real-time multiplayer games with this architecture, all clients run the game simulation in lockstep, processing inputs for each frame simultaneously. The server then ensures all clients are synchronized and resolves any discrepancies.

The deterministic lockstep architecture has high latency, especially when it’s a massively multiplayer game, since clients must wait for inputs from all other clients. It’s also not the best choice for games launched in unstable or unequal networking conditions. However, its advantages are that if you create your own real-time multiplayer game with this architecture, it will be incredibly fair and consistent.

How to choose the right architecture for multiplayer game development?

Here are the points game developers have to consider when thinking how to make a multiplayer game from scratch:

• Game complexity. Simple games can often use P2P or hybrid models, while complex games with a lot of interactions and state data might fare better with an authoritative server or deterministic lockstep.
• Potential player count. Architectures that offload some or all communication to clients (P2P and hybrid) are only suitable for games where multiplayer activities are built for a small number of players, typically 2 to 4. Larger player counts typically require an authoritative server to manage the game state effectively.
• Platform constraints. In one of the sections above, we’ve mentioned that high latency and energy consumption are big challenges for mobile multiplayer games. We recommend architectures that minimize latency and handle disconnections well.
• Security. Competitive or monetized games require the security of an authoritative server.
• Network conditions. Mobile networks are less stable than wired connections. Opt for architectures that can tolerate latency and packet loss (e.g., local prediction with server correction).

Synchronization techniques

For real-time multiplayer game development, synchronization is obviously the main point, otherwise they wouldn’t really be multiplayer. So how do you do that? How to make players on different ends of the world perfectly in sync? There’s a selection of techniques.

Client-side prediction

Clients predict the results of their actions locally to provide immediate feedback to players. These predictions are sent to the server, which later confirms or corrects them. When a player performs an action (e.g., moving a character), the client immediately updates the local game state to reflect this action. The client sends the action to the server. The server processes the action and sends the authoritative state back to the client. If the server’s state differs from the client’s predicted state, the client corrects the state (reconciliation).

For example, in a first-person shooter, when a player moves, the client immediately shows the movement. The server processes the move and if there’s a discrepancy, the player’s position is adjusted accordingly.

This technique requires careful handling of discrepancies to avoid noticeable corrections, but it can provide immediate feedback, reducing perceived latency and ensuring a smoother gameplay experience.

Server reconciliation

With this technique, clients send their actions to the server, which processes them and then sends back the authoritative game state. Then, clients adjust their local state to match the server’s state and maintain a history of their actions. When the server’s state is received, clients compare it with their predicted state and if discrepancies are found, clients adjust their state to match the server’s authoritative state.

Server reconciliation ensures consistency across all clients and prevents cheating by relying on server authority. However, it can also result in visible corrections or “rubber-banding”.

State synchronization

The server periodically sends the complete game state to all clients, ensuring they all have a consistent view of the game world. Clients receive state updates from the server at regular intervals and interpolate between states to provide smooth transitions.

This technique is simple to implement and ensures all clients are synchronized. But on the other hand, it can be bandwidth-intensive and requires careful handling of interpolation to prevent jitter.

Delta compression

Instead of sending the entire game state, the server only sends the changes (deltas) since the last update. The server keeps track of the game state and calculates the differences between the current state and the last sent state. Only the changes are sent to the clients.

The biggest advantage of this technique is that it reduces bandwidth usage. But it requires clients to correctly apply deltas to maintain synchronization, so it’s efficient for strategy games and similar genres with large but mostly static states.

How to optimize synchronization performance and minimize network overhead?

This question will pop up often when thinking about how to make an online multiplayer game from scratch. Here’s what our developers recommend:

Reduce frequency of updates	Adaptive update rates. Adjust update rates based on network conditions and game requirements. Send critical updates more frequently and less critical updates less often. Event-based updates. Only send updates when significant events occur (e.g., player movement starts/stops, actions are performed).
Optimize data transmission	Compression. Use data compression techniques to reduce the size of the data being sent. Protocols like Google’s Protocol Buffers or custom binary protocols can be effective. Data aggregation. Combine multiple small updates into a single packet to reduce overhead.
Efficient state management	Interpolation and extrapolation. Use interpolation to smoothly transition between states, and extrapolation to predict future states based on past data. This reduces the need for frequent updates. Prioritize critical data. Prioritize sending critical game state information (e.g., player positions, health) over less critical data (e.g., cosmetic changes).
Network optimization	Latency compensation. Implement techniques like client-side prediction and server reconciliation to compensate for network latency and provide a smoother experience. Bandwidth management. Monitor and manage bandwidth usage to prevent network saturation. Adjust update frequencies dynamically based on current bandwidth availability.
Scalability and load balancing	Distributed servers. Use a network of distributed game servers to reduce latency and handle larger player counts. Cloud services like AWS, Google Cloud, or Photon Cloud can help with this. Load balancing. Distribute the load across multiple servers to prevent any single server from becoming a bottleneck.

Multiplayer game development with Mind Studios Games

Our very first game was a multiplayer title. Yes, we’re not ones to back out from a challenge 😎 It took time and some major changes — it was initially a first-person multiplayer shooter, which we have later rebuilt into a third-person one — but CyberHero has been live for a while already. It’s a 3D mobile team PvP shooter set in cyberpunk-style areas. Check it out here: iOS, Android.

Our other online multiplayer game is mainly for children, though we know quite a number of adults enjoy the cute visuals of chibi characters mounted on beetles and bugs as well. Beetle Riders is a racing game where players can compete against other players and against AI-backed bots. The goal is to collect as many rewards as possible, and you can push your opponents off the platform to slow them down. You can find the game here: iOS, Android.

Conclusion

Real-time multiplayer game development is no cakewalk, that’s for sure. However, the tech world evolved so much in the last couple decades that it’s even become possible to build a live multiplayer game (a not too complex one) in under half a year. Granted you work with a professional team, of course. For a single developer, that might take longer.

There are a lot of things to consider if your goal is a mobile multiplayer title. You need to pay close attention to architecture, synchronization, networking, and look out for possible pitfalls — mobile platforms have unique ones, after all.

Our game development team at Mind Studios Games has experience in multiplayer game development, starting with the idea all the way to launch and support. We also have a general 97% success score with our projects in our 8 years on the market. Whether you need a full-cycle team to turn your idea into reality, or you require the help of a specific professional to handle the multiplayer functionality — we have you covered.

Reach out to our consultant for a free call so that we can discuss your project and offer you advice, estimates, and possible timeline to complete the project.

1