Enterprise vs Open-Source Feature Comparison

Feature Comparison

Feature Module	Feature	Open-Source	Enterprise	Description
Communication Model
	request/response	✅	✅	The requester sends a request to the server. The server receives and processes it, then returns response data.
	request/void	✅	✅	The requester sends a request to the server. The server receives and processes it, then returns no response data.
	broadcast	✅	✅	The server proactively pushes data to users.
	OnExternal	✅	✅	Interacts with external servers.
	request/multiple_response	❌	✅	Interacts with multiple logic servers of the same type at the same time, breaking traditional RPC limitations.
	EventBus	❌	✅	Distributed event bus for lightweight cross-service event communication.
External Server
	Connection Method - WebSocket	✅	✅	Supports clients connecting to the server through WebSocket.
	Connection Method - TCP	✅	✅	Supports clients connecting to the server through TCP.
	Heartbeat Settings and Hooks	✅	✅	Keeps communication active in long-lived connections.
	User Online/Offline Hooks	✅	✅
	Route Access Control	✅	✅	The framework provides precise access control, allowing you to specify which routes cannot be accessed by users.
	WS Token Authentication and Validation	✅	✅	Performs token-related authentication and validation before WebSocket connections are established.
	Built-in and Optional Handlers	✅	✅	Built-in Netty handlers provided by the framework.
	External Server Cache	❌	✅	Supports caching business data in external servers to achieve zero GC and zero encode/decode overhead for data access, delivering major performance gains. Reduces pressure on backend logic servers and accelerates data responses.
Logic Server
	Runner Extension Mechanism	✅	✅	The Runner mechanism is similar to Spring CommandLineRunner startup hooks. It is triggered once before and once after logic-server connections are established. Developers can extend their own systems by implementing the Runner interface.
	JSR380	✅	✅	Supports the JSR380 validation specification, helping keep business code cleaner.
	Metadata - Attachments	✅	✅	Allows carrying custom metadata while processing actions.
	Protocol Fragments	✅	✅	Reduces data-protocol fragmentation.
	Assertion + Exception Mechanism	✅	✅	Assertion + Exception mechanism = clear and concise code.
	Thread Orchestration	✅	✅	Provides thread-related customization and extension so developers can design thread orchestration suited to their project requirements and characteristics.
	Dynamic Logic-Server Binding	❌	✅	After a user is bound to a logic server, subsequent requests are handled by that logic server.
	End-to-End Call Trace Logs	❌	✅	Solves cross-service call-chain tracing problems. Traces a request path from the user side through service A -> service B -> service C ... across processes, machines, and services.
	Broadcast Logs	❌	✅	When broadcast logging is enabled, you can locate the source code position of broadcast calls.
Business Framework Plugins
	DebugInOut	✅	✅	When an action handles a request, related information is printed in the console, such as code navigation, user, request parameters, thread, elapsed time, response, and more. Code navigation lets developers quickly jump to related business code. In multi-developer projects, it quickly shows which methods were executed, making review and modification faster.
	Action Call Statistics Plugin	✅	✅	Collects action invocation data such as call count, total time, average time, max time, exception count, and more. Developers can use these metrics to find hot methods and slow methods for precise optimization.
	Business Thread Monitoring Plugin	✅	✅	Analyzes business consumption across threads. Based on this data, you can adjust hardware resources and tune thread strategies appropriately.
	Time-Range Call Statistics Plugin	✅	✅	Focuses on action call counts in each time period of the day. Developers can analyze call frequencies by time window, prepare more machines before peak periods, and reduce machines after peak periods.
Extension Modules
	Domain Event	✅	✅	The domain event module wraps Disruptor usage. It is a lightweight, single-machine, ultra-fast MQ used for business decoupling and concurrency avoidance. Disruptor won the 2011 Duke's Program Framework Innovation Award.
	Generate .proto	✅	✅	Allows generating multiple objects into one `.proto` file, further simplifying jprotobuf usage.
	Room	✅	✅	Room module + Domain Event + built-in Kit = easy implementation of tabletop-style games.
	Simulation Client	✅	✅	This module simulates clients and reduces simulation workload. You only need to write corresponding requests and callbacks. With this module, when collaborating with frontend teammates, you no longer need repetitive "click again" style manual joint debugging. Unlike unit tests, this module can simulate a real network environment, and interaction with the server during simulation remains continuous and interactive.
	SDK Code Generation	✅	✅	The framework supports "write once, integrate everywhere" and provides code-generation helpers for clients, significantly reducing client development workload. You only need to write Java once to generate unified interaction APIs for Godot, UE, Unity, CocosCreator, Laya, React, Vue, Angular, and more. The generated APIs ensure explicit and type-safe parameters so potential issues are detected at compile time. This effectively avoids security risks and reduces low-level integration errors.
	Spring Integration	✅	✅	Integration with Spring and usage of the Spring ecosystem.
	Robot Solution	❌	❌	Room + Robot + code generation (SDK) = rapid development of multiplayer online games with bots.
