BitNet

Lightning-fast, buffer-based networking library for Roblox.

BitNet replaces your RemoteEvents and RemoteFunctions with events and functions that you define in a single shared Networking module. They work like the Roblox ones you already know (FireServer, OnServerEvent, InvokeServer...), except each one is locked to a schema: a description of exactly what it sends.

Hit = RemoteEvent({
	Args = args(struct({ target = player, damage = u16, critical = bool })),
})

Because the server and client both know that schema, only the values go over the network. The keys and type information are never sent. This Hit fire costs 3 bytes and 1 bit, plus a 1-byte event id.

Why BitNet

• Smaller packets. Values are written into a buffer at the exact size you choose: a u8 is 1 byte, a bool is 1 bit
• Speed. Encoding and decoding are among the fastest out there (see Benchmark)
• Exploit-resistant by default. The server strictly decodes everything clients send. Malformed or out-of-bounds data is rejected before it reaches your handlers, and OnRejected tells you who sent it.
• Typed in Luau. Types come straight from the schema, so FireServer arguments and OnServerEvent parameters are type-checked in your editor with no extra steps.
• Built-in extras. Rate limiting, unreliable events, type-validation, sending only to nearby players, Zstd compression and more.

Benchmark

BitNet offers the best balance of speed and payload size: only 2 bytes behind Lync payloads, while running up to 2.4x faster.

• Primitive: A single u8
• Medium: Struct containing integers, strings and an array
• Complex: Struct containing integers, strings, nested structs, nested arrays

Installation

BitNet comes with a Networking template module. It already has every BitNet type, function and helper set up, ready for your remotes.

Manual: download BitNet.rbxm and Networking.rbxm from Releases and insert both into ReplicatedStorage.

Wally

[dependencies]
BitNet = "minecoiii2/bitnet@3.2.0"

Then copy Networking.luau into your project and change its require to point at your packages folder, e.g. ReplicatedStorage.Packages.BitNet.

Quick start

Every event and function goes in the table that Networking returns. The server and client both require this one module, so everything registers in the same order on both sides.

-- ReplicatedStorage.Networking
const BitNet = require(ReplicatedStorage.BitNet)({})
...

local Islands = enumFromKeys(IslandDictionary)

return {
	Chat = {
		Send = RemoteEvent({
			Args = args(string, u16),
		}),
		Receive = RemoteEvent({
			Args = args(player, string, u16),
		}),

		GetAllChats = RemoteFunction({
			Args = args(nothing),
			Returns = args(
				compress(array(
					struct({
						Sender = player,
						At = u48,
						Message = string,
						WasFiltered = bool,
					})
				))
			)
		}),
	},

	TeleportToIsland = RemoteEvent({
		Args = args(Islands, uuid, u32),
	}),
}

-- Server
const Networking = require(ReplicatedStorage.Networking)

Networking.Chat.Send.OnServerEvent:Connect(function(player, message, channel)
	Networking.Chat.Receive:FireAllClients(player, message, channel)
end)

Networking.Chat.GetAllChats:SetServerCallback(function(player)
	return AllReceivedChats
end)

-- Client
const Networking = require(ReplicatedStorage.Networking)

Networking.Chat.Receive.OnClientEvent:Connect(function(player, message, channel)
	print(message, 'sent by', player, 'in channel', channel)
end)

Networking.Chat.Send:FireServer("hello", 1)

Types

The narrow types (u24, i24, f24, u48, i48, vec*i16, cframe) save bytes but cost a bit of CPU. In the Networking template, any is ref.

Combinators

• struct(format): table with fixed keys
• array(value): array of one type
• map(key, value): dictionary (up to 16,383 entries)
• optional(value): value or nil
• instance(...className): an Instance. instance() accepts any class, instance("BasePart", "Model") only those. Always call it, even with no classes
• tuple(...): multiple arguments
• enum(Enum.X): a Roblox EnumItem
• enumFromKeys(t) / enumFromValues(t): string from a known set, sent as an index
• compress(value, level?): Zstd-compresses the value when that makes it smaller

Events

RemoteEvent(options) in the template, BitNet.event(options) without it.

Methods:

• :FireServer(...)
• :FireClient(player, ...)
• :FireAllClients(...)
• :FireClientsStreamed(position, range, ...): Send to players within range
• :FireClientsStreamedWithExclusion(position, range, player, ...): Same, excluding one player

Listening:

• .OnServerEvent gives (player, ...)
• .OnClientEvent gives (...)

On the client, fires that arrive before anything is connected are queued (up to 256) and delivered once something connects.

Funcs

RemoteFunction(options) in the template, BitNet.func(options) without it.

Methods:

• :InvokeServer(...)
• :InvokeClient(player, ...)
• :SetServerCallback(fn)
• :SetClientCallback(fn)

If the other side can't answer (its callback errors, it has no callback, or RateLimit refused the call), the invoke errors right away with the reason instead of waiting for Timeout.

Configuration

require(BitNet) returns a function that starts BitNet. Call it once, at the top of Networking, with a table of overrides, or {} to keep the defaults:

-- ReplicatedStorage.Networking
const BitNet = require(ReplicatedStorage.BitNet)({
	DEFAULT_FUNC_TIMEOUT = 10,
	VALIDATE_OUTGOING_TYPES = true,
})

Other scripts get the same BitNet by calling it with no config: require(ReplicatedStorage.BitNet)(). Require Networking before doing that, otherwise BitNet starts with the defaults and Networking's own call errors.

Every other value in BitNet's constants module can be overridden the same way.

Important Notes

• Reliable and unreliable events aren't ordered relative to each other. If a reliable event is fired after an unreliable one, either one can be received first.
• :FireAllClients and :FireClient are batched separately. Within a frame, order is only kept between fires sent the same way, so a :FireAllClients can be received before a :FireClient that was called earlier. If two fires must arrive in order, send them the same way.

Trivia

• BitNet was originally meant to be a ByteNet fork, but it ended up turning into a full rewrite.

License

MIT