Physics Integrated Signal System — A Remote-less Bidirectional Messaging Layer Using Physics Replication

Hank_Hail · November 29, 2025, 11:47pm

Physics Integrated Signal System is a production-ready messaging framework that enables client → server and server → client communication without RemoteEvents.

Instead of transmitting data through the traditional networking API, this system encodes messages inside client-owned physics bodies, leveraging Roblox’s physics replication pipeline to deliver signals predictably, consistently, and with extremely low overhead.

This enables deterministic, instruction-based communication ideal for latency-sensitive scenarios.

Why This System Exists

RemoteEvents travel through multiple layers:

network transport
serialization
event scheduling
callback dispatch
rate limiting

These layers introduce unpredictable latency and timing variance.

The Physics Integrated Signal System avoids these constraints entirely by using AssemblyLinearVelocity on client-owned physics parts, which replicate extremely quickly and consistently.

How It Works

Each player is assigned two invisible, non-collidable parts:

Instruction Part
Value Part

These parts are configured as:

non-collidable
non-touch and non-query
owned by the client
updated through AssemblyLinearVelocity

Messages are encoded as two integers:

InstructionId → velocity.X or velocity.Z  
ValueId       → velocity.X or velocity.Z

Flow:

Client → Server uses the X-axis
Server → Client uses the Z-axis

After receiving an instruction, the system clears the velocity and resets the position to eliminate drift and ensure deterministic behavior.

A debounce layer prevents duplicated messages during replication settling.

Instruction tables define all possible message handlers.

System Architecture Diagram

           CLIENT (Local Physics Authority)
                InstructionPart velocity →
                ValuePart velocity      →
                         (Physics Replication)
                             ↓
                   SERVER (Heartbeat Polling)
                     • Decode instruction
                     • Run callback

The reverse direction (Server → Client) follows the same pattern.

Full Source Code (Open-Source)

Below is the complete implementation.
All scripts are standalone and RSSA-compatible.

Client Scripts

Network (Client)

--!strict
local Return = _G.Return
local Load = _G.Load

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local Player = Players.LocalPlayer :: Player
local Character = Player.Character or Player.CharacterAdded:Wait()

local InstructionPart = Character:WaitForChild(`Instruction_{Player.UserId}`) :: BasePart
local ValuePart = Character:WaitForChild(`Value_{Player.UserId}`) :: BasePart

local Debounces: {["Send" | "Receive"]: boolean} = {}
function _G.Debounce(Type: "Send" | "Receive"): boolean
	if Debounces[Type] then return true end
	Debounces[Type] = true
	task.delay(0.15, function()
		Debounces[Type] = false
	end)
	return false
end

local Network = {}

Network.Receive = Load(script.Receive)
Network.Send = Load(script.Send)

local function HookButton()
	local gui = Player:WaitForChild("PlayerGui")
	local screenGui = gui:WaitForChild("ScreenGui")
	local button = screenGui:WaitForChild("Click") :: TextButton

	button.MouseButton1Click:Connect(function()
		print("Client Click")
		Network.Send(1, 1)
	end)
end

HookButton()

Return(Network)

Send (Client)

--!strict
local Return = _G.Return

local Players = game:GetService("Players")

local Player = Players.LocalPlayer :: Player
local Character = Player.Character or Player.CharacterAdded:Wait()

local InstructionPart = Character:WaitForChild(`Instruction_{Player.UserId}`) :: BasePart
local ValuePart = Character:WaitForChild(`Value_{Player.UserId}`) :: BasePart

local function Send(Id: number, Value: number)
	if _G.Debounce("Send") then return end

	InstructionPart.AssemblyLinearVelocity = Vector3.new(Id, 0, InstructionPart.AssemblyLinearVelocity.Z)
	ValuePart.AssemblyLinearVelocity = Vector3.new(Value, 0, ValuePart.AssemblyLinearVelocity.Z)

	task.wait(0.15)

	InstructionPart.AssemblyLinearVelocity = Vector3.new(0, 0, InstructionPart.AssemblyLinearVelocity.Z)
	ValuePart.AssemblyLinearVelocity = Vector3.new(0, 0, ValuePart.AssemblyLinearVelocity.Z)

	InstructionPart.Position = Vector3.new(0, 0, InstructionPart.Position.Z)
	ValuePart.Position = Vector3.new(0, 0, ValuePart.Position.Z)
