End of Life for Twilio Programmable Video - Upgrade to VideoSDKLearn More

How to Integrate Socket.IO with Unity?

Learn how to integrate Socket.IO with Unity to enable real-time communication in your games. This comprehensive guide covers setup, code examples, and practical applications.

Introduction to Unity and Socket.IO

In the world of game development, Unity stands out as a versatile and powerful platform, enabling developers to create stunning and immersive games across multiple devices. Its extensive features and user-friendly interface have made it a popular choice among both novice and experienced developers. On the other hand, Socket.IO is an essential tool for real-time, bi-directional communication, allowing seamless data exchange between clients and servers.
This article aims to provide a comprehensive guide on integrating Socket.IO with Unity, offering developers the tools and knowledge needed to implement real-time features in their Unity projects effectively. Whether you’re looking to create a real-time multiplayer game or a live chat application, understanding how to combine these two powerful tools is crucial.

Understanding Unity and Socket.IO

What is Unity?

Unity is a powerful game development platform known for its flexibility and robust features. It supports 2D and 3D game development, VR/AR experiences, and simulations across multiple platforms, including mobile, desktop, and consoles. Unity's extensive asset store, comprehensive documentation, and active community make it an ideal choice for both beginners and experienced developers.

What is Socket.IO?

Socket.IO is a JavaScript library that enables real-time, bidirectional communication between web clients and servers. It is built on top of WebSockets and provides additional features such as automatic reconnection, disconnection detection, and event-based communication. This makes Socket.IO a preferred choice for applications requiring real-time updates, such as chat applications, live notifications, and multiplayer games.

Setting Up Your Development Environment


Before you begin, ensure you have the following installed on your development machine:
  • Unity Hub and Unity Editor (latest version)
  • Node.js (latest LTS version)
  • Visual Studio Code or any preferred code editor
  • Basic understanding of JavaScript and C#

Installation Steps

[a] Install Node.js

[b] Set Up a New Node.js Project

  • Open your terminal and create a new directory for your project.
  • Run npm init -y to initialize a new Node.js project.
  • Install Socket.IO by running npm install socket.io.

[c] Install Unity and Create a New Project

  • Open Unity Hub, click on "New Project," and select a template (e.g., 3D).
  • Name your project and choose a location to save it, then click "Create."

Creating a Basic Unity Project

Project Setup

  • Open Unity: Launch Unity Hub and open your newly created project.
  • Configure Build Settings:
    • Go to File > Build Settings.
    • Select your target platform (e.g., PC, Mac & Linux Standalone).
    • Click "Switch Platform" if necessary.

Adding Required Assets

  • Import Socket.IO Unity Package: You can find third-party packages for Socket.IO on the Unity Asset Store or GitHub. Import the package into your project.
  • Organize Project Structure: Create folders for Scripts, Prefabs, and Scenes to keep your project organized.

Integrating Socket.IO with Unity

Download and Import Socket.IO Client

  • Download the Socket.IO Client for Unity from a trusted source.
  • Import the package into your Unity project by dragging and dropping it into the Assets folder.

Connecting to a Socket.IO Server

Set Up a Basic Socket.IO Server

  • Create a file named server.js in your Node.js project directory.
  • Add the following code to set up a basic server:


1     const io = require('socket.io')(3000);
2     io.on('connection', (socket) => {
3       console.log('A user connected');
4       socket.on('disconnect', () => {
5         console.log('A user disconnected');
6       });
7     });
Run the server with node server.js.

Connect Unity to the Server

  • Create a new C# script in Unity named SocketManager.
  • Add the following code to establish a connection:


1     using SocketIO;
2     using UnityEngine;
4     public class SocketManager : MonoBehaviour
5     {
6         private SocketIOComponent socket;
8         void Start()
9         {
10             GameObject go = GameObject.Find("SocketIO");
11             socket = go.GetComponent<SocketIOComponent>();
12             socket.On("open", OnConnected);
13             socket.On("error", OnError);
14             socket.On("close", OnDisconnected);
15             socket.Connect();
16         }
18         void OnConnected(SocketIOEvent e)
19         {
20             Debug.Log("Connected to server");
21         }
23         void OnError(SocketIOEvent e)
24         {
25             Debug.Log("Error: " + e.data);
26         }
28         void OnDisconnected(SocketIOEvent e)
29         {
30             Debug.Log("Disconnected from server");
31         }
32     }

Handling Events

Custom Event Handling

To handle custom events, add event listeners in your SocketManager script:


1     socket.On("yourCustomEvent", OnCustomEvent);
3     void OnCustomEvent(SocketIOEvent e)
4     {
5         Debug.Log("Received custom event: " + e.data);
6     }
Emit events from the server in server.js:


1     io.emit('yourCustomEvent', { message: 'Hello from server!' });

Get Free 10,000 Minutes Every Months

No credit card required to start.

Implementing Real-Time Features

Real-Time Chat Application

Client-Side Chat Implementation

  • Create a new C# script named ChatManager in Unity.
  • Add input fields and buttons for chat functionality in your Unity scene.
  • Implement the following code to handle chat messages:


1     public class ChatManager : MonoBehaviour
2     {
3         private SocketIOComponent socket;
5         void Start()
6         {
7             socket = GameObject.Find("SocketIO").GetComponent<SocketIOComponent>();
8             socket.On("chat message", OnChatMessage);
9         }
11         public void SendMessage(string message)
12         {
13             JSONObject jsonObject = new JSONObject();
14             jsonObject.AddField("message", message);
15             socket.Emit("chat message", jsonObject);
16         }
18         void OnChatMessage(SocketIOEvent e)
19         {
20             Debug.Log("New message: " + e.data["message"].str);
21         }
22     }

Server-Side Chat Handling

In server.js, handle incoming chat messages:


1     io.on('connection', (socket) => {
2       socket.on('chat message', (msg) => {
3         io.emit('chat message', msg);
4       });
5     });

Real-Time Multiplayer Game

Synchronizing Game State

  • Create a new C# script named GameSync in Unity.
  • Implement code to sync game objects across clients:


1     public class GameSync : MonoBehaviour
2     {
3         private SocketIOComponent socket;
5         void Start()
6         {
7             socket = GameObject.Find("SocketIO").GetComponent<SocketIOComponent>();
8             socket.On("update position", OnUpdatePosition);
9         }
11         public void UpdatePosition(Vector3 position)
12         {
13             JSONObject jsonObject = new JSONObject();
14             jsonObject.AddField("x", position.x);
15             jsonObject.AddField("y", position.y);
16             jsonObject.AddField("z", position.z);
17             socket.Emit("update position", jsonObject);
18         }
20         void OnUpdatePosition(SocketIOEvent e)
21         {
22             Vector3 position = new Vector3(
23                 float.Parse(e.data["x"].str),
24                 float.Parse(e.data["y"].str),
25                 float.Parse(e.data["z"].str)
26             );
27             // Update game object position
28         }
29     }

Server-Side Position Handling

In server.js, broadcast position updates:


1     io.on('connection', (socket) => {
2       socket.on('update position', (position) => {
3         socket.broadcast.emit('update position', position);
4       });
5     });


Integrating Socket.IO with Unity opens up a world of possibilities for real-time applications, from multiplayer games to live chat functionalities. By following the steps outlined in this guide, you can set up your development environment, create a basic Unity project, and implement real-time features using Socket.IO. Experiment with the provided examples, and don't hesitate to explore more complex scenarios to enhance your Unity projects with real-time capabilities.

Want to level-up your learning? Subscribe now

Subscribe to our newsletter for more tech based insights