Supported Types

Flux automatically serializes the following types.

Supported

Hover any icon for what it means in that column.

Type	Schema constructor	Lossless
`nil`	`T.Optional(...)`
`boolean`	`T.Bool()`
`number`	`T.UInt8/16/32`, `T.Int8/16/32`, `T.Float32/64`
`string`	`T.String(maxLen?)`
`buffer`	not available
`table`	`T.Array`, `T.Struct`
`Instance`	`T.Instance()`
`Vector2`	`T.Vector2()`	`f32`
`Vector3`	`T.Vector3()`	`f32`
`CFrame`	`T.CFrame()`	axis-angle
`Color3`	`T.Color3()`	8-bit
`BrickColor`	not available
`Region3`	not available	loses rotation
`EnumItem`	`T.Enum(enum)`
`UDim`	not available	`f32` scale
`UDim2`	not available	`f32` scale
`TweenInfo`	not available

Six supported datatypes have no schema constructor: buffer, BrickColor, Region3, UDim, UDim2 and TweenInfo. Under a schema, use T.Any() or write a custom type.

Not supported

Sending any of these logs warn("Unsupported type: ...") on the sender, and the receiver gets nil.

Type	Send instead
`function`	An id or name the receiver maps to a local function
`thread`	nothing equivalent
`Vector2int16`, `Vector3int16`	Components as `T.Int16()`
`NumberRange`	Two numbers
`NumberSequence`, `ColorSequence`	An array of keypoint structs
`Ray`	Origin and direction as two `Vector3`
`Rect`	Two `Vector2`
`Axes`, `Faces`	A bitfield in a `T.UInt8()`
`PhysicalProperties`	Its six numbers
`Font`	Family string and weight enum
`DateTime`	`dateTime.UnixTimestamp` as `T.Float64()`
`RBXScriptSignal` / `Connection`	nothing equivalent
Metatables, `newproxy` userdata	nothing equivalent

This failure is silent on the receiving side. The argument count still matches, so your callback runs with a nil in that position and the only clue is one warning in the sender’s output. Check this table before sending an unusual datatype.

Tables

Arrays, dense 1..n

Written as TYPE_ARRAY plus a varint count. Round-trips exactly.

MyEvent:Fire({ 10, 20, 30 })  --> { 10, 20, 30 }

Dictionaries

Written as TYPE_TABLE with alternating keys and values. Keys are themselves dynamically encoded, so any serializable type works as a key.

MyEvent:Fire({ Health = 100, Team = "Red" })

Mixed tables

Fail the array test and take the dictionary path, which preserves both parts.

MyEvent:Fire({ 1, 2, Name = "x" })  --> { 1, 2, Name = "x" }

Sparse tables, reshaped

A table with gaps also takes the dictionary path, so it arrives as a dictionary with numeric keys rather than an array. #result is unreliable and ipairs stops at the first gap.

MyEvent:Fire({ [1] = "a", [3] = "c" })
-- arrives as { [1] = "a", [3] = "c" }, and #result is 1

Circular references, stack overflow

Recursion has no visited-set and no depth limit.

local t = {}
t.self = t
MyEvent:Fire(t)  -- STACK OVERFLOW

Break cycles before sending, or send an id and let the receiver rebuild.

Metatables and non-data fields

Metatables are never transmitted, so a received table is always a plain table. Function-valued fields become nil with a warning, which means an OOP instance arrives as its data fields only, without its methods.

Numbers

The dynamic encoder narrows integers automatically.

Value	Encoded as	Payload bytes
`0` to `255`	`u8`	1
`256` to `65,535`	`u16`	2
`65,536` to `2^32-1`	`u32`	4
`-1` to `-32,768`	`i16`	2
`-32,769` to `-2^31`	`i32`	4
any non-integer	`f64`	8
beyond the above	`f64`	8

There is no automatic f32 narrowing and no i8 selection. Every non-integer costs 8 bytes, and small negatives cost 2 where the same magnitude positive costs 1. Declare T.Float32() or T.Int8() in a schema to get those widths.

nan and inf are non-integers and go through f64, which transmits them faithfully. They will then propagate into the receiver’s arithmetic, so validate before sending.

Instances

varint index, 1 to 3 bytes

Instances ride in a side array passed alongside the buffer, and only an index is serialized. Cheap regardless of tree depth, and deduplicated within a batch.

nil

If the receiver cannot see the instance, whether server-only, not replicated, or destroyed before the flush, the index resolves to nil. No error is raised.

Highlight:Connect(function(part)
	if not part then return end
	-- safe
end)

Multiple return values

OnInvoke may return any number of values, and all of them survive.

-- Server
Shop.OnInvoke = function(player, itemId)
	return true, itemId, priceOf(itemId), os.time()
end

-- Client
local ok, item, price, at = Shop:Invoke("sword")

Invoke traffic always uses the dynamic encoder regardless of any schema, which is precisely why a variable return count works without you declaring anything. See Invocations.

Getting Started

Guides

Concepts

Reference

Supported Types

Supported

Not supported

Tables

Numbers

Instances

Multiple return values

Next steps

Known limits

Serialization

​Supported

​Not supported

​Tables

​Numbers

​Instances

​Multiple return values

​Next steps

Known limits

Serialization

Supported

Not supported

Tables

Numbers

Instances

Multiple return values

Next steps