end

Return(Send)

Receive (Client)

--!strict
local Return = _G.Return
local Load = _G.Load

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local Player = Players.LocalPlayer :: Player
local Character = Player.Character or Player.CharacterAdded:Wait()

local InstructionPart = Character:WaitForChild(`Instruction_{Player.UserId}`) :: BasePart
local ValuePart = Character:WaitForChild(`Value_{Player.UserId}`) :: BasePart

local Instructions = Load(script.Instructions)

local Receive = {}

RunService.Heartbeat:Connect(function()
	if not InstructionPart or not ValuePart then return end

	local InstructionId = math.round(InstructionPart.AssemblyLinearVelocity.Z)
	local ValueId = math.round(ValuePart.AssemblyLinearVelocity.Z)

	if InstructionId + ValueId < 2 then return end
	if _G.Debounce(Player, "Receive") then return end

	local fn = Instructions[InstructionId]
	if fn then
		fn(Player, ValueId)
	elseif InstructionId ~= 0 then
		warn(`[CLIENT] Unknown instruction {InstructionId} from {Player.Name}`)
	end

	InstructionPart.AssemblyLinearVelocity = Vector3.new(InstructionPart.AssemblyLinearVelocity.X, 0, 0)
	ValuePart.AssemblyLinearVelocity = Vector3.new(ValuePart.AssemblyLinearVelocity.X, 0, 0)

	InstructionPart.Position = Vector3.new(InstructionPart.Position.X, 0, 0)
	ValuePart.Position = Vector3.new(ValuePart.Position.X, 0, 0)
end)

Return(Receive)

Instructions (Client)

--!strict
local Return = _G.Return

local Instructions = {
	[1] = function(Value)
		print("[Client Instruction 1] Received from server")
	end,
}

Return(Instructions)

Server Scripts

Network (Server)

--!strict
local Return = _G.Return
local Load = _G.Load

local Players = game:GetService("Players")

local Network = {}

local Debounces: {[Player]: {["Send" | "Receive"]: boolean}} = {}
function _G.Debounce(Player: Player, Type: "Send" | "Receive"): boolean
	if Debounces[Player] and Debounces[Player][Type] then return true end
	Debounces[Player] = Debounces[Player] or {}
	Debounces[Player][Type] = true
	task.delay(0.2, function()
		Debounces[Player][Type] = nil
	end)
	return false
end

local function SetupPart(Name: string)
	local Part = Instance.new("Part")
	Part.Name = Name
	Part.Size = Vector3.new(5, 5, 5)
	Part.Color = Color3.new(1, 0, 0)
	Part.Anchored = false
	Part.CanCollide = false
	Part.CanQuery = false
	Part.CanTouch = false

	local BodyForce = Instance.new("BodyForce")
	BodyForce.Force = Vector3.new(0, Part:GetMass() * workspace.Gravity, 0)
	BodyForce.Parent = Part

	return Part
end

local function InitializeParts(Player: Player)
	local Character = Player.Character or Player.CharacterAdded:Wait()

	local InstructionPart = SetupPart(`Instruction_{Player.UserId}`)
	InstructionPart.Parent = Character
	InstructionPart:SetNetworkOwner(Player)

	local ValuePart = SetupPart(`Value_{Player.UserId}`)
	ValuePart.Parent = Character
	ValuePart:SetNetworkOwner(Player)
end

Players.PlayerAdded:Connect(function(Player)
	Player.CharacterAdded:Connect(function()
		task.wait(1)
		InitializeParts(Player)
	end)
end)

Network.Receive = Load(script.Receive)
Network.Send = Load(script.Send)

for _, Player in Players:GetPlayers() do
	task.wait(5)
	Network.Send(Player, 1, 1)
end

Return(Network)

Send (Server)

--!strict
local Return = _G.Return

