Learn the Language

Luau Features

Luau is Roblox's enhanced version of Lua. It adds types, modern iteration, performance tweaks, and a bunch of new libraries. Everything here works in Roblox and will make your code cleaner and faster.

1. Type Annotations – Catch Bugs Early

You can annotate variables, parameters, and return types. It's optional but super helpful – the editor will highlight type mismatches.

local name: string = "Luau"
local age: number = 5

function greet(person: string, times: number): string
    return person .. " repeated " .. tostring(times)
end

2. Generalized Iteration – No More ipairs

You can iterate over any array‑like table directly – no need for ipairs or pairs.

local colors = {"red", "green", "blue"}
for color in colors do
    print(color)   -- red, green, blue
end

for index, color in colors do
    print(index, color)   -- 1 red, 2 green, 3 blue
end

3. New String and Table Utilities

• string.split – splits a string into parts.
• table.clone – shallow copy.
• table.find – returns index of a value.

local parts = string.split("a,b,c", ",")  -- {"a","b","c"}
local t = {x=1, y=2}
local copy = table.clone(t)
local idx = table.find({"cat","dog","bird"}, "dog")  -- 2

4. Arrow Functions – Shorter Syntax

You can write functions with => – they're shorter and great for one‑liners.

local add = (a, b) => a + b
print(add(2,3))  -- 5

-- With a block body:
local multiply = (a, b) => {
    local result = a * b
    return result
}

5. Enhanced pcall – Error Objects

Same as Lua, but you can also pass custom error objects.

6. Modules with Relative Paths

You can use require("folder.module") – it's cleaner.

7. Bit32 – Still There

Bitwise operations are the same as in Lua – band, bor, bxor, lshift, rshift.

8. Math Round, Sign, and More

Luau adds math.round, math.sign, and math.clamp.

print(math.round(3.6))  -- 4
print(math.sign(-5))    -- -1

9. Table Clear, Move, etc.

table.clear(t) empties a table, table.move copies elements to another table.

10. String.gmatch – Iterator over Matches

Great for parsing.

for word in string.gmatch("foo bar baz", "%a+") do
    print(word) -- foo, bar, baz
end

11. Task Library – Reliable Timers

The task library replaces wait(). It's more precise and doesn't get throttled.

task.spawn(function()
    task.wait(1)
    print("After 1 second")
end)

12. Buffer – Raw Bytes

buffer lets you work with binary data – useful for networking or file formats.

local buf = buffer.create(4)
buffer.writeu32(buf, 0, 12345)
print(buffer.readu32(buf, 0)) -- 12345

13. Debug Improvements

Better stack traces and more info in debug.getinfo.

14. Performance Tips – Cache Globals

Store frequently used globals in locals – it's faster.

local print = print
print("fast")

15. Type Aliases – Define Custom Types

You can create type aliases for complex types.

type PlayerData = { name: string, level: number }
local data: PlayerData = { name = "Alex", level = 10 }

16. Union Types – Multiple Possible Types

Use | to allow multiple types.

function getId(id: number | string): string
    return tostring(id)
end

17. Optional Types – ?

Mark a type as optional with ?.

function getAge(player: { age: number? })
    return player.age or 0
end

18. Never Type – no return

Use never for functions that never return (like error()).

function halt(): never
    error("halt")
end

19. Type Checking at Runtime

You can use type and typeof to check types at runtime.

20. String Methods – gmatch, split, etc.

All the string goodness from Lua, plus more.

Roblox Features

This is the good stuff – everything you need to build cool stuff in Roblox. From services to events to optimizations – we've got you covered.

1. Services – The Right Way

Always use game:GetService("ServiceName") to get services. It's faster and more reliable than using game.ServiceName.

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

2. Character Handling – Respawn‑Safe

Get the player's character – but be ready for respawns. Here's the pattern I use:

local LocalPlayer = Players.LocalPlayer
local Character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
-- Or just: local Character = LocalPlayer.CharacterAdded:Wait()

3. RunService – RenderStepped vs Heartbeat vs Stepped

• RenderStepped – runs every frame before rendering. Perfect for camera, UI, aimbots.
• Heartbeat – runs every physics tick. Use for physics, movement, etc.
• Stepped – before physics – rarely used.

4. Aimbot – The Clean Implementation

Here's that aimbot we talked about – simple, modern, and works.

-- (same as before – I'll keep it compact)
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Camera = workspace.CurrentCamera

local LocalPlayer = Players.LocalPlayer
local Character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
local currentTarget = nil
local isLocked = false

UserInputService.InputBegan:Connect(function(input, processed)
    if processed or input.KeyCode ~= Enum.KeyCode.E then return end
    isLocked = not isLocked
    if not isLocked then currentTarget = nil return end

    local root = Character:FindFirstChild("HumanoidRootPart")
    if not root then return end
    local pos = root.Position
    local closest, bestDist = nil, math.huge

    for _, other in Players:GetPlayers() do
        if other == LocalPlayer then continue end
        local char = other.Character
        if not char then continue end
        local otherRoot = char:FindFirstChild("HumanoidRootPart")
        local otherHead = char:FindFirstChild("Head")
        if not otherRoot or not otherHead then continue end
        local dist = (otherRoot.Position - pos).Magnitude
        if dist < bestDist then
            bestDist = dist
            closest = char
        end
    end
    currentTarget = closest
end)

RunService.RenderStepped:Connect(function()
    if not isLocked or not currentTarget then return end
    local head = currentTarget:FindFirstChild("Head")
    if head then
        Camera.CFrame = CFrame.lookAt(Camera.CFrame.Position, head.Position)
    end
end)

5. Raycasting – Shoot or Detect

Raycasting is essential for guns, line‑of‑sight, and picking things up.

local function raycast(origin, direction, range)
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Blacklist
    params.FilterDescendantsInstances = {Character}
    local result = workspace:Raycast(origin, direction * range, params)
    return result
end

6. RemoteEvents & RemoteFunctions

For client‑server communication – use RemoteEvents for one‑way, RemoteFunctions for request‑response.

-- Client
local remote = game:GetService("ReplicatedStorage").MyEvent
remote:FireServer("hello")

-- Server
remote.OnServerEvent:Connect(function(player, msg)
    print(player.Name .. " said: " .. msg)
end)

7. BindToClose – Clean Shutdown

Use this on the server to save data before the game closes.

game:BindToClose(function()
    -- save stuff
    print("Server shutting down")
end)

8. DataStores – Save Player Progress

Use DataStoreService to save player data across sessions.

local DataStoreService = game:GetService("DataStoreService")
local store = DataStoreService:GetDataStore("PlayerData")
store:SetAsync(player.UserId, {coins = 100})

9. Pathfinding – AI Movement

PathfindingService is your friend for NPC navigation.

local PathfindingService = game:GetService("PathfindingService")
local path = PathfindingService:CreatePath()
path:ComputeAsync(startPos, endPos)

10. TweenService – Smooth Animations

Animate properties smoothly – position, size, color, etc.

local TweenService = game:GetService("TweenService")
local tween = TweenService:Create(part, TweenInfo.new(1), {Position = Vector3.new(10,0,0)})
tween:Play()

11. CollectionService – Tagging

Tag instances and retrieve them easily – great for grouping enemies or interactables.

local CollectionService = game:GetService("CollectionService")
CollectionService:AddTag(part, "Enemy")
local enemies = CollectionService:GetTagged("Enemy")

12. UserInputService – Keyboard, Mouse, Gamepad

Handles all input – we used it in the aimbot. Also supports mouse movement, key up/down, etc.

13. ContextActionService – Key Bindings

Bind actions to keys with context – useful for menus or interaction prompts.

local ContextActionService = game:GetService("ContextActionService")
ContextActionService:BindAction("Jump", function(action, state, input)
    if state == Enum.UserInputState.Begin then
        -- jump
    end
end, false, Enum.KeyCode.Space)

14. SoundService – Playing Sounds

Manage audio globally – play sounds, adjust volume, etc.

15. PhysicsService – Collision Groups

Control which objects can collide – useful for filtering raycasts or making parts ignore each other.

16. HttpService – Making HTTP Requests

Send and receive data from web APIs – but be careful, it's limited on the client.

17. ScriptContext – Error Handling

You can set a global error handler with ScriptContext.Error to catch script errors.

18. LocalizationService – Multi‑Language

For internationalization – translate strings based on player's locale.

19. MarketplaceService – In‑Game Purchases

Handle developer products, game passes, and purchases.

20. Optimizations – Keep it Snappy

• Cache often‑used objects (like workspace).
• Avoid FindFirstChild in tight loops – use WaitForChild if you know it exists.
• Use task.wait() instead of wait() – it's more precise.
• Disable unnecessary physics on parts.
• Use Instance.new instead of cloning when possible.