General Capabilities
	Load Balancing	❌	✅	Improves performance and response speed, and enhances system scalability. Distributes a large number of requests evenly across multiple logic servers to prevent single-server overload, slow response, or crashes.
	Run Multiple Same-Type Logic Servers	❌	✅	Supports running multiple logic servers of the same type and splitting business requests with load balancing.
	Run Multiple External Servers	❌	✅	Supports more user connections and more connection protocols, such as WebSocket, TCP, and UDP.
Deployment
	Single Machine, Single Process	✅	✅	Supports single-machine single-process startup, and multiple logic servers can run within one process.
	Single Machine, Multiple Processes	✅	✅	Supports running multiple processes on one machine, with network communication between processes.
	Multiple Machines	❌	✅	Supports running processes across multiple machines, with network communication between machines.

Dual-Version Strategy

We adopt a dual-version strategy (open-source edition / enterprise edition) to precisely align the framework's core value with customer complexity requirements.

1. Focus on core value: The open-source edition focuses on high-performance single-machine communication and an extremely simple development experience, providing most developers with a free and practical foundation for rapid application development.
2. Manage complexity: Multi-machine distributed capability inevitably introduces additional learning cost. Placing it in the enterprise edition avoids forcing users without high scalability needs to pay this complexity cost.
3. Sustainable growth: By providing professional services for business customers who need high scalability (such as technical support and custom development), the enterprise edition better supports continuous framework development, maintenance, and ecosystem growth.

---

Open-Source Edition - High-Performance Single Machine and Minimalism

The open-source edition streamlines distributed features, greatly lowering the onboarding threshold and learning cost. It is dedicated to delivering a high-performance single-machine deployment solution. A single machine supports multi-process startup, which is sufficient for the vast majority of projects.

The connection upper bound of the open-source edition depends on the hardware limits of a single machine.

Enterprise Edition - Horizontal Scalability

The core value of the enterprise edition is horizontal scalability. Through distributed deployment across multiple machines and nodes, it breaks through the physical limits of a single machine and supports hundreds of millions of connections and ultra-high concurrency scenarios. In addition, the enterprise edition provides comprehensive functional enhancements and performance optimizations for distributed scenarios, enabling seamless horizontal scaling.

• Horizontal scalability
  • Supports distributed deployment across multiple machines and nodes.
  • Supports built-in load-balancing strategies to distribute requests efficiently and evenly across nodes.
  • Supports running multiple external servers.
  • Supports running multiple logic servers of the same type.
• Observability and operations
  • Supports end-to-end call trace logs for faster issue diagnosis in distributed environments.
  • Supports broadcast logs.
• Enhanced communication model
  • Supports distributed EventBus for lightweight cross-service event communication.
  • Supports the request/multiple_response model, breaking traditional RPC limitations.
• Business capabilities
  • Supports dynamic logic-server binding.
  • Supports external-server caching to reduce backend logic-server pressure and accelerate data responses.

Enterprise Performance Improvements

Sharding for internal request/callback messages

Suitable for systems that require extremely low latency, strict thread-resource control, and synchronized cleanup work with the Aeron I/O loop.

By constraining critical operations to Aeron threads, the threading model is simplified, avoiding extra timer threads and cross-thread synchronization complexity. Cleanup is performed when Aeron threads are idle, ensuring cleanup does not compete for I/O resources during peak network load.

Characteristics: Sharding improves concurrency and distributes load through Aeron threads. Each invocation cleans only one shard, avoiding long single cleanup operations and preserving a low-latency, non-blocking main loop. This is a high-performance design that better follows Aeron's philosophy (avoiding GC and thread context switches).

---

Enhanced message publishing

Message publishing is lock-free and specifically designed for multi-producer, single-consumer scenarios. It is array-based with memory allocated at initialization, avoiding runtime GC pressure and delivering very high performance with no lock contention or blocking.

Latency remains low when messages are present. When no messages are being published, a progressive backoff strategy is applied, using a high-performance adaptive idle strategy to release CPU resources efficiently.

This implementation is a better high-performance approach that aligns with Aeron philosophy. It uses a lock-free queue to decouple multi-threaded writes and an adaptive idle strategy so the single writer thread releases CPU efficiently when idle and remains low-latency under load.

How to Get the Enterprise Edition

The enterprise edition is not open source, but we provide the following ways to obtain it:

• Paid option: purchase separately.
• Free option: Get Enterprise Edition for Free.