hibamoussaddar-lab/flux-relay

Batched binary networking for Roblox. Delta-encoded, XOR-framed, one RemoteEvent per frame.

Lync is a network transmission layer for Roblox that fundamentally rethinks how game state travels between server and clients. Instead of firing a RemoteEvent for every individual change, Lync gathers every mutation that happens during a frame, compresses them through delta encoding, wraps the result in an XOR-based frame, and pushes the entire batch through a single RemoteEvent per frame.

Think of it like a courier service that waits until the end of the day, packs every parcel into one truck, and drives a single optimized route — rather than sending a separate driver for every envelope. The result is quieter networking, smaller payloads, and a game loop that breathes.

The idea behind Lync is simple but potent: Roblox's network layer is already efficient, but developers often waste its potential by firing events in loops, broadcasting unchanged values, and sending tables that are 90% identical to the previous tick. Lync intercepts that behavior, diffs it against the last known state, and emits only the difference — then flags it so the receiver knows exactly how to reconstruct the whole picture.

Whether you're building a physics-driven sandbox, a fast-paced competitive experience, or a persistent world with hundreds of moving parts, Lync gives you a cleaner channel to speak through.

Every networked game is a conversation. Most developers shout — firing events constantly, hoping the client catches everything. Lync teaches your game to whisper. It listens to what changed, forgets what didn't, and packages the remainder into a compact, frame-aligned message.

This isn't just an optimization — it's a design stance. Once your state sync is batched and delta-encoded, you stop thinking in terms of "what do I send" and start thinking in terms of "what actually matters this frame." That shift changes how you architect gameplay systems, replication logic, and even your UI.

Lync also embraces a somewhat old-school idea: explicit framing. XOR framing isn't cryptographic — it's structural. It tags each packet so the receiver can validate, align, and decode without ambiguity. In a world of opaque serialization layers, Lync keeps the wire format legible.

• Delta-Encoded Payloads — Only the differences between frames are transmitted. No redundant data, no wasted cycles.
• XOR Frame Wrapping — Each batched payload is framed with a lightweight XOR mask for structural integrity and fast decode paths.
• One RemoteEvent Per Frame — Coalesces every queued mutation into a single network dispatch, dramatically reducing RemoteEvent chatter.
• Batched Mutation Queue — State changes are accumulated throughout the frame and flushed at a deterministic boundary.
• Deterministic Reconstruction — Clients rebuild full state from the last known snapshot plus the incoming delta, with no ambiguity.
• Schema-Agnostic — Works with arbitrary Lua tables, Instances references, and primitive types.
• Backpressure Awareness — If the queue grows beyond a threshold, Lync can drop non-critical mutations or force a full snapshot.
• Frame-Boundary Flush — Ties network emission to RunService.Heartbeat (or your chosen boundary) for predictable timing.
• Latency-Resilient — Handles out-of-order or dropped frames gracefully with snapshot resync.
• Minimal Footprint — No external services, no third-party dependencies, no telemetry.
• Responsive UI Integration — Pair Lync with your UI layer to keep replicated state and visual state in lockstep.
• Multilingual Documentation Support — Docs and inline comments are written to be translation-friendly, with clear, plain language and minimal jargon.
• Round-the-Clock Maintainer Support — Issues and discussions are triaged continuously; expect a response within the same day in most cases.
• MIT Licensed — Permissive, commercial-friendly, and built for the community.

Roblox developers inherit a networking model that's powerful but easy to misuse. It's tempting to fire a RemoteEvent for every part that moves, every stat that changes, every click that registers. That works — until it doesn't. Once you have 30 players, 500 moving objects, and a UI that updates every frame, the overhead becomes visible: latency spikes, jitter, and a creeping sense that the game is "heavy" even when nothing visually dramatic is happening.

Lync addresses this at the root. It gives you a state channel rather than an event channel. You describe what your world looks like, and Lync figures out the smallest possible message that gets the client from its last known world to the current one.

The benefits compound:

