NeonConfig cfg = NeonConfig.defaults(); // relay port 7777
NeonRelay relay = new NeonRelay("0.0.0.0", cfg);
Thread.ofVirtual().start(relay::startAndRun);

import threading
from qti_neon import NeonRelay, NeonConfig

relay = NeonRelay("0.0.0.0", NeonConfig())
threading.Thread(target=relay.start_and_run, daemon=True).start()

import { NeonRelay } from 'qti-neon';

const relay = new NeonRelay('0.0.0.0'); // relay port 7777
await relay.start();

var relay := NeonRelay.new("0.0.0.0")  # relay port 7777
var thread := Thread.new()
thread.start(relay.start_and_run)

cfg := qtineon.DefaultConfig() // relay port 7777
relay, _ := qtineon.NewRelay("0.0.0.0", cfg)
go relay.StartAndRun()

NeonHost host = new NeonHost(42, "relay.example.com:7777", cfg);
host.setClientConnectCallback((id, name, sid) ->
    System.out.println(name + " joined as " + (id & 0xFF)));
host.setUnhandledPacketCallback((type, from, payload) ->
    handleGamePacket(type, from));
Thread.ofVirtual().start(() -> host.startAndRun());

import threading
from qti_neon import NeonHost

host = NeonHost(session_id=42, relay_address="relay.example.com:7777")
host.set_client_connect_callback(lambda cid, name, sid: on_client_join(cid, name))
host.set_unhandled_packet_callback(lambda ptype, sender, payload: handle_game_packet(ptype, sender))
threading.Thread(target=host.start_and_run, daemon=True).start()

import { NeonHost } from 'qti-neon';

const host = new NeonHost(42, 'relay.example.com:7777');
host.setClientConnectCallback((id, name, sid) => onClientJoin(id, name));
host.setUnhandledPacketCallback((type, from, payload) => handleGamePacket(type, from));
await host.start();

var host := NeonHost.new(42, "relay.example.com:7777")
host.set_client_connect_callback(func(id, name, sid): on_client_join(id, name))
host.set_unhandled_packet_callback(func(type, from, payload): handle_game_packet(type, from))
var thread := Thread.new()
thread.start(host.start_and_run)

host, _ := qtineon.NewHost(42, "relay.example.com:7777", cfg)
host.SetClientConnectCallback(func(id uint8, name string, sid int32) {
    fmt.Println(name, "joined as", id)
})
host.SetUnhandledPacketCallback(func(ptype, from uint8, payload []byte) {
    handleGamePacket(ptype, from)
})
go host.StartAndRun()

NeonClient client = new NeonClient("player1", cfg);
client.setSessionConfigCallback(sc ->
    System.out.println("Tick rate: " + sc.tickRate()));
client.setUnhandledPacketCallback((type, from, payload) ->
    handleGamePacket(type, from));

if (client.connect(42, "relay.example.com:7777")) {
    Thread.ofVirtual().start(client::run);
}

import threading
from qti_neon import NeonClient

client = NeonClient("player1")
client.set_session_config_callback(lambda sc: on_session_config(sc))
client.set_unhandled_packet_callback(lambda ptype, sender, payload: handle_game_packet(ptype, sender))

if client.connect(session_id=42, relay_address="relay.example.com:7777"):
    threading.Thread(target=client.run, daemon=True).start()

import { NeonClient } from 'qti-neon';

const client = new NeonClient('player1');
client.setSessionConfigCallback(sc => onSessionConfig(sc));
client.setUnhandledPacketCallback((type, from, payload) => handleGamePacket(type, from));

await client.connect(42, 'relay.example.com:7777');

var client := NeonClient.new("player1")
client.set_unhandled_packet_callback(func(type, from, payload): handle_game_packet(type, from))

if client.connect(42, "relay.example.com:7777"):
    var thread := Thread.new()
    thread.start(client.run)

client, _ := qtineon.NewClient("player1", cfg)
client.SetSessionConfigCallback(func(sc qtineon.SessionConfig) {
    fmt.Println("Tick rate:", sc.TickRate)
})
client.SetUnhandledPacketCallback(func(ptype, from uint8, payload []byte) {
    handleGamePacket(ptype, from)
})

if client.Connect(42, "relay.example.com:7777") {
    go client.Run()
}

byte[] data = encodePosition(x, y, z);
client.sendPacket(data, PACKET_POSITION, (byte) 0); // 0 = broadcast

data = encode_position(x, y, z)
client.send_packet(data, PACKET_POSITION, dest_id=0)  # 0 = broadcast

const data = encodePosition(x, y, z);
client.sendPacket(data, PACKET_POSITION, 0); // 0 = broadcast

var data := encode_position(x, y, z)
client.send_packet(data, PACKET_POSITION, 0)  # 0 = broadcast

data := encodePosition(x, y, z)
client.SendPacket(data, PacketPosition, 0) // 0 = broadcast

