Ruck Script (November 2026) – Inspector AIO

PUBLISHEDUPDATED
1 Available ScriptFree

Grinding out resources on a crowded server can get old fast, so adding the Ruck script to your routine makes the whole survival loop way smoother.

You start out with just a rock and need to open chests, grab power ups, build bases, and survive night monsters while fixing your ship to escape the island.

If you want to track down mobs, chests, and shrines without wasting time, check out the working script below.

Ruck Script – Inspector AIO & More

Inspector AIO & MoreFree
Inspector AIO
--[[
    RUCK INSPECTOR AIO
    Version: 0.1.0
    UI: WindUI 1.6.66

    Features:
    - ESP labels for Mobs, Chests, Shrines, Camps, Resources, Pickups
    - Per-category toggle, max distance and type filter
    - Mob species detected from name (Cow_1 -> Cow, Goblin_10 -> Goblin)
    - Optional highlights (Roblox only renders 31 at once, so nearest 30)
    - Diagnostics: type census, folder inspection, nearest object inspector
    - Single-instance guard (re-executing replaces the old copy)
    - RightShift / RightControl window toggle

    Target: Roblox Player
]]

--==================================================
-- INITIALIZATION
--==================================================

local VERSION = "0.1.0"
local WINDUI_VERSION = "1.6.66"
local startedAt = os.clock()

local WindUI = nil
local Window = nil
local Container = nil

local Connections = {}
local Entries = {} -- [instance] = entry

local CONTAINER_NAME = "RuckInspectorVisuals"

local CONFIG = {
    Version = VERSION,
    WindUIVersion = WINDUI_VERSION,
    MaxLogs = 60,
    Notifications = true,
}

local Settings = {
    Highlights = false,
    MaxHighlights = 30,
    ShowDistance = true,
    ShowHealth = true,
    ScanInterval = 1.5,
}

local State = {
    Running = true,
    Logs = {},
    TotalCreated = 0,
    TotalRemoved = 0,
    LastScan = "Never",
    LastScanClock = 0,
    ScanDirty = true,
}

--==================================================
-- SINGLE INSTANCE GUARD
--==================================================

local ENV = (type(getgenv) == "function" and getgenv()) or _G
local INSTANCE_KEY = "__RuckInspector"

local function sweepOrphans()
    local parents = {}

    if type(gethui) == "function" then
        pcall(function()
            table.insert(parents, gethui())
        end)
    end

    pcall(function()
        table.insert(parents, game:GetService("CoreGui"))
    end)

    pcall(function()
        local lp = game:GetService("Players").LocalPlayer
        local pg = lp and lp:FindFirstChild("PlayerGui")
        if pg then
            table.insert(parents, pg)
        end
    end)

    for _, parent in ipairs(parents) do
        pcall(function()
            while true do
                local found = parent:FindFirstChild(CONTAINER_NAME)
                if not found then
                    break
                end
                found:Destroy()
            end
        end)
    end
end

local previous = ENV[INSTANCE_KEY]

if previous and type(previous.Unload) == "function" then
    pcall(previous.Unload)
    task.wait(0.2) -- let the old window finish closing
end

ENV[INSTANCE_KEY] = nil
sweepOrphans()

--==================================================
-- LOGGING
--==================================================

local function log(message)
    print(("[Ruck Inspector][%s] %s"):format(
        os.date("%H:%M:%S"),
        tostring(message)
    ))
end

local function addLog(message)
    table.insert(State.Logs, {
        Time = os.date("%H:%M:%S"),
        Message = tostring(message),
    })

    while #State.Logs > CONFIG.MaxLogs do
        table.remove(State.Logs, 1)
    end

    log(message)
end

--==================================================
-- NOTIFICATIONS
--==================================================

local function notify(title, content, duration)
    if not WindUI then
        warn("[Ruck Inspector] WindUI unavailable.")
        return
    end

    local ok, err = pcall(function()
        WindUI:Notify({
            Title = title,
            Content = content,
            Duration = duration or 3,
        })
    end)

    if not ok then
        warn("[Ruck Inspector] Notification error: " .. tostring(err))
    end
end

local function safeNotify(title, content, duration)
    if CONFIG.Notifications then
        notify(title, content, duration)
    end
end

--==================================================
-- CONNECTION MANAGEMENT
--==================================================

local function trackConnection(connection)
    table.insert(Connections, connection)
    return connection
end

local function disconnectAll()
    for _, connection in ipairs(Connections) do
        pcall(function()
            connection:Disconnect()
        end)
    end

    table.clear(Connections)
end

--==================================================
-- WINDUI LOADER
--==================================================

local function loadWindUI()
    if type(loadstring) ~= "function" then
        error("Executor does not expose loadstring.")
    end

    local sourceUrl =
        "https://github.com/Footagesus/WindUI/releases/download/"
        .. WINDUI_VERSION .. "/main.lua"

    local response = game:HttpGet(sourceUrl)

    if type(response) ~= "string" or #response < 1000 then
        error("Invalid WindUI download response.")
    end

    local chunk, compileError = loadstring(response)

    if not chunk then
        error("WindUI compilation failed: " .. tostring(compileError))
    end

    local ok, result = pcall(chunk)

    if not ok then
        error("WindUI initialization failed: " .. tostring(result))
    end

    if type(result) ~= "table"
        or type(result.CreateWindow) ~= "function" then

        error("WindUI CreateWindow API unavailable.")
    end

    return result