• Lower bandwidth per player — Fewer bytes, fewer events, fewer allocations.
• Smoother replication — Frame-aligned batches arrive in order and decode predictably.
• Simpler mental model — You stop hand-rolling deduplication logic in every system.
• Scalable architecture — As your player count grows, Lync's overhead stays flat.

It's the kind of library you introduce once and then forget about — because it quietly does its job while you build the parts of your game that players actually see.

Lync is organized into four conceptual layers. You don't need to understand all of them to use the library, but knowing the shape helps when you want to tune behavior.

1. The Mutation Queue Every time your game state changes — a part moves, a stat increments, an inventory slot swaps — you enqueue a mutation. The queue is intentionally dumb: it records what changed, not how. This keeps the hot path fast.

2. The Delta Encoder At the frame boundary, the encoder walks the queue, compares each mutation to the last known snapshot, and emits only the fields that differ. This is where the "delta" in delta-encoded comes from. If a part moved 0.01 studs, only that 0.01 is sent — not the entire CFrame.

3. The XOR Framer The resulting delta is wrapped in a frame. The frame carries a small header, a checksum-like XOR mask, and the payload. The mask isn't security — it's a fast structural check that lets the decoder reject malformed or misaligned packets without a full parse.

4. The Transport The framed payload is dispatched through a single RemoteEvent. On the client, Lync reverses the process: unframe, decode delta, apply to snapshot, and notify any listeners.

This layering is deliberate. Each stage is replaceable. If you want to swap XOR for a different framing scheme, you can. If you want to replace the queue with a priority system, you can. Lync is a pipeline, not a monolith.

Getting Lync into your project is intentionally boring — no exotic tooling, no build steps that require a degree in arcane configuration. You bring the library into your Roblox project, require it from both server and client, and then start describing state.

The workflow looks like this:

• Define your state schema — Decide which values are replicated. Lync works with tables, numbers, strings, booleans, and Instance references.
• Register mutations — When something changes, tell Lync. It handles the rest.
• Flush at frame boundary — Lync batches everything queued during the frame and emits a single framed payload.
• Listen on the client — The client receives the delta, applies it to its local snapshot, and fires your callbacks.

There's no ceremony. The library doesn't require you to rewrite your game around it. You can introduce Lync to one system at a time and expand as you see value.

Detailed walkthroughs live in the repository's documentation folder. The high-level map:

• Core Concepts — Snapshots, mutations, deltas, frames, and flush boundaries explained without hand-waving.
• Schema Design — How to structure your replicated state for maximum delta efficiency.
• Frame Lifecycle — The exact path a mutation takes from enqueue to client callback.
• Transport Tuning — Adjusting flush timing, queue limits, and backpressure thresholds.
• Error Recovery — What happens when a frame is dropped, delayed, or arrives out of order.
• Integration Recipes — Patterns for common Roblox systems: character movement, inventories, combat stats, world objects.
• Performance Notes — Where Lync spends its cycles, and how to keep it lean.

The documentation is written to be read once and referenced often. It avoids magic and favors plain explanations.

Lync ships with a test harness that simulates network conditions — latency, packet loss, reordering, and frame stalls — so you can see how the library behaves under stress before your players do. The harness is deliberately simple: a mock transport, a mock clock, and a set of assertions that verify delta correctness and frame integrity across thousands of frames.

If you extend Lync, the harness is the first place to add coverage. It's designed to be readable, hackable, and fast enough to run on every change.

Lync shines in scenarios where state changes are frequent but small:

• Physics Sandboxes — Hundreds of parts moving every frame, each with a tiny delta.
• Competitive Games — Player positions, cooldowns, and resource counts that need to be replicated precisely.
• Persistent Worlds — World state that evolves slowly but must stay consistent across sessions.
• UI-Replicated State — Inventories, quest logs, and stat panels that mirror server truth.
• Custom Replication Layers — When Roblox's built-in replication isn't granular enough for your design.

It's less useful for one-off, high-priority events (like a chat message or a single sound trigger) — those are better served by a direct RemoteEvent. Lync is for the steady drumbeat of state, not the occasional cymbal crash.

