ioGame

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:

1. Truly lightweight — lock-free, async, event-driven from the ground up.
2. Small package, low memory, fast startup.
3. Pure JavaSE — integrates effortlessly with Spring, Vert.x, Quarkus, Solon, and others.
4. Zero learning curve. If you know basic Java or web MVC, you already know how to use ioGame. No game dev experience required.
5. Architecturally eliminates the N×N scaling problem that plagues traditional frameworks.
6. No third-party dependencies for clustering & distribution — just a JVM is all you need.
7. Three-part architecture: External Server + Broker (Gateway) + Game Logic Server — each can run independently or fused together, adapting to any game type.
8. Fully dynamic scaling — add or remove External Servers, Logic Servers, and Brokers on the fly.
9. Multi-server, single-process mode for development — debug distributed systems as easily as a monolith.
10. Logic Servers can run standalone, enabling true modularization.
11. Built-in full-link distributed tracing.
12. Rich communication primitives — logic servers can talk across machines seamlessly.
13. MVC-style coding with non-intrusive Java Beans — effectively prevents class explosion.
14. Built-in per-player thread safety — concurrency handled for you.
15. One codebase supports TCP, WebSocket, UDP simultaneously — no code changes needed. Extensible to KCP, QUIC, and beyond.
16. One codebase for switching data protocols — Protobuf, JSON, and more. Extensible.
17. Hot-swap protocols — add or remove protocols without restarting the gateway or External Server. No player disconnections.
18. Auto-boxing/unboxing of primitives in actions — solves the protocol fragment problem.
19. Pluggable, extensible plugin system.
20. Deploy as single-process or multi-process across machines — switch freely without code changes.
21. Logic Servers never expose ports — immune to port-scanning attacks by design.
22. Built-in stress testing & simulation module with real network conditions, continuous interaction, and automation support.
23. Sync, async, and async-callback methods for inter-service communication.
24. Distributed event bus (like MQ / Redis pub-sub — works across machines and processes).
25. Elegant route-level access control.
26. Intelligent same-process affinity.
27. JSR380 validation + assertions + exceptions = less boilerplate, fewer bugs.
28. 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:

1. No redundant development.
2. Low coupling between modules.