A lock-free, asynchronous, event-driven Java Netty framework for building high-performance network applications. Lightweight and dependency-free, it supports di
A lock-free, asynchronous, event-driven Java Netty framework for building high-performance network applications. Lightweight and dependency-free, it supports di
ioGame
Lock-free, async, event-driven architecture — supports clustering & distribution out of the box, no middleware required
Build decentralized, auto-scaling, multi-process distributed game servers with ease
Tiny footprint, blazing-fast startup, low memory usage, zero config files, elegant route-level access control
Simultaneous support for WebSocket, UDP, TCP and more — with built-in full-link distributed tracing
One codebase, multiple protocols — seamlessly switch between Protobuf, JSON, and beyond
Near-native performance — 11.52 million business operations per second in a single thread
Code-as-documentation, JSR380 validation, assertion + exception patterns — minimal maintenance overhead
Smart same-process affinity with IDE-friendly code navigation & jump-to-source
Deploy your way — components run independently or fused together
Write once, generate client SDKs — interactive code generation for any frontend
Cross-process, cross-machine communication between logic servers
Dynamic player-to-server binding
Plays nicely with any framework
Feels natural for web MVC developers
No hard dependency on Spring
Zero learning curve
Pure JavaSE
https://iohao.github.io/game
Documentation: https://iohao.github.io/game/docs/intro
Make game server development effortless. We're here to change the industry — lowering the barrier to entry and making game development tools truly accessible to everyone.
Why AGPL 3.0?
ioGame is released under the AGPL 3.0 license. Projects built with ioGame under this license are free of charge.
We chose AGPL 3.0 because it's fairer to developers. It ensures that project ownership is shared — meaning that even if a developer leaves a company, they retain legitimate rights to the project they helped build.
Contrast this with permissive licenses like Apache 2.0 or MIT, where developers who leave a company lose all control over the project and get nothing in return. We've all seen it: developers pour their hearts into a project through countless late nights and weekends, only to be let go right before — or just after — launch, watching their hard work become someone else's asset.
Under AGPL 3.0, shared ownership means developers are genuinely motivated to invest in and polish their work.
ioGame is impressively lean:
Looking for a game server framework that's high-performance, stable, easy to use, with built-in load balancing, clean architecture (no class explosion), cross-process communication, decentralized clustering, auto-scaling, and stateful multi-process distribution? Meet ioGame — a Java networking framework designed exactly for this.
ioGame is a lightweight networking framework built for online games, IoT, internal systems, and any scenario that needs persistent connections.
Key Features at a Glance:
- Truly lightweight — lock-free, async, event-driven from the ground up.
- Small package, low memory, fast startup.
- Pure JavaSE — integrates effortlessly with Spring, Vert.x, Quarkus, Solon, and others.
- Zero learning curve. If you know basic Java or web MVC, you already know how to use ioGame. No game dev experience required.
- Architecturally eliminates the N×N scaling problem that plagues traditional frameworks.
- No third-party dependencies for clustering & distribution — just a JVM is all you need.
- Three-part architecture: External Server + Broker (Gateway) + Game Logic Server — each can run independently or fused together, adapting to any game type.
- Fully dynamic scaling — add or remove External Servers, Logic Servers, and Brokers on the fly.
- Multi-server, single-process mode for development — debug distributed systems as easily as a monolith.
- Logic Servers can run standalone, enabling true modularization.
- Built-in full-link distributed tracing.
- Rich communication primitives — logic servers can talk across machines seamlessly.
- MVC-style coding with non-intrusive Java Beans — effectively prevents class explosion.
- Built-in per-player thread safety — concurrency handled for you.
- One codebase supports TCP, WebSocket, UDP simultaneously — no code changes needed. Extensible to KCP, QUIC, and beyond.
- One codebase for switching data protocols — Protobuf, JSON, and more. Extensible.
- Hot-swap protocols — add or remove protocols without restarting the gateway or External Server. No player disconnections.
- Auto-boxing/unboxing of primitives in actions — solves the protocol fragment problem.
- Pluggable, extensible plugin system.
- Deploy as single-process or multi-process across machines — switch freely without code changes.
- Logic Servers never expose ports — immune to port-scanning attacks by design.
- Built-in stress testing & simulation module with real network conditions, continuous interaction, and automation support.
- Sync, async, and async-callback methods for inter-service communication.
- Distributed event bus (like MQ / Redis pub-sub — works across machines and processes).
- Elegant route-level access control.
- Intelligent same-process affinity.
- JSR380 validation + assertions + exceptions = less boilerplate, fewer bugs.
- Write once, generate everywhere — produce unified interactive SDKs for Godot, UE, Unity, Cocos Creator, Laya, React, Vue, Angular, and more. Massive productivity boost.
Packaging, memory, and startup are all best-in-class: jar size ~15 MB, startup typically under 1 second, low memory footprint.
Ecosystem integration is straightforward — Spring integration takes just 4 lines of code. Beyond Spring, ioGame plays well with Vert.x, Quarkus, Solon, and any other framework, letting you tap into their ecosystems.
Zero learning curve. If you know basic Java or web MVC patterns, you're ready. No game development background needed.
Clean coding style. ioGame provides MVC-like conventions with non-intrusive Java Beans, effectively preventing class explosion. Sync, async, and callback methods are available for inter-service calls — resulting in elegant code with full-link tracing baked in.
Write once, connect everywhere. ioGame generates client interaction code automatically, dramatically cutting client-side workload. Write your Java code once and generate unified SDKs for Godot, UE, Unity, Cocos Creator, Laya, React, Vue, Angular, and more. Supports code generation in C#, TypeScript, GDScript, and C++ — fully extensible.
No N×N headaches. Traditional architectures rely on Redis, MQ, ZooKeeper, and other middleware to scale — hardly "lightweight." ioGame solves the N×N problem architecturally, without external dependencies.
Truly lightweight. No third-party middleware or database is needed for clustering and distribution — just a JVM. This simplifies usage and slashes deployment and maintenance costs. A single dependency gives you the entire framework — no Nginx, Redis, MQ, MySQL, ZooKeeper, or Protobuf compiler to install.
Flexible architecture. ioGame's three-part design — External Server, Broker (Gateway), Game Logic Server — can run independently or merged together, adapting to any game type simply by adjusting deployment. These changes are trivial and never break existing code.
Dynamic scaling. External Servers, Logic Servers, and Brokers all support live addition and removal. Scale up or down as player counts change. The architecture also enables zero-downtime updates: spin up new servers (A-3, A-4) with your latest features, then gracefully retire the old ones (A-1, A-2) — players never notice.
Decentralized clustering. The Broker (Gateway) uses a masterless, self-organizing cluster design — all nodes are equal and autonomous with no single point of failure. The cluster auto-manages and elastically scales, maintaining load balance and consistency as nodes join or leave.
Distributed by design. Logic servers are organized into distinct layers — External Servers, Game Logic Servers — each with clear responsibilities and interfaces. This improves readability, maintainability, and enables effortless horizontal scaling.
Developer-friendly distributed development. Distributed apps usually mean juggling multiple processes, making debugging painful. Most frameworks can't solve this — ioGame can. Multi-server single-process mode lets you develop and debug distributed systems as if they were monoliths.
Modular ecosystem. Game Logic Servers can run standalone — just plug into the Broker to provide services. Build reusable, componentized logic servers — Guild, Friends, Login, Lottery, Announcements, Leaderboards, and more. Benefits include:
Full-link distributed tracing. Every request gets a unique trace ID recorded across logs — filter by ID to instantly find what you need. ioGame's tracing works across machines and processes: from request entry to completion, every logic server touched is precisely recorded.
Rich communication models. While most frameworks only offer push/broadcast, ioGame provides a complete set of communication patterns — all supporting cross-process, cross-machine communication with full-link tracing:
No open issues yet, or sync has not completed.