end

local loadOK, loadResult = pcall(loadWindUI)

if not loadOK then
    warn("[Ruck Inspector] INITIALIZATION FAILED")
    warn(tostring(loadResult))
    return
end

WindUI = loadResult

log("WindUI " .. WINDUI_VERSION .. " loaded.")

--==================================================
-- SERVICES
--==================================================

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

local LocalPlayer = Players.LocalPlayer

--==================================================
-- VISUAL CONTAINER
--==================================================

local function createContainer()
    local folder = Instance.new("Folder")
    folder.Name = CONTAINER_NAME

    local parent = nil

    if type(gethui) == "function" then
        pcall(function()
            parent = gethui()
        end)
    end

    if not parent then
        pcall(function()
            parent = game:GetService("CoreGui")
        end)
    end

    local ok = parent ~= nil and pcall(function()
        folder.Parent = parent
    end)

    if not ok or not folder.Parent then
        folder.Parent = LocalPlayer:WaitForChild("PlayerGui")
    end

    return folder
end

Container = createContainer()

--==================================================
-- CATEGORY DEFINITIONS
--==================================================

local CATEGORIES = {
    {
        Key = "Mobs",
        Title = "Mobs",
        Path = { "Mobs" },
        Color = Color3.fromRGB(255, 85, 85),
        Default = true,
        MaxDistance = 500,
        Known = { "Cow", "Goblin" },
    },
    {
        Key = "Chests",
        Title = "Chests",
        Path = { "World", "Chests" },
        Color = Color3.fromRGB(255, 215, 0),
        Default = true,
        MaxDistance = 1000,
        Known = {
            "LootChestBlue", "LootChestFree", "LootChestOrange",
            "LootChestWhite", "StarterChest",
        },
    },
    {
        Key = "Shrines",
        Title = "Shrines",
        Path = { "World", "Shrines" },
        Color = Color3.fromRGB(190, 120, 255),
        Default = true,
        MaxDistance = 1500,
        Known = {
            "BossShrineChief", "BossShrineChunk", "BossShrineGronk",
            "BossShrineGuardian", "ShrineCombat", "TotemRespawn",
        },
    },
    {
        Key = "Camps",
        Title = "Camps",
        Path = { "World", "Camps" },
        Color = Color3.fromRGB(255, 160, 60),
        Default = false,
        MaxDistance = 1000,
        Known = {
            "Anvil", "Cart", "Cauldron", "Cave", "ChestPlayer", "ChestRock",
            "Fireplace", "FletchingTable", "House_Cook", "House_Fletch",
            "House_Miner", "House_Smith", "House_Wood",
        },
    },
    {
        Key = "Resources",
        Title = "Resources",
        Path = { "World", "Resources" },
        Color = Color3.fromRGB(90, 200, 120),
        Default = false,
        MaxDistance = 300,
        Known = {
            "Adamantite", "AshRock", "AshRockLarge", "Barrel", "BasaltSlab",
            "BasaltSpire", "Birch", "Coal", "DarkOak", "Fir", "Gold", "Iron",
            "Log", "LogPile", "MagmaCoal", "Mihtril", "Oak", "Obamium",
            "ObsidianRock", "Rock", "RockPile", "Ruby", "ScorchedTree",
            "SulfurRock", "Tent", "Tree",
        },
    },
    {
        Key = "Pickups",
        Title = "Pickups",
        Path = { "World", "Pickups" },
        Color = Color3.fromRGB(120, 200, 255),
        Default = false,
        MaxDistance = 300,
        Known = {
            "Apple", "CoalPickup", "Flint", "Flower", "MushroomOrange",
            "MushroomPink", "MushroomRed", "MushroomSus", "RockPickup",
            "Wheat",
        },
    },
}

-- Per-type color overrides.
local TYPE_COLORS = {
    Goblin = Color3.fromRGB(255, 85, 85),
    Cow = Color3.fromRGB(235, 235, 235),
    Gold = Color3.fromRGB(255, 215, 0),
    Ruby = Color3.fromRGB(230, 40, 80),
    Obamium = Color3.fromRGB(255, 0, 255),
    Adamantite = Color3.fromRGB(80, 220, 200),
    Mihtril = Color3.fromRGB(120, 160, 255),
    Iron = Color3.fromRGB(200, 200, 210),
    Coal = Color3.fromRGB(150, 150, 150),
}

-- Extra info shown in the label (chest open costs, as observed).
local TYPE_NOTES = {
    LootChestWhite = "25g",
    LootChestBlue = "80g",
    LootChestOrange = "200g",
    LootChestFree = "free?",
}

local CatState = {}

