ionet documentation documentation

ionet possesses the capability of "write once, connect everywhere," and it provides code generation assistance for clients, which can help client developers reduce a significant workload.

You only need to write Java code once, and you can generate unified interaction interfaces for projects such as Godot, UE, Unity, CocosCreator, Laya, React, Vue, Angular... and more.

Supported languages: C#、TypeScript、GDScript、C++、Lua.

Client requests _server

Java Action

C#
TypeScript
GDScript
C++
Lua

public async Task TestLoginVerify()
{
    var loginVerifyMessage = new LoginVerifyMessage { Jwt = "10" };

    // code style: callback. Advantages: simple, integrated.
    // cn: 编码风格：回调。 优点：简洁，一体化。
    MyAction.OfLoginVerify(loginVerifyMessage, result =>
    {
        var userMessage = result.GetValue<UserMessage>();
        result.Log(userMessage);
    });

    // code style: async await. Advantages: Avoid callback hell.
    // cn: 编码风格：async await 机制。 优点：可避免回调地狱。
    var result = await MyAction.OfAwaitLoginVerify(loginVerifyMessage);
    var userMessage = result.GetValue<UserMessage>();
    result.Log(userMessage);
}

public async Task TestIntValue()
{
    const int value = 1;

    MyAction.OfIntValue(value, result =>
    {
        result.Log(result.GetInt());
    });

    var result = await MyAction.OfAwaitIntValue(value);
    result.Log(result.GetInt());
}

public async Task TestListString()
{
    const string value = "hello";

    MyAction.OfListString(value, result =>
    {
        result.Log(result.ListString());
    });

    var result = await MyAction.OfAwaitListString(value);
    result.Log(result.ListString());
}

export async function testLoginVerify() {
    const loginVerifyMessage = create(LoginVerifyMessageSchema, {jwt: "10"});
    
    // code style: callback. Advantages: simple, integrated.
    // cn: 编码风格：回调。 优点：简洁，一体化。
    MyAction.ofLoginVerify(loginVerifyMessage, result => {
        const message = result.getValue(UserMessageSchema);
        result.log(message);
    });

    // code style: async await. Advantages: Avoid callback hell.
    // cn: 编码风格：async await 机制。 优点：可避免回调地狱。
    var result = await MyAction.OfAwaitLoginVerify(loginVerifyMessage);
    const message = result.getValue(UserMessageSchema);
    result.log(message);
}

export async function testIntValue() {
    const value = 1;
    MyAction.ofIntValue(value, result => {
        result.log(result.getInt());
    });

    const result = await MyAction.ofAwaitIntValue(value);
    result.log(result.getInt());
}

export async function testListString() {
    const value = "hello";
    MyAction.ofListString(value, result => {
        result.log(result.listString());
    });

    const result = await MyAction.ofAwaitListString(value);
    result.log(result.listString());
}

func test_login_verify():
    var verify_message := Common.LoginVerifyMessage.new()
    verify_message.set_jwt("10")
    
    // code style: callback. Advantages: simple, integrated.
    // cn: 编码风格：回调。 优点：简洁，一体化。
    MyAction.of_login_verify(verify_message, func(result: IoGame.ResponseResult):
        var user_message := result.get_value(Common.UserMessage) as Common.UserMessage
        result.log(user_message)
    )
    
    // code style: async await. Advantages: Avoid callback hell.
    // cn: 编码风格：async await 机制。 优点：可避免回调地狱。
    var _result := await MyAction.of_await_login_verify(verify_message)
    var user_message := result.get_value(Common.UserMessage) as Common.UserMessage
    _result.log(user_message)


func test_int_value():
    var value: int = 1
    
    MyAction.of_int_value(value, func(result: IoGame.ResponseResult):
        result.log(result.get_int())
    )
    
    var _result := await MyAction.of_await_int_value(value)
    _result.log(_result.get_int())


func test_list_string():
    var value := "hello"
    
    MyAction.of_list_string(value, func(result: IoGame.ResponseResult):
        result.log(result.list_string())
    )
    
    var _result := await MyAction.of_await_list_string(value)
    _result.log(_result.list_string())    
                            

@ActionController(1)
public final class MyAction {
    @ActionMethod(1)
    private UserMessage loginVerify(LoginVerifyMessage verifyMessage) {
        var userMessage = new UserMessage();
        ... 
        return userMessage;
    }
    
    @ActionMethod(2)
    private int intValue(int value) {
        return value + 1;
    }
    
    @ActionMethod(3)
    private List<String> listString(String value) {
        return List.of(value, "ionet");
    }
}

.proto

syntax = "proto3";
package common;

// LoginVerify
message LoginVerifyMessage {
    // jwt
    string jwt = 1;
}

// User
message UserMessage {
    // userId
    int64 user_id = 1;
    // nickname
    string name = 2;
}

Nanosecond-Level End-to-End Latency

ionet is built for ultra-low latency and high throughput with lock-free design and minimal runtime overhead.

Client SDK and Code Generation

Write server-side Java once, then generate unified client interfaces for engines and web apps. Supported languages include C#、TypeScript、GDScript、C++、Lua.

Multiple Protocols and Connections

Reuse one business codebase across Protobuf、JSON and connection types like TCP、WebSocket、UDP.

Load Balancing and Distributed Scaling

Built-in load balancing and flexible service topology help you scale out or in with minimal friction.

Thread Safety by Design

Consistent threading strategy helps avoid user-level concurrency issues and simplifies safe business logic.

Flexible Architecture

External services and logic services can run independently or together, adapting to different game and app models.

Modular Services

Logic services can run as standalone components, making feature reuse and modularization straightforward.

Multiple Communication Models

Supports broadcast, request/void, and request/response models for different interaction patterns.

MVC-like Development Style

A clean Java Bean style helps keep action logic clear and avoids class explosion in large projects.

Excellent DX and Fewer Integration Docs

With protocol contracts in code, validation, and error assertions, integration and maintenance become much easier.

Simulated Client Requests

Simulate real network interactions for long-running, interactive testing without manual repetitive frontend clicks.

Pluggable Architecture

Extensible plugins support observability and debugging so issues can be detected earlier in development.