IoGame
A lock-free, asynchronous, event-driven Java Netty framework for building high-performance network applications. Lightweight and dependency-free, it supports distributed, decentralized clusters without requiring external middleware or databases—ideal for game servers, IoT, and long-lived connection systems.
Install / Use
/learn @iohao/IoGameREADME
Documentation: https://iohao.github.io/game/docs/intro
Vision
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.
Open, Free & Developer-Friendly License
- There is no commercial edition — never has been, never will be. Every feature is open source.
- We're committed to at least ten years of active maintenance, starting from 2022-03-01.
- ioGame is a lightweight networking framework built for online games, IoT, internal systems, and any scenario that needs persistent connections. The source code is fully open, documentation is free, and usage costs nothing (subject to license terms).
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.
Startup Showcase
ioGame is impressively lean:
- Memory: Minimal footprint.
- Startup: Applications typically boot in under 1 second.
- Package size: ~15 MB as a jar.

What is ioGame?
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](https://iohao.github.io/game/
Related Skills
canvas
330.3kCanvas Skill Display HTML content on connected OpenClaw nodes (Mac app, iOS, Android). Overview The canvas tool lets you present web content on any connected node's canvas view. Great for: -
feishu-drive
330.3k|
things-mac
330.3kManage Things 3 via the `things` CLI on macOS (add/update projects+todos via URL scheme; read/search/list from the local Things database)
clawhub
330.3kUse the ClawHub CLI to search, install, update, and publish agent skills from clawhub.com