local function toSet(list)
    local set = {}

    if type(list) == "string" then
        set[list] = true
    elseif type(list) == "table" then
        for key, value in pairs(list) do
            if type(value) == "string" then
                set[value] = true
            elseif value == true and type(key) == "string" then
                set[key] = true
            end
        end
    end

    return set
end

for _, cat in ipairs(CATEGORIES) do
    cat.KnownSet = toSet(cat.Known)

    CatState[cat.Key] = {
        Enabled = cat.Default,
        MaxDistance = cat.MaxDistance,
        Selected = toSet(cat.Known),
    }
end

--==================================================
-- GENERAL HELPERS
--==================================================

local function resolvePath(path)
    local current = Workspace

    for _, name in ipairs(path) do
        current = current and current:FindFirstChild(name)
    end

    return current
end

local function typeOf(name)
    local base = tostring(name)

    base = base:gsub("%s*%(%d+%)$", "")
    base = base:match("^(.-)_%d+$") or base

    return base
end

local function colorFor(cat, typeName)
    if TYPE_COLORS[typeName] then
        return TYPE_COLORS[typeName]
    end

    if typeName:find("^BossShrine") then
        return Color3.fromRGB(255, 60, 160)
    end

    return cat.Color
end

local function isTypeVisible(cat, cs, typeName)
    if cat.KnownSet[typeName] then
        return cs.Selected[typeName] == true
    end

    -- Unknown / newly discovered types are always shown.
    return true
end

-- Returns only the top-most Models / BaseParts under root
-- (a part inside a model is not listed separately).
local function getTopLevel(root)
    local results = {}

    if not root then
        return results
    end

    for _, descendant in ipairs(root:GetDescendants()) do
        if descendant:IsA("Model") or descendant:IsA("BasePart") then
            local nested = false
            local parent = descendant.Parent

            while parent and parent ~= root do
                if parent:IsA("Model") or parent:IsA("BasePart") then
                    nested = true
                    break
                end

                parent = parent.Parent
            end

            if not nested then
                table.insert(results, descendant)
            end
        end
    end

    return results
end

local function getAdornPart(obj)
    if obj:IsA("BasePart") then
        return obj
    end

    if obj:IsA("Model") then
        if obj.PrimaryPart then
            return obj.PrimaryPart
        end

        for _, descendant in ipairs(obj:GetDescendants()) do
            if descendant:IsA("BasePart") then
                return descendant
            end
        end
    end

    return nil
end

local function getPosition(obj)
    local ok, pos = pcall(function()
        return obj:GetPivot().Position
    end)

    if ok then
        return pos
    end

    return nil
end

local function getOrigin()
    local character = LocalPlayer and LocalPlayer.Character
    local root = character and character:FindFirstChild("HumanoidRootPart")

    if root then
        return root.Position
    end

    local camera = Workspace.CurrentCamera

    if camera then
        return camera.CFrame.Position
    end

    return Vector3.new(0, 0, 0)
end

local function countParts(obj)
    local count = 0

    for _, descendant in ipairs(obj:GetDescendants()) do
        if descendant:IsA("BasePart") then
            count += 1
        end
    end

    return count
end

--==================================================
-- ESP ENTRIES
--==================================================

local function removeHighlight(entry)
    if entry.Highlight then
        pcall(function()
            entry.Highlight:Destroy()
        end)

        entry.Highlight = nil
    end
end

local function ensureHighlight(entry)
    if entry.Highlight and entry.Highlight.Parent then
        return
    end

    local highlight = Instance.new("Highlight")

    highlight.Name = "RuckESPHighlight"
    highlight.Adornee = entry.Obj
    highlight.FillColor = entry.Color
    highlight.OutlineColor = Color3.fromRGB(255, 255, 255)
    highlight.FillTransparency = 0.7
    highlight.OutlineTransparency = 0
    highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    highlight.Parent = Container

    entry.Highlight = highlight
end

local function removeEntry(obj)
    local entry = Entries[obj]

    if not entry then
        return
    end

    removeHighlight(entry)

    if entry.Gui then
        pcall(function()
            entry.Gui:Destroy()
        end)
    end

    Entries[obj] = nil
    State.TotalRemoved += 1
end

local function clearAllEntries()
    for obj in pairs(Entries) do
        removeEntry(obj)
    end

    table.clear(Entries)
end

local function removeCategoryEntries(cat)
    for obj, entry in pairs(Entries) do
        if entry.Cat == cat then
            removeEntry(obj)
        end
    end
end

