Lync

Buffer networking for Roblox.

Releases · Install · Example · Codecs · Benchmarks

Lync batches all sends into a single buffer per player per frame, applies XOR compression across frames, validates and rate-limits every incoming payload, and does it all without code generation.

Install

Wally

[dependencies]
Lync = "axp3cter/lync@2.1.2"

npm (roblox-ts)

npm install @axpecter/lync

import Lync from "@axpecter/lync";

Or grab the .rbxm from Releases.

[!IMPORTANT] Define all packets, queries, and groups before calling Lync.start().

Example

Shared (ReplicatedStorage.Net)

local Lync = require(game.ReplicatedStorage.Lync)

local Net = {}

Net.State = Lync.packet("State", Lync.deltaStruct({
    position = Lync.vec3,
    health   = Lync.float(0, 100, 0.5),
    shield   = Lync.float(0, 100, 0.5),
    status   = Lync.enum("idle", "moving", "attacking", "dead"),
    alive    = Lync.bool,
}))

Net.Hit = Lync.packet("Hit", Lync.struct({
    targetId = Lync.int(0, 65535),
    damage   = Lync.float(0, 200, 0.1),
    headshot = Lync.bool,
}), {
    rateLimit = { maxPerSecond = 30, burst = 5 },
    validate = function(data, player)
        if data.damage > 200 then return false, "damage" end
        return true
    end,
})

Net.Chat = Lync.packet("Chat", Lync.struct({
    msg     = Lync.string(200),
    channel = Lync.int(0, 255),
}))

Net.Ping = Lync.query("Ping", Lync.nothing, Lync.f64, { timeout = 3 })

return table.freeze(Net)

Server

local Lync    = require(game.ReplicatedStorage.Lync)
local Net     = require(game.ReplicatedStorage.Net)
local Players = game:GetService("Players")

local alive = Lync.group("alive")

Lync.onDrop(function(player, reason, name)
    warn(player.Name, "dropped", name, reason)
end)

Lync.start()

Players.PlayerAdded:Connect(function(player) alive:add(player) end)

game:GetService("RunService").Heartbeat:Connect(function()
    Net.State:send({
        position = Vector3.new(0, 5, 0),
        health   = 100,
        shield   = 50,
        status   = "idle",
        alive    = true,
    }, alive)
end)

Net.Hit:on(function(data, player)
    local target = Players:GetPlayerByUserId(data.targetId)
    if not target then return end
    alive:remove(target)
    Net.Chat:send({ msg = player.Name .. " eliminated " .. target.Name, channel = 0 }, Lync.all)
end)

Net.Ping:handle(function(_, player) return os.clock() end)

Client

local Lync = require(game.ReplicatedStorage.Lync)
local Net  = require(game.ReplicatedStorage.Net)

Lync.start()

local scope = Lync.scope()

scope:on(Net.State, function(state)
    local character = game.Players.LocalPlayer.Character
    if not character then return end
    character:PivotTo(CFrame.new(state.position))
end)

scope:on(Net.Chat, function(data) print("[chat]", data.msg) end)

Net.Hit:send({ targetId = 123, damage = 45.5, headshot = true })

local serverTime = Net.Ping:request(nil)
if serverTime then print("server clock:", serverTime) end

Packets

Lync.packet(name, codec, options?)

Options

Sending

-- Server
packet:send(data, player)
packet:send(data, Lync.all)
packet:send(data, Lync.except(p1, p2))
packet:send(data, { p1, p2, p3 })
packet:send(data, group)

-- Client
packet:send(data)

Receiving

Queries

Lync.query(name, requestCodec, responseCodec, options?)

Request-response built on packets. Returns nil on timeout.

Options

Methods

Each query consumes two packet IDs internally.

Groups

Lync.group(name)

Named player sets. Members auto-removed on PlayerRemoving. Iterable with for player in group do.

Scope

Lync.scope()

Batches connections for cleanup.

local scope = Lync.scope()
scope:on(packetA, fnA)
scope:on(packetB, fnB)
scope:add(someRBXScriptConnection)
scope:destroy()  -- disconnects everything

Connection

Returned by packet:on(), packet:once(), query:handle(), and middleware functions.

Middleware

Lync.onSend(function(data, name, player)
    return data  -- or return Lync.DROP to discard
end)

Lync.onReceive(function(data, name, player)
    return data
end)

Lync.onDrop(function(player, reason, name, data)
    warn(player.Name, "dropped", name, reason)
end)

All three return a Connection.

Targets

Server-side second argument to packet:send().

Codecs

Numbers

Lync.int(min, max) picks the smallest wire type for your range.

Strings & Buffers

Roblox Types

Quantized Variants

Call the codec to get a quantized version.

Composites

Delta

Only works with reliable transport. Sends 1 byte when data hasn't changed.

Meta

Rate Limiting

Two modes (pick one per packet):

Token bucket: { maxPerSecond = N, burst = M }

Cooldown: { cooldown = seconds }

Global limit across all packets: Lync.configure({ globalRateLimit = { maxPerSecond = N } })

Configuration

Lync.configure(options) — call before Lync.start().

Lifecycle

Stats

Enable with Lync.configure({ stats = true }).

Debug

Limits

Benchmarks

Run rojo serve bench.project.json with one server + one client.

Wire Sizes

Codec Throughput

100k iterations, isolated CPU. No networking.

Delta Savings

Network Throughput

1000 fires/frame, 8 seconds, one player.

Cross-Library Comparison

Same methodology as Blink's benchmarks: 1,000 fires/frame, same data every frame, 10 seconds.

Other tool numbers from Blink v0.17.1 (2025-04-30).

[!NOTE] Lync batches all sends into one buffer per frame. Other tools fire one RemoteEvent per send. Lync also includes server-side validation and bool bitpacking (1000 bools = 127B vs ~1002B). Delta compression is not exercised here — see Delta Savings.

Entities — 100× struct(6× u8)

Booleans — 1000× bool

License

MIT