expert
50 min

Advanced Networking & Optimization

Optimize your game for performance and smooth network communication.

Network OptimizationLag CompensationReplication

1
Network Ownership

Understand and manage network ownership for smooth gameplay.

Setting Network Ownership

local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
  player.CharacterAdded:Connect(function(character)
    -- Give player ownership of their tools
    for _, tool in ipairs(player.Backpack:GetChildren()) do
      if tool:IsA("Tool") then
        local handle = tool:FindFirstChild("Handle")
        if handle then
          handle:SetNetworkOwner(player)
        end
      end
    end
    
    -- Set ownership for player's vehicle
    local vehicle = workspace:FindFirstChild(player.Name .. "_Vehicle")
    if vehicle then
      for _, part in ipairs(vehicle:GetDescendants()) do
        if part:IsA("BasePart") then
          part:SetNetworkOwner(player)
        end
      end
    end
  end)
end)

Give clients ownership of objects they control for better responsiveness.

💡 Tips:

  • • Give ownership to the player controlling the object
  • • Server retains ownership of important game objects
  • • Use SetNetworkOwnershipAuto() for shared objects

2
Efficient RemoteEvent Usage

Minimize network traffic and avoid exploits.

Batching Updates

-- CLIENT SCRIPT
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local remote = ReplicatedStorage.BulkUpdate

local updateQueue = {}
local lastSendTime = 0
local sendInterval = 0.1  -- Send every 100ms

local function queueUpdate(updateType, data)
  table.insert(updateQueue, {
    type = updateType,
    data = data,
    timestamp = tick()
  })
end

-- Send queued updates
game:GetService("RunService").Heartbeat:Connect(function()
  local currentTime = tick()
  
  if currentTime - lastSendTime >= sendInterval and #updateQueue > 0 then
    remote:FireServer(updateQueue)
    updateQueue = {}
    lastSendTime = currentTime
  end
end)

-- Usage
queueUpdate("position", character.HumanoidRootPart.Position)
queueUpdate("health", humanoid.Health)

Batch multiple updates into one RemoteEvent call to reduce network traffic.

Rate Limiting

-- SERVER SCRIPT
local rateLimits = {}
local MAX_REQUESTS_PER_SECOND = 10

local function isRateLimited(player)
  local userId = player.UserId
  local currentTime = tick()
  
  if not rateLimits[userId] then
    rateLimits[userId] = {
      requests = 0,
      resetTime = currentTime + 1
    }
  end
  
  local limit = rateLimits[userId]
  
  -- Reset if time window passed
  if currentTime >= limit.resetTime then
    limit.requests = 0
    limit.resetTime = currentTime + 1
  end
  
  -- Check if over limit
  if limit.requests >= MAX_REQUESTS_PER_SECOND then
    return true
  end
  
  limit.requests = limit.requests + 1
  return false
end

remote.OnServerEvent:Connect(function(player, ...)
  if isRateLimited(player) then
    warn(player.Name .. " is rate limited!")
    return
  end
  
  -- Process request
end)

Prevent exploiters from spamming RemoteEvents.

3
Replication Best Practices

Replicate only what players need to see.

Streaming Enabled Setup

-- Enable in game settings:
-- game.Workspace.StreamingEnabled = true

-- Handle streaming events
local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
  player.CharacterAdded:Connect(function(character)
    local humanoid = character:WaitForChild("Humanoid")
    
    -- Wait for important parts to stream in
    local function waitForPart(partName)
      local part = workspace:WaitForChild(partName, 5)
      if not part then
        warn("Part didn't stream in: " .. partName)
      end
      return part
    end
    
    -- Load important game objects
    waitForPart("SpawnArea")
    waitForPart("MainBuilding")
  end)
end)

Streaming Enabled only loads nearby parts, improving performance in large games.

💡 Tips:

  • • Enable Streaming for large worlds
  • • Replicate visual effects only to nearby players
  • • Use CollectionService to manage replicated objects
  • • Avoid replicating every frame - use intervals

Practice Exercises

Exercise 1: Create Rate Limiter

Create a simple rate limiter that allows 5 requests per second.

Starter Code:

local function canMakeRequest(player)
  -- Your rate limiting logic
  
end
Show Solution
local requests = {}

local function canMakeRequest(player)
  local userId = player.UserId
  local currentTime = tick()
  
  if not requests[userId] then
    requests[userId] = {}
  end
  
  -- Remove old requests
  local playerRequests = requests[userId]
  for i = #playerRequests, 1, -1 do
    if currentTime - playerRequests[i] > 1 then
      table.remove(playerRequests, i)
    end
  end
  
  -- Check limit
  if #playerRequests >= 5 then
    return false
  end
  
  table.insert(playerRequests, currentTime)
  return true
end

Ready for more?

Continue your learning journey

Executors.Online - Your Roblox Developer Hub