Create an Agar.io Server in 2026: The Complete Guide

To create a private Agar.io server in 2026, one option is to use OgarII, an open-source server written in Node.js. The project provides a documented installation procedure: install Node.js and a C++11 compiler, download the repository, run npm install, then start the server with node index.js from the cli folder. After the first launch, OgarII generates a settings.json file, among others, which lets you configure the server.

Key takeaways

• OgarII is an open-source Agar.io server implementation based on Node.js. Its repository states that it supports the current versions of the Agar.io protocol and multiple worlds within a single instance.
• The OgarII repository officially states Node.js 8 or later, as well as a C++11-compatible compiler to build uWebSockets.
• The MultiOgar-Edited project also has several public forks. The agarian-2/MultiOgar fork, whose repository is at github.com/agarian-2/MultiOgar, provides a playable client hosted separately at agarian-2.github.io and documents the setServer("ip:port") command.
• OgarII documents the official agar.io client with the core.disableIntegrityChecks(true) command to run before connecting. For a simple tutorial, it is better to use a community client designed for private servers rather than rely on a modification of the official client.

The state of the Agar.io ecosystem in 2026: what can be verified

Many historical projects related to private Agar.io servers still exist on GitHub, but their status varies widely. It is better to check the repository and its documentation than to assume that any list of projects is exhaustive.

The date of the last commit is a useful indicator, but it isn't enough to determine whether a project is technically functional. An old repository can keep working, while a recent fork may need fixes. For a new installation, mainly check the documentation, the dependencies and the known issues of the repository you choose. OgarII still has installation documentation and a clearly identified project structure.

Installing the technical prerequisites

For OgarII, the officially documented prerequisites are Node.js and a C++11 compiler capable of building uWebSockets. The procedure below aims for a modern setup while staying within the project's requirements.

On Windows

1. Install Node.js. Download an LTS version from nodejs.org. OgarII officially states that it requires Node.js 8 or later.
2. Install the C++ build tools. OgarII uses uWebSockets and requires a C++11-compatible compiler. The project's historical README mentions windows-build-tools for Windows. Since that package is old, if this method doesn't work with your Node.js environment, use a Windows setup with the necessary C++ build tools, for example the Visual Studio Build Tools.
3. Git for Windows is recommended but not required. Available from git-scm.com, it lets you clone the repository easily and keep it up to date.
4. A text editor. Visual Studio Code, Notepad++ or any other editor suited to JSON files will do.

On Linux (Ubuntu, Debian)

OgarII requires Node.js and a C++11 compiler. The repository specifically recommends GCC on GNU/Linux.

Install the basic tools:

sudo apt update
sudo apt install nodejs npm build-essential git

Then verify:

node -v
npm -v
gcc --version

The exact Node.js version available in your distribution's repositories may vary. What matters for OgarII is having a version compatible with its dependencies and a working C++11 compiler. If npm install reports a uWebSockets compilation error, first check your C++ environment and the compatibility of the Node.js version you are using. The OgarII repository has documented issues with compiling uWebSockets on some configurations.

On macOS

Install Homebrew if needed, then Apple's development tools:

brew install node git
xcode-select --install

xcode-select --install installs Apple's Command Line Tools, which provide the tools needed for compilation, among others.

Method 1: installing OgarII step by step

OgarII is an open-source Agar.io server written in Node.js. Its official README provides a short, reproducible installation procedure: install Node.js and a C++11 compiler, download the repository, run npm install, then launch node index.js from the cli folder.

1. Open a terminal (PowerShell on Windows, Terminal on Linux/macOS) and clone the repository:

git clone https://github.com/Luka967/OgarII.git

Alternative without Git: download the ZIP archive from OgarII's GitHub page, then extract it.

1. Go into the folder and install the dependencies:

cd OgarII
npm install

This step installs the project's dependencies and may compile uWebSockets. If a compilation error appears, check that the C++11 compiler is correctly installed. OgarII explicitly documents this dependency.

1. Go to the CLI folder and start the server:

cd cli
node index.js

This procedure matches the instructions in the official OgarII repository.

1. After the first launch, OgarII creates settings.json and log-settings.json in the cli folder / working directory. The first is used to configure the server and the second to configure logging.
2. Stop the server with Ctrl+C before changing its configuration.

Important

Don't automatically copy a settings.json from another fork. The Ogar, OgarII and MultiOgar projects have different configurations. With OgarII, primarily use the settings.json file generated by your own installation and only modify the parameters present in that version.

Configuring settings.json

After the first start, OgarII creates cli/settings.json. The official repository states that this file is used to change how the server behaves.

The exact parameters may depend on the version or fork you use. It is therefore better to edit the file generated by your installation rather than copy a list of parameters from another tutorial.

To get started:

• open cli/settings.json;
• identify the parameter you want to change;
• keep the JSON format;
• save the file;
• restart the server with node index.js.

A JSON syntax error, such as a missing or extra comma, can prevent the server from starting. If needed, use a JSON validator before restarting the server.

To find out which parameters are actually available in your version, use the settings.json file generated by OgarII as a reference. The repository confirms that this file is created automatically after the first launch.

Connecting to the server

The OgarII server and the client must use a compatible protocol. Several community clients exist; their compatibility depends in particular on the protocol version they support.

Option 1: the Cigar2 client

Cigar2 is an open-source Agar.io client specifically described as a protocol 6 client for private servers. Its repository explicitly recommends Luka's OgarII as the server.

To install it:

git clone https://github.com/Cigar2/Cigar2.git
cd Cigar2
npm install
npm start

The client then starts on localhost:3000 according to its documentation.

The repository states that servers can be added to the client's menu by editing index.html. This solution therefore takes a few extra steps, but it gives you your own local client.

Option 2: the agarian-2 client

agarian-2's MultiOgar fork has its own client. The playable client is hosted at agarian-2.github.io and its source code is in the github.com/agarian-2/agarian-2.github.io repository (it is based on Luka967's Cigar, with features taken from Cigar2). It is the README of the github.com/agarian-2/MultiOgar server that explicitly documents the setServer("serverip:serverport") command and recommends this client for that MultiOgar server.

To use it:

1. Open the hosted client at agarian-2.github.io.
2. Press Ctrl + Shift + J to open the developer console.
3. Type:

setServer("ip-address:port")

The github.com/agarian-2/MultiOgar repository documents this command and specifies that the client uses wss:// by default because it is hosted on GitHub Pages. If the server doesn't support secure WebSocket, the repository says you need to download the client and adapt it locally.

Note: this method is documented for agarian-2's MultiOgar server. Don't present this client as the officially recommended client for OgarII: the two projects are separate.

The official agar.io client

OgarII states in its README that before connecting from the agar.io client, you need to run:

core.disableIntegrityChecks(true)

This instruction is well documented by the OgarII project. However, how the official client behaves may depend on its version. For a tutorial aimed at a new installation, it is better to use a community client designed for private servers when the official client doesn't allow the connection.

Tip for the first test

Start with a local test before opening the server to the Internet. This lets you tell a server problem apart from a network, firewall or WebSocket problem.

Opening the server to remote friends

Once the server works locally, there are three main ways to make it reachable from the Internet.

1. Port forwarding

The classic method is to forward the port your server uses from your router to the local IP address of the machine hosting it.

For example, if your server listens on port 8080:

• find your computer's local IP address;
• create a NAT/port forwarding rule on your router;
• forward the TCP port used by the server to your computer;
• also allow that port in the Windows firewall or your Linux distribution's firewall;
• then use your public IP address and the same port to connect.

The exact procedure depends on the router you use. A dynamic public IP address can also change over time.

2. Network tunnel

A TCP tunneling service can temporarily expose a local server without configuring your router directly. Services such as ngrok offer this kind of feature.

The exact command and the addresses provided depend on the service and its plan at the time you use it. So don't copy an example address or port as if it were a permanent value.

Above all, check that the tunnel you use supports the TCP traffic your Agar.io server needs, and use the address and port the service actually gives you.

3. VPS or dedicated server

For a server available 24/7, a VPS can be more practical than a personal computer. Install Node.js, the build tools and Git on the VPS, then follow the same OgarII procedure:

git clone https://github.com/Luka967/OgarII.git
cd OgarII
npm install
cd cli
node index.js

A server's capacity depends on many factors: processor, number of players, bots, map size and game settings. OgarII specifies that Node.js can use a single CPU core per instance and that several worlds can run in the same instance. It is therefore better to monitor CPU usage than to promise a fixed number of players for a given configuration.

Frequently Asked Questions

What is the difference between Ogar, OgarII and MultiOgar?

Ogar is the original historical project, whose GitHub repository has been archived since November 27, 2020; OgarII is another open-source implementation in Node.js that supports the current protocol versions, multiple worlds within a single instance and uWebSockets for networking; MultiOgar is another historical branch with several forks still around, including agarian-2's heavily modified one with its own client. So it isn't accurate to claim that only two projects are usable in 2026: always check the repository you choose before a new installation.

Can you use the official agar.io client to connect to a private server?

OgarII documents the core.disableIntegrityChecks(true) command to run before connecting from agar.io, but doesn't guarantee that it works with every version of the official client; for a setup meant for a private client, use instead a client whose repository explicitly documents its compatibility with the server you chose, for example Cigar2, an open-source client for private servers that lists OgarII as the recommended server.

How many players can an OgarII server support?

The official documentation gives no universal figure: a Node.js instance can use a single CPU core, so you mainly need to watch processor performance, and the number of players you can actually support also depends on bots, map size and server settings. The right approach is to start with a small load, monitor CPU usage and gradually increase the number of players.

Does it work on a Raspberry Pi?

Since OgarII is based on Node.js and requires compiling uWebSockets, an installation on an architecture different from a standard PC may need adjustments, and the project provides no figure guaranteeing a specific number of players on a Raspberry Pi; first check that your Node.js version, your architecture and your compiler can build the dependencies, bearing in mind that the repository already reports uWebSockets compilation issues on some configurations.

Can you add custom skins or bots?

OgarII provides an API to add commands and create custom game modes (commands are created from the src/commands/CommandList.js file, and game modes by inheriting from the abstract Gamemode class defined in src/Gamemode.js, then registering it with ServerHandle.gamemodes.register), but skin possibilities depend on the client used, a skin added on the client side isn't available in every Agar.io client, and for bots, don't assume a specific command such as addbot 10 exists everywhere: check the commands available in your server, notably in src/commands/CommandList.js for OgarII.

How do you migrate an old 2016 Ogar server to OgarII?

Treat OgarII as a new installation rather than an automatic upgrade: keep the important settings from your old server and recreate them gradually in the settings.json generated by OgarII, without directly replacing its configuration files with those of an old server, and don't assume that custom plugins, commands and game modes from an old server are automatically compatible, since OgarII has its own API for commands and game modes.