Primitive Types

local T = Flux.Types

Bool

Type<boolean>

One byte: 1 for true, 0 for false.

local Toggle = Flux.Server("Toggle", {
	T.String(32),
	T.Bool(),
})

Toggle:FireAll("night_mode", true)

A full byte per boolean, because there is no bit-packing. Eight flags cost eight bytes. If you send many booleans together, pack them into a T.UInt8() bitfield yourself:

local flags = 0
if isSprinting then flags = bit32.bor(flags, 1) end
if isCrouching then flags = bit32.bor(flags, 2) end
if isAiming    then flags = bit32.bor(flags, 4) end

State:FireAllUnreliable(flags)

Read returns value == 1, so any byte other than 1 decodes as false.

String

Type<string>

A varint length prefix followed by the raw bytes.

number

Optional maximum byte length, asserted on write.

local Chat = Flux.Server("Chat", { T.String() })
local Name = Flux.Server("Name", { T.String(20) })

Size

Length	Total bytes
`""`	1
`"gg"`	3
127 chars	128
128 chars	130
20,000 chars	20,003

The varint prefix is one byte up to 127, two up to 16,383, and three up to 2,097,151.

Strings are written with buffer.writestring, so they are byte sequences rather than character sequences. Binary data is safe, and maxLen counts bytes, not characters. A UTF-8 emoji costs four against the limit.

The maxLen bound

maxLen is enforced on write only, and it raises a Luau error rather than dropping the message:

assert(#v <= maxLen, "string exceeds max length")

Two consequences follow.First, it throws in your code at the Fire call site, not inside Flux. A server Fire with an over-long string errors inside your listener.Second, it is not inbound validation. Read ignores maxLen entirely, so a tampered client can send a string of any length and your server listener receives it in full.Always re-check length inside server listeners handling client data:

Chat:Connect(function(player, message)
    if typeof(message) ~= "string" or #message > 200 then
        return
    end
    -- safe to use
end)

Any

Type<any>

Falls back to the dynamic WriteAny and ReadAny encoder for this one entry.

Use it when a single argument’s shape genuinely varies but the rest of the payload is fixed.

local Analytics = Flux.Server("Analytics", {
	T.String(64),  -- event name, always a string
	T.Any(),       -- arbitrary payload
})

Analytics:Fire(player, "level_complete", {
	Level = 7,
	Time = 84.2,
	Deaths = 3,
})

T.Any() costs a type tag byte plus the value, which is exactly what an unschematised argument costs. It is the escape hatch rather than an optimisation: an event that is all T.Any() entries is byte-for-byte identical to one with no schema, just more verbose.

It is also the only schema option for datatypes Types has no constructor for:

local Layout = Flux.Server("Layout", {
	T.Any(),  -- UDim2, since no T.UDim2() exists
	T.Any(),  -- TweenInfo, since no T.TweenInfo() exists
})

For those, a custom type usually beats T.Any(). A UDim2 through T.Any() costs 17 bytes; decomposed into two Float32 scales and two Int16 offsets it costs 12, with no tag.

T.Any() inherits every dynamic-encoder limitation. Circular tables overflow the stack, unsupported datatypes become nil with only a sender-side warning, and non-integer numbers cost a full 8 bytes. See Serialization.

Entry Point

Classes

Namespaces

Internals

Primitive Types

Bool

String

Size

The maxLen bound

Any

Next steps

Roblox datatypes

Composites

​Bool

​String

​Size

​The maxLen bound

​Any

​Next steps

Roblox datatypes

Composites

Bool

String

Size

The maxLen bound

Any

Next steps