Lync is a networking tool. It's designed to make replication efficient, not to bypass platform rules or obscure malicious behavior. The XOR framing is structural, not cryptographic — it's there to validate packets, not to hide them. Developers using Lync are expected to follow Roblox's community standards and terms of service.

There's nothing covert about Lync. It's open, documented, and built in the spirit of making good architecture accessible.

The project is actively evolving. Planned directions include:

• Priority-Based Mutation Channels — Separate high-priority state (player health) from low-priority state (environmental detail).
• Adaptive Frame Sizing — Dynamically adjust batch size based on observed latency and packet loss.
• Snapshot Compression — Additional encoding passes for large snapshots during resync.
• Expanded Schema Types — First-class support for more Roblox-specific types (Vector3, Color3, Region3, etc.).
• Diagnostics Panel — A developer-facing overlay showing queue depth, delta size, and frame timing.
• Multi-Language Docs — Community translations of the core documentation, starting with Spanish and Portuguese.

Roadmap items are shaped by community feedback. If something matters to you, the issue tracker is the place to say so.

Contributions are welcome — bug reports, documentation fixes, feature proposals, and pull requests alike. The contribution guide covers coding conventions, test expectations, and the review process.

The short version: keep changes focused, write clear commit messages, add tests where it makes sense, and be kind in discussions. Lync is a community project, and it works best when the community feels welcome.

Issues and discussions are actively monitored. Expect a response within the same day for most questions, and always within a few days for complex topics. The maintainers aim to keep the project approachable — no gatekeeping, no "just read the source" answers.

If you're stuck, describe what you tried, what you expected, and what happened. That's usually enough to get to a solution quickly.

Lync is guided by a handful of principles that shape every decision:

• Clarity over cleverness — The wire format should be understandable by a human reading it.
• Composability over configuration — Layers should be replaceable without rewriting the whole pipeline.
• Predictability over magic — No hidden allocations, no surprise flushes, no implicit retries.
• Performance as a default — Efficiency isn't a mode; it's the baseline.
• Community as a collaborator — The project is shaped by the people who use it.

These principles aren't slogans — they're constraints. When a feature request conflicts with one of them, the conversation is about which principle matters more, not about whether principles matter at all.

Is Lync a replacement for Roblox's built-in replication? No — it's a complement. It handles a specific kind of traffic (batched state changes) and leaves everything else to the platform.

Does XOR framing provide security? No. It's structural validation, not encryption. Don't rely on it to protect data.

Can I use Lync with a custom transport? Yes. The transport layer is abstracted, so you can swap the RemoteEvent for something else if your architecture calls for it.

How does Lync handle dropped frames? The client detects sequence gaps and requests a snapshot resync. Details are in the error recovery documentation.

Does Lync work with StreamingEnabled? Yes, though you may want to tune flush boundaries to align with streaming chunks for maximum smoothness.

Is there a performance cost to batching? There's a small cost in the queue and encoder, offset by the reduction in RemoteEvent dispatches. In most cases, the net effect is a significant win.

Lync is released under the MIT License. You're welcome to use it in personal, commercial, and educational projects. The full license text is available at:

https://opensource.org/licenses/MIT

Copyright (c) 2026 Lync Contributors.

Lync is provided "as is," without warranty of any kind, express or implied. The maintainers are not responsible for any consequences arising from its use, including but not limited to data loss, gameplay disruption, or unexpected network behavior. You are responsible for testing Lync thoroughly in your own environment before deploying it to a live experience.

Roblox is a trademark of Roblox Corporation. Lync is an independent project and is not affiliated with, endorsed by, or sponsored by Roblox Corporation.

All trademarks and registered trademarks are the property of their respective owners.

binary networking for Roblox, batched RemoteEvent library, delta encoding for game state, XOR frame protocol, one RemoteEvent per frame, Roblox state replication, efficient Roblox networking, Roblox performance optimization, frame-boundary networking, Roblox multiplayer architecture, delta compression in Lua, Roblox replication layer, custom networking for Roblox, Roblox RemoteEvent optimization, low-bandwidth Roblox games, scalable Roblox networking, Roblox game state sync, Roblox developer tools 2026, Lua networking library, Roblox server-client communication.