client.stop(); // or socket dies ungracefully
// ...
boolean ok = client.reconnect(); // uses stored session token

client.stop()  # or socket dies ungracefully
# ...
ok = client.reconnect()  # uses stored session token

client.stop(); // or socket dies ungracefully
// ...
const ok = await client.reconnect(); // uses stored session token

client.stop()  # or socket dies ungracefully
# ...
var ok := client.reconnect()  # uses stored session token

client.Stop() // or socket dies ungracefully
// ...
ok := client.Reconnect(5) // uses stored session token, up to 5 attempts

// Relay — load a PKCS12 keystore with the relay's certificate
KeyStore ks = KeyStore.getInstance("PKCS12");
try (var is = new FileInputStream("relay.p12")) {
    ks.load(is, "password".toCharArray());
}
SSLContext relayCtx = DtlsConfig.fromKeyStore(ks, "password".toCharArray());

NeonConfig relayCfg = NeonConfig.builder()
    .sslContext(relayCtx)
    .build();

// Host / Client — trust the relay certificate (or use a proper TrustManager)
SSLContext clientCtx = DtlsConfig.insecureTrustAll(); // dev only
NeonConfig clientCfg = NeonConfig.builder()
    .sslContext(clientCtx)
    .build();

from qti_neon import DtlsConfig, NeonConfig, NeonRelay, NeonClient

# Relay — load certificate and private key
relay_cfg = NeonConfig(dtls_config=DtlsConfig.from_key_store("relay.crt", "relay.key"))
relay = NeonRelay("0.0.0.0", relay_cfg)

# Host / Client — trust the relay certificate (or supply a proper trust store)
client_cfg = NeonConfig(dtls_config=DtlsConfig.insecure_trust_all())  # dev only
client = NeonClient("player1", client_cfg)

import { DtlsConfig, NeonConfig, NeonRelay, NeonClient } from 'qti-neon';

// Relay — load certificate and private key
const relayCfg = new NeonConfig({ dtlsConfig: DtlsConfig.fromKeyStore('relay.crt', 'relay.key') });
const relay = new NeonRelay('0.0.0.0', relayCfg);

// Host / Client — trust the relay certificate (or supply a proper trust store)
const clientCfg = new NeonConfig({ dtlsConfig: DtlsConfig.insecureTrustAll() }); // dev only
const client = new NeonClient('player1', clientCfg);

# Relay — load certificate and private key (PEM files)
var relay_cfg := NeonConfig.new({dtls_config = DtlsConfig.from_key_store("relay.crt", "relay.key")})
var relay := NeonRelay.new("0.0.0.0", relay_cfg)

# Host / Client — trust the relay certificate (or use insecure for dev)
var client_cfg := NeonConfig.new({dtls_config = DtlsConfig.insecure_trust_all()})  # dev only
var client := NeonClient.new("player1", client_cfg)

// Relay — load a PEM certificate and private key
relayCfg := qtineon.DefaultConfig()
relayCfg.DTLS, _ = qtineon.FromKeyStore("relay.pem", "relay-key.pem")
relay, _ := qtineon.NewRelay("0.0.0.0", relayCfg)

// Host / Client — trust the relay certificate (or supply a proper trust store)
clientCfg := qtineon.DefaultConfig()
clientCfg.DTLS = qtineon.InsecureTrustAll() // dev only
client, _ := qtineon.NewClient("player1", clientCfg)

<dependency>
    <groupId>com.quietterminal</groupId>
    <artifactId>qti-neon</artifactId>
    <version>1.0.0</version>
</dependency>

pip install qti-neon

With DTLS support:

pip install "qti-neon[dtls]"

npm install qti-neon

With DTLS support:

npm install koffi

Copy (or symlink) godot/addons/qti_neon/ into your project's addons/ directory, then enable the plugin in Project → Project Settings → Plugins.

No package manager step is required — the implementation is pure GDScript with no external dependencies.

go get github.com/Quiet-Terminal-Interactive/QTINeon/go

DTLS support (github.com/pion/dtls/v2) is a direct dependency and requires no extra installation step.

mvn verify

Tests that open UDP sockets (most of them) must run outside a sandbox:

mvn test

Generate docs:

mvn javadoc:javadoc
# output: target/reports/apidocs/index.html

cd python
pip install -e ".[dev]"
pytest

Generate docs:

pdoc src/qti_neon --output-dir ../docs/python
# output: ../docs/python/qti_neon.html

cd js-ts
npm install
npm test

Generate docs:

npm run docs
# output: ../docs/ts/index.html

No build step — the implementation is pure GDScript. To verify the compliance scripts parse correctly:

cd godot
godot --headless --check-only --script compliance/neon_host_runner.gd

To run the cross-language compliance tests (requires Java and Node.js):

python3 test_compliance.py

cd go
go build ./...
go vet ./...

Tests open real UDP sockets on loopback:

go test ./...

Generate docs:

gomarkdoc ./... --output ../docs/go/README.md
# output: ../docs/go/README.md