local function createEntry(cat, obj, typeName)
    local part = getAdornPart(obj)

    if not part then
        return
    end

    local height = 3

    pcall(function()
        if obj:IsA("Model") then
            height = obj:GetExtentsSize().Y / 2
        else
            height = obj.Size.Y / 2
        end
    end)

    height = math.clamp(height + 1.5, 2, 30)

    local color = colorFor(cat, typeName)

    local gui = Instance.new("BillboardGui")

    gui.Name = "RuckESPLabel"
    gui.Adornee = part
    gui.Size = UDim2.fromOffset(220, 20)
    gui.StudsOffset = Vector3.new(0, height, 0)
    gui.AlwaysOnTop = true
    gui.LightInfluence = 0
    gui.Parent = Container

    local label = Instance.new("TextLabel")

    label.Size = UDim2.fromScale(1, 1)
    label.BackgroundTransparency = 1
    label.Text = typeName
    label.TextColor3 = color
    label.TextStrokeTransparency = 0.3
    label.TextSize = 14
    label.Font = Enum.Font.GothamBold
    label.Parent = gui

    local humanoid = nil

    if obj:IsA("Model") then
        humanoid = obj:FindFirstChildOfClass("Humanoid")
    end

    Entries[obj] = {
        Obj = obj,
        Cat = cat,
        Type = typeName,
        Part = part,
        Gui = gui,
        Label = label,
        Color = color,
        Humanoid = humanoid,
        Dist = 0,
        Text = "",
    }

    State.TotalCreated += 1
end

local function buildText(entry)
    local text = entry.Type
    local note = TYPE_NOTES[entry.Type]

    if note then
        text = text .. " (" .. note .. ")"
    end

    if Settings.ShowDistance then
        text = text .. " [" .. math.floor(entry.Dist) .. "m]"
    end

    if Settings.ShowHealth then
        local health, maxHealth

        if entry.Humanoid and entry.Humanoid.Parent then
            health = entry.Humanoid.Health
            maxHealth = entry.Humanoid.MaxHealth
        else
            local attrHealth = entry.Obj:GetAttribute("Health")
            local attrMax = entry.Obj:GetAttribute("MaxHealth")

            if type(attrHealth) == "number" then
                health = attrHealth
                maxHealth = type(attrMax) == "number" and attrMax or nil
            end
        end

        if health then
            if maxHealth then
                text = text .. " " .. math.floor(health) .. "/" .. math.floor(maxHealth)
            else
                text = text .. " " .. math.floor(health) .. "hp"
            end
        end
    end

    return text
end

--==================================================
-- SCANNING
--==================================================

local function requestScan()
    State.ScanDirty = true
end

local missingWarned = {}

local function scanAll()
    local origin = getOrigin()

    for _, cat in ipairs(CATEGORIES) do
        local cs = CatState[cat.Key]

        if not cs.Enabled then
            removeCategoryEntries(cat)
        else
            local root = resolvePath(cat.Path)

            if not root then
                removeCategoryEntries(cat)

                if not missingWarned[cat.Key] then
                    missingWarned[cat.Key] = true
                    addLog(cat.Title .. " folder not found: Workspace." .. table.concat(cat.Path, "."))
                end
            else
                missingWarned[cat.Key] = nil

                local seen = {}

                for _, obj in ipairs(getTopLevel(root)) do
                    local typeName = typeOf(obj.Name)

                    if isTypeVisible(cat, cs, typeName) then
                        local pos = getPosition(obj)

                        if pos and (pos - origin).Magnitude <= cs.MaxDistance then
                            seen[obj] = true

                            if not Entries[obj] then
                                createEntry(cat, obj, typeName)
                            end
                        end
                    end
                end

                for obj, entry in pairs(Entries) do
                    if entry.Cat == cat and not seen[obj] then
                        removeEntry(obj)
                    end
                end
            end
        end
    end

    State.LastScan = os.date("%H:%M:%S")
end

local function updateEntries()
    local origin = getOrigin()
    local list = {}

    for obj, entry in pairs(Entries) do
        local cs = CatState[entry.Cat.Key]

        if not cs.Enabled or not obj:IsDescendantOf(Workspace) then
            removeEntry(obj)
        else
            if not entry.Part or not entry.Part:IsDescendantOf(Workspace) then
                entry.Part = getAdornPart(obj)

                if entry.Part then
                    entry.Gui.Adornee = entry.Part
                end
            end

            local pos = getPosition(obj)

            if not entry.Part or not pos then
                removeEntry(obj)
            else
                entry.Dist = (pos - origin).Magnitude

                local text = buildText(entry)

                if text ~= entry.Text then
                    entry.Text = text
                    entry.Label.Text = text
                end

                table.insert(list, entry)
            end
        end
    end

    if Settings.Highlights then
        table.sort(list, function(a, b)
            return a.Dist < b.Dist
        end)

        for index, entry in ipairs(list) do
            if index <= Settings.MaxHighlights then
                ensureHighlight(entry)
            else
                removeHighlight(entry)
            end
        end
    else
        for _, entry in ipairs(list) do
            removeHighlight(entry)
        end
    end
end

--==================================================
-- INSPECTION TOOLS
--==================================================