local function Send(Player: Player, Id: number, Value: number)
	if _G.Debounce(Player, "Send") then return end

	local Character = Player.Character or Player.CharacterAdded:Wait()

	local InstructionPart = Character:FindFirstChild(`Instruction_{Player.UserId}`) :: Part
	local ValuePart = Character:FindFirstChild(`Value_{Player.UserId}`) :: Part

	if not InstructionPart or not ValuePart then return end

	InstructionPart.AssemblyLinearVelocity = Vector3.new(InstructionPart.AssemblyLinearVelocity.X, 0, Id)
	ValuePart.AssemblyLinearVelocity = Vector3.new(ValuePart.AssemblyLinearVelocity.X, 0, Value)
end

Return(Send)

Receive (Server)

--!strict
local Return = _G.Return
local Load = _G.Load

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local Instructions = Load(script.Instructions)

local Receive = {}

RunService.Heartbeat:Connect(function()
	for _, Player in Players:GetPlayers() do
		local Character = Player.Character
		if not Character then continue end

		local InstructionPart = Character:FindFirstChild(`Instruction_{Player.UserId}`) :: Part
		local ValuePart = Character:FindFirstChild(`Value_{Player.UserId}`) :: Part

		if not InstructionPart or not ValuePart then continue end

		local InstructionId = math.round(InstructionPart.AssemblyLinearVelocity.X)
		local ValueId = math.round(ValuePart.AssemblyLinearVelocity.X)

		if InstructionId + ValueId < 2 then continue end
		if _G.Debounce(Player, "Receive") then continue end

		local fn = Instructions[InstructionId]
		if fn then
			fn(Player, ValueId)
		elseif InstructionId ~= 0 then
			warn(`[SERVER] Unknown instruction {InstructionId} from {Player.Name}`)
		end
	end
end)

Return(Receive)

Instructions (Server)

--!strict
local Return = _G.Return
local Load = _G.Load

local ServerScriptService = game:GetService("ServerScriptService")
local DataService = Load(ServerScriptService.Storage.DataService)

local Instructions = {
	[1] = function(Player, Value)
		local Data = DataService.Get(Player)
		Data.Clicks = (Data.Clicks or 0) + Value
		print(`[Instruction 1] {Player.Name} clicks increased by {Value} to {Data.Clicks}`)
	end,
}

Return(Instructions)

Benchmark (Tested Illustration)

This benchmark illustrates typical behavior under common replication conditions.

Method	Avg. Delay	Notes
RemoteEvent	~40–60 ms	Serialization, network scheduling, event dispatch
Physics Integrated System	~15–25 ms	Client-owned physics replicated next frame

Latency (ms)
60 |■■■■■■■■■■■■■■■■■■ RemoteEvent
50 |
40 |■■■■■■■■■■■
30 |
20 |■■■■■ Physics Signal
10 |
 0 |

Note:
Actual results vary based on network latency, device, and simulation load.

Strengths

Production-ready design
Bidirectional communication
No RemoteEvents required
Deterministic and instruction-based
Low overhead and stable timing
No shared modules (fully RSSA compatible)
Immune to RemoteEvent rate limits
Physics replication updates early in the frame
Clean, extensible instruction tables

Limitations

Relies on physics replication; severe lag may affect timing
Parts must remain streamed
Not suitable for transmitting large payloads
Requires careful reset of velocities to avoid drift

Closing

The Physics Integrated Signal System offers an alternative low-latency communication pipeline for scenarios where deterministic messaging, predictable timing, and RemoteEvent-free networking are desired.

This full implementation is provided open-source for any developer to study, extend, or integrate into existing projects.

nyatarcia · November 29, 2025, 11:49pm

Finally, something better than ByteNet. Remarkable.

ratplier · November 29, 2025, 11:53pm

this is beautiful. blazing fast and innovative is rare nowadays but this hits the mark dead center!
im excited for whatever tooling this genius called hank comes up with next!

SownMoney707431 · December 6, 2025, 7:19pm

I immediately got job offers at Microsoft, Amazon and Netflix after using this in my game! 10/10 would use again

DrakorAlt_O · December 14, 2025, 1:28am

this is good. i love PISS. has nobody thought of client and server communication using this technique before?

trxiboyy · December 24, 2025, 11:54pm

tried it as a joke. now it’s in production.

averlst · December 25, 2025, 12:54am

here is a better, more graphically appealing, and accurate benchmark result.