local function inspectPath(path)
    local label = "Workspace." .. table.concat(path, ".")
    local folder = resolvePath(path)

    print("\n========== " .. label .. " ==========")

    if not folder then
        print("Not found.")
        addLog(label .. " not found.")
        return
    end

    local models, parts, folders = 0, 0, 0
    local descendants = folder:GetDescendants()

    for _, object in ipairs(descendants) do
        if object:IsA("Model") then
            models += 1
        elseif object:IsA("BasePart") then
            parts += 1
        elseif object:IsA("Folder") then
            folders += 1
        end
    end

    print("Direct children:", #folder:GetChildren())
    print("Total descendants:", #descendants)
    print("Models:", models, "BaseParts:", parts, "Folders:", folders)
    print("\nDirect children:")

    for _, child in ipairs(folder:GetChildren()) do
        print(child.Name, "[" .. child.ClassName .. "]", "Children:", #child:GetChildren())
    end

    print("==========================================\n")

    addLog(label .. " inspection completed.")
end

local function inspectWorkspaceOverview()
    print("\n========== WORKSPACE OVERVIEW ==========")

    for _, child in ipairs(Workspace:GetChildren()) do
        print(child.Name, "[" .. child.ClassName .. "]", "Children:", #child:GetChildren())
    end

    print("========================================\n")

    addLog("Workspace overview printed.")
end

local function inspectObject(obj)
    if not obj then
        return
    end

    print("\n========== OBJECT STRUCTURE ==========")

    print("Name:", obj.Name)
    print("Class:", obj.ClassName)
    print("FullName:", obj:GetFullName())

    local pos = getPosition(obj)
    print("Position:", pos and tostring(pos) or "Unknown")

    if obj:IsA("Model") then
        print("PrimaryPart:", obj.PrimaryPart and obj.PrimaryPart.Name or "None")
        print("Direct children:", #obj:GetChildren())
        print("Total descendants:", #obj:GetDescendants())
        print("BaseParts:", countParts(obj))

        local humanoid = obj:FindFirstChildOfClass("Humanoid")

        if humanoid then
            print("Humanoid:", humanoid.Health .. "/" .. humanoid.MaxHealth)
        else
            print("Humanoid: None")
        end
    end

    local attributes = {}

    pcall(function()
        attributes = obj:GetAttributes()
    end)

    print("\nAttributes:")

    local hasAttributes = false

    for key, value in pairs(attributes) do
        hasAttributes = true
        print("  " .. tostring(key) .. " =", value)
    end

    if not hasAttributes then
        print("  (none)")
    end

    local function printHierarchy(parent, depth)
        if depth > 8 then
            print(string.rep("  ", depth) .. "... depth limit")
            return
        end

        for _, child in ipairs(parent:GetChildren()) do
            print(string.rep("  ", depth) .. child.Name, "[" .. child.ClassName .. "]")
            printHierarchy(child, depth + 1)
        end
    end

    print("\nHierarchy:")
    printHierarchy(obj, 0)

    print("======================================\n")
end

local function inspectNearest()
    local origin = getOrigin()
    local nearest, nearestDist, nearestCat = nil, math.huge, nil

    for _, cat in ipairs(CATEGORIES) do
        local root = resolvePath(cat.Path)

        for _, obj in ipairs(getTopLevel(root)) do
            local pos = getPosition(obj)

            if pos then
                local dist = (pos - origin).Magnitude

                if dist < nearestDist then
                    nearest, nearestDist, nearestCat = obj, dist, cat
                end
            end
        end
    end

    if not nearest then
        addLog("No nearby objects found.")
        return
    end

    print(("Nearest object: %s (%s) at %d studs"):format(
        nearest.Name, nearestCat.Title, math.floor(nearestDist)
    ))

    inspectObject(nearest)
    addLog("Inspected nearest object: " .. nearest.Name)
end

local function typeCensus()
    print("\n========== TYPE CENSUS ==========")

    for _, cat in ipairs(CATEGORIES) do
        local root = resolvePath(cat.Path)

        print("\n[" .. cat.Title .. "] Workspace." .. table.concat(cat.Path, "."))

        if not root then
            print("  Folder not found.")
        else
            local counts = {}
            local total = 0

            for _, obj in ipairs(getTopLevel(root)) do
                local typeName = typeOf(obj.Name)
                counts[typeName] = (counts[typeName] or 0) + 1
                total += 1
            end

            local names = {}

            for name in pairs(counts) do
                table.insert(names, name)
            end

            table.sort(names)

            print("  Total objects:", total)

            for _, name in ipairs(names) do
                print(
                    "  " .. name,
                    counts[name],
                    cat.KnownSet[name] and "" or "<-- NEW (not in filter list)"
                )
            end
        end
    end

    print("\n=================================\n")

    addLog("Type census completed.")
end

local function printLogs()
    print("\n========== RUCK INSPECTOR LOGS ==========")

    if #State.Logs == 0 then
        print("No events recorded.")
    end

    for _, entry in ipairs(State.Logs) do
        print("[" .. entry.Time .. "] " .. entry.Message)
    end

    print("=========================================\n")
end

local function printReport()
    local counts = {}
    local total = 0

    for _, entry in pairs(Entries) do
        counts[entry.Cat.Key] = (counts[entry.Cat.Key] or 0) + 1
        total += 1
    end

    print("\n========== INSPECTOR REPORT ==========")
    print("Version:", VERSION)
    print("WindUI:", WINDUI_VERSION)
    print("Player:", LocalPlayer and LocalPlayer.Name or "Unavailable")
    print("PlaceId:", game.PlaceId)
    print("GameId:", game.GameId)
    print("Active ESP objects:", total)

    for _, cat in ipairs(CATEGORIES) do
        local cs = CatState[cat.Key]
        print(
            "  " .. cat.Title .. ":",
            counts[cat.Key] or 0,
            cs.Enabled and "(ON, " .. cs.MaxDistance .. "m)" or "(off)"
        )
    end

    print("Total created:", State.TotalCreated)
    print("Total removed:", State.TotalRemoved)
    print("Last scan:", State.LastScan)
    print("======================================\n")
end

--==================================================
-- WINDOW
--==================================================

Window = WindUI:CreateWindow({
    Title = "RUCK | Inspector AIO",
    Author = "Author: asuralangley - AIO v" .. VERSION,
    Icon = "swords",
    Theme = "Dark",
    Size = UDim2.fromOffset(680, 500),
    MinSize = Vector2.new(560, 400),
    Resizable = true,
    HideSearchBar = false,
    Folder = "RuckInspector",
})

--==================================================
-- CUSTOM TOGGLE KEYBIND
-- (WindUI's built-in ToggleKey is intentionally not used,
--  so only one handler ever toggles the window.)
--==================================================

local TOGGLE_KEYS = {
    [Enum.KeyCode.RightShift] = true,
    [Enum.KeyCode.RightControl] = true,
}

local windowOpen = true
local lastToggle = 0

local function toggleWindow()
    if os.clock() - lastToggle < 0.15 then
        return
    end

    lastToggle = os.clock()

    local ok = pcall(function()
        Window:Toggle()
    end)

    if not ok then
        if windowOpen then
            ok = pcall(function()
                Window:Close()
            end)
        else
            ok = pcall(function()
                Window:Open()
            end)
        end
    end

    if ok then
        windowOpen = not windowOpen
        log("Window toggled.")
    else
        warn("[Ruck Inspector] Could not toggle window (no Toggle/Open/Close method).")
    end
end

trackConnection(UserInputService.InputBegan:Connect(function(input)
    if input.UserInputType ~= Enum.UserInputType.Keyboard then
        return
    end

    if not TOGGLE_KEYS[input.KeyCode] then
        return
    end

    if UserInputService:GetFocusedTextBox() then
        return
    end

    toggleWindow()
end))

pcall(function()
    Window:Tag({
        Title = "v" .. VERSION,
        Color = "Success",
    })
end)

local Dashboard = Window:Tab({
    Title = "Dashboard",
    Icon = "layout-dashboard",
})

local MobsTab = Window:Tab({
    Title = "Mobs",
    Icon = "skull",
})

local WorldTab = Window:Tab({
    Title = "World",
    Icon = "globe",
})

local DiagnosticsTab = Window:Tab({
    Title = "Diagnostics",
    Icon = "scan-search",
})

local SettingsTab = Window:Tab({
    Title = "Settings",
    Icon = "settings",
})

--==================================================
-- UI HELPERS
--==================================================

local function addSection(tab, title)
    local ok = pcall(function()
        tab:Section({ Title = title })
    end)

    if not ok then
        pcall(function()
            tab:Paragraph({ Title = title, Desc = "" })
        end)
    end
end

local function tryElement(description, fn)
    local ok, err = pcall(fn)

    if not ok then
        addLog("UI element failed (" .. description .. "): " .. tostring(err))
    end
end

local function copyList(list)
    local copy = {}

    for _, value in ipairs(list) do
        table.insert(copy, value)
    end

    return copy
end

local function buildCategoryUI(tab, cat)
    local cs = CatState[cat.Key]

    addSection(tab, cat.Title)

    tryElement(cat.Title .. " toggle", function()
        tab:Toggle({
            Title = "Show " .. cat.Title .. " ESP",
            Value = cs.Enabled,
            Callback = function(value)
                cs.Enabled = value
                requestScan()
                addLog(cat.Title .. " ESP: " .. tostring(value))
            end,
        })
    end)

    tryElement(cat.Title .. " distance", function()
        tab:Slider({
            Title = cat.Title .. " Max Distance",
            Step = 10,
            Value = {
                Min = 50,
                Max = 3000,
                Default = cs.MaxDistance,
            },
            Callback = function(value)
                local number = tonumber(value)

                if number then
                    cs.MaxDistance = number
                    requestScan()
                end
            end,
        })
    end)

    tryElement(cat.Title .. " types", function()
        tab:Dropdown({
            Title = cat.Title .. " Types",
            Values = copyList(cat.Known),
            Value = copyList(cat.Known),
            Multi = true,
            AllowNone = true,
            Callback = function(selection)
                cs.Selected = toSet(selection)
                requestScan()
            end,
        })
    end)
end

--==================================================
-- DASHBOARD
--==================================================

Dashboard:Paragraph({
    Title = "RUCK Inspector AIO",
    Desc = "Version " .. VERSION .. " | WindUI " .. WINDUI_VERSION,
})

Dashboard:Paragraph({
    Title = "Quick Start",
    Desc = "Mobs, Chests and Shrines ESP are on by default. Enable Camps, Resources and Pickups in the World tab. Run Type Census in Diagnostics to find new mob species or items.",
})

Dashboard:Button({
    Title = "Rescan Now",
    Icon = "refresh-cw",
    Callback = function()
        requestScan()
        safeNotify("Scan", "Rescan requested.")
    end,
})

Dashboard:Button({
    Title = "Print Full Report",
    Icon = "file-text",
    Callback = function()
        printReport()
        safeNotify("Report", "Report printed to console.")
    end,
})

Dashboard:Button({
    Title = "Show Event Logs",
    Icon = "scroll-text",
    Callback = printLogs,
})

--==================================================
-- MOBS TAB
--==================================================

buildCategoryUI(MobsTab, CATEGORIES[1])

MobsTab:Button({
    Title = "Print Mob Species Census",
    Icon = "bar-chart",
    Callback = typeCensus,
})

--==================================================
-- WORLD TAB
--==================================================

for index = 2, #CATEGORIES do
    buildCategoryUI(WorldTab, CATEGORIES[index])
end

--==================================================
-- DIAGNOSTICS
--==================================================

DiagnosticsTab:Paragraph({
    Title = "Runtime Diagnostics",
    Desc = "Everything prints to the executor console (F9).",
})

DiagnosticsTab:Button({
    Title = "Workspace Overview",
    Icon = "layers",
    Callback = inspectWorkspaceOverview,
})

DiagnosticsTab:Button({
    Title = "Type Census (All Categories)",
    Icon = "bar-chart",
    Callback = typeCensus,
})

DiagnosticsTab:Button({
    Title = "Inspect Nearest Object",
    Icon = "crosshair",
    Callback = inspectNearest,
})

DiagnosticsTab:Button({
    Title = "Inspect Mobs Folder",
    Icon = "skull",
    Callback = function()
        inspectPath({ "Mobs" })
    end,
})

DiagnosticsTab:Button({
    Title = "Inspect MobVisuals Folder",
    Icon = "eye",
    Callback = function()
        inspectPath({ "MobVisuals" })
    end,
})

DiagnosticsTab:Button({
    Title = "Inspect World Folder",
    Icon = "globe",
    Callback = function()
        inspectPath({ "World" })
    end,
})

DiagnosticsTab:Button({
    Title = "Run Environment Diagnostics",
    Icon = "scan",
    Callback = function()
        print("\n========== ENVIRONMENT DIAGNOSTICS ==========")

        print("WindUI loaded:", WindUI ~= nil and "PASS" or "FAIL")
        print("LocalPlayer available:", LocalPlayer ~= nil and "PASS" or "FAIL")
        print("Visual container:", Container and Container.Parent and "PASS" or "FAIL")
        print("MobVisuals folder:", Workspace:FindFirstChild("MobVisuals") and "PASS" or "FAIL")

        for _, cat in ipairs(CATEGORIES) do
            print(
                cat.Title .. " folder:",
                resolvePath(cat.Path) and "PASS" or "FAIL"
            )
        end

        print("PlaceId:", game.PlaceId)
        print("GameId:", game.GameId)
        print("RunService:", RunService ~= nil and "PASS" or "FAIL")
        print("==============================================\n")

        addLog("Environment diagnostics completed.")
        safeNotify("Diagnostics", "Diagnostics printed to console.")
    end,
})

DiagnosticsTab:Button({
    Title = "Show Event Logs",
    Icon = "scroll-text",
    Callback = printLogs,
})

--==================================================
-- SETTINGS
--==================================================

SettingsTab:Paragraph({
    Title = "General Settings",
    Desc = "Configure ESP display and interface behavior.",
})

SettingsTab:Toggle({
    Title = "Show Distance",
    Value = Settings.ShowDistance,
    Callback = function(value)
        Settings.ShowDistance = value
    end,
})

SettingsTab:Toggle({
    Title = "Show Health (when available)",
    Value = Settings.ShowHealth,
    Callback = function(value)
        Settings.ShowHealth = value
    end,
})

SettingsTab:Toggle({
    Title = "Highlights (nearest 30)",
    Value = Settings.Highlights,
    Callback = function(value)
        Settings.Highlights = value
        addLog("Highlights: " .. tostring(value))
    end,
})

tryElement("scan interval", function()
    SettingsTab:Slider({
        Title = "Scan Interval (seconds)",
        Step = 0.5,
        Value = {
            Min = 0.5,
            Max = 5,
            Default = Settings.ScanInterval,
        },
        Callback = function(value)
            local number = tonumber(value)

            if number then
                Settings.ScanInterval = number
            end
        end,
    })
end)

SettingsTab:Toggle({
    Title = "Notifications",
    Value = CONFIG.Notifications,
    Callback = function(value)
        CONFIG.Notifications = value
        addLog("Notifications: " .. tostring(value))

        if value then
            notify("Settings", "Notifications enabled.")
        end
    end,
})

SettingsTab:Button({
    Title = "Disable All ESP",
    Icon = "eye-off",
    Callback = function()
        for _, cat in ipairs(CATEGORIES) do
            CatState[cat.Key].Enabled = false
        end

        clearAllEntries()
        addLog("All ESP disabled (toggle categories back on to re-enable).")
        safeNotify("ESP", "All ESP cleared.")
    end,
})

SettingsTab:Button({
    Title = "Clear Event Logs",
    Icon = "trash-2",
    Callback = function()
        table.clear(State.Logs)
        log("Event logs cleared.")
        safeNotify("Logs", "Event logs cleared.")
    end,
})

SettingsTab:Button({
    Title = "Print Configuration",
    Icon = "settings-2",
    Callback = function()
        print("\n========== CONFIGURATION ==========")

        for key, value in pairs(CONFIG) do
            print(key, value)
        end

        for key, value in pairs(Settings) do
            print("Settings." .. key, value)
        end

        for _, cat in ipairs(CATEGORIES) do
            local cs = CatState[cat.Key]
            print(cat.Key, "Enabled:", cs.Enabled, "MaxDistance:", cs.MaxDistance)
        end

        print("===================================\n")
    end,
})

--==================================================
-- BACKGROUND LOOPS
--==================================================

-- Scan loop: finds new objects, removes ones that left range or filter.
task.spawn(function()
    while State.Running do
        if State.ScanDirty
            or os.clock() - State.LastScanClock >= Settings.ScanInterval then

            State.ScanDirty = false
            State.LastScanClock = os.clock()

            local ok, err = pcall(scanAll)

            if not ok then
                addLog("Scan error: " .. tostring(err))
            end
        end

        task.wait(0.25)
    end
end)

-- Update loop: distances, health text, highlight ranking.
task.spawn(function()
    while State.Running do
        local ok, err = pcall(updateEntries)

        if not ok then
            addLog("Update error: " .. tostring(err))
        end

        task.wait(0.25)
    end
end)

--==================================================
-- CLEANUP / UNLOAD
--==================================================

local function unload()
    if not State.Running then
        return
    end

    State.Running = false

    if ENV[INSTANCE_KEY] and ENV[INSTANCE_KEY].Unload == unload then
        ENV[INSTANCE_KEY] = nil
    end

    clearAllEntries()
    disconnectAll()

    if Container then
        pcall(function()
            Container:Destroy()
        end)
    end

    addLog("Inspector unloading.")

    local destroyed = false

    for _, methodName in ipairs({ "Destroy", "Close" }) do
        local method = Window and Window[methodName]

        if type(method) == "function" then
            local ok = pcall(function()
                method(Window)
            end)

            if ok then
                destroyed = true
                break
            end
        end
    end

    if not destroyed then
        warn("[Ruck Inspector] Window cleanup method unavailable.")
    end

    print("[Ruck Inspector] Unload completed.")
end

-- Register this instance so the next execution can replace it.
ENV[INSTANCE_KEY] = { Unload = unload }

SettingsTab:Button({
    Title = "Unload UI",
    Icon = "power",
    Callback = unload,
})

--==================================================
-- READY
--==================================================

addLog("Ruck Inspector AIO v" .. VERSION .. " initialized.")

safeNotify(
    "Ruck Inspector",
    "AIO v" .. VERSION .. " loaded successfully.",
    5
)

print("[Ruck Inspector] AIO v" .. VERSION .. " loaded.")
print("[Ruck Inspector] Run 'Type Census' in Diagnostics to discover all species and items.")
Executor compatibility changes over time. Check current reports before testing.

Copy the code above into a compatible Roblox script executor if you choose to test it.

Ruck Script Status

✓AvailabilityFree
$Price$0
◫CompatibilityDesktop & Mobile
★SafetyVerified

Roblox and game updates can affect compatibility, so the script’s status should be treated as temporary rather than guaranteed.

Frequently Asked Questions

What is a Ruck script?

A Ruck script is third-party Lua code intended to run alongside the Roblox game through a compatible script executor.

What features does this Ruck script include?

Different scripts contain different code. This version includes: Inspector AIO.

How do you use the Ruck script?

Pick a compatible executor such as Hydrogen, MacSploit, AWP.GG, Delta, Fluxus, Codex, launch Roblox and join the game, copy the complete Lua code from the script card above, paste it into the executor’s editor, and click Run or Execute. Compatibility changes over time, so a name here doesn’t guarantee current support.

Can a Ruck script get your Roblox account banned?

Yes. Third-party scripts can violate Roblox rules and may put an account at risk. Only use code from a source you trust, never enter your Roblox password into a script or executor, and test on an alternate account first.

Does the Ruck script work on mobile?

Check whether both the executor and the script support your device and the current Roblox version. Mobile executor support does not guarantee that every script will work.

Check out our Roblox Scripts hub and Roblox Games Directory for more.

Leave a Comment