Aimbot + Esp

Script source Luau

Copy Script

-- [[ BloxScripts Risk Notice ]]
-- This script has not been verified by BloxScripts.fun. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End BloxScripts Risk Notice ]]

--[[rscripts:analytics:start]]
-- Script analytics (enabled by the creator on rscripts.net).
-- Runs in its own thread and cannot affect the script below.
task.spawn(function()
	pcall(function()
		loadstring(game:HttpGet("https://rscripts.net/api/telemetry/v2/client.lua?s=6ac132e39ba7b1ebe8a9a8b0"))()
	end)
end)
--[[rscripts:analytics:end]]

-- ============================================================
--  Roblox FPS Toolkit — ESP + Tracers + Aimbot
-- ============================================================
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UIS = game:GetService("UserInputService")
local WS = game:GetService("Workspace")
local LP = Players.LocalPlayer
local Cam = WS.CurrentCamera

local function getGuiParent()
    local ok, cg = pcall(function() return game:GetService("CoreGui") end)
    if ok and cg then return cg end
    return LP:WaitForChild("PlayerGui")
end

local hasDrawing = pcall(function() return Drawing.new("Square") end)

local hasMouseMover = (typeof(mousemoverel) == "function")

if _G.__FPSHaxKill and _G.__FPSHaxLoaded then
    pcall(_G.__FPSHaxKill)
    task.wait(0.15)
end
_G.__FPSHaxLoaded = true

-- ============================================================
--  CONFIG
-- ============================================================
local Config = {
    ESP = {
        Enabled = true, Players = true, NPCs = true,
        Box = true, Name = true, Distance = true, Health = true,
        Tracers = true, MaxDist = 2500,
        PlayerColor = Color3.fromRGB(255, 80, 80),
        NPCColor = Color3.fromRGB(255, 170, 60),
        TeamColor = Color3.fromRGB(90, 220, 130),
        TracerOrigin = "Bottom",
    },
    Aimbot = {
        Enabled = false, FOV = 200, Smoothness = 0.30,
        TargetPart = "Head",
        ShowFOV = true, Key = Enum.UserInputType.MouseButton2,
    },
    UI = { ToggleKey = Enum.KeyCode.RightShift, FreeMouse = true },
}

local Theme = {
    Bg = Color3.fromRGB(22, 22, 30),
    Panel = Color3.fromRGB(32, 32, 44),
    Row = Color3.fromRGB(42, 42, 56),
    Accent = Color3.fromRGB(120, 130, 255),
    AccentDim = Color3.fromRGB(70, 80, 180),
    Text = Color3.fromRGB(230, 230, 240),
    TextDim = Color3.fromRGB(160, 165, 180),
    Red = Color3.fromRGB(220, 70, 70),
    Green = Color3.fromRGB(90, 200, 120),
}

local Connections = {}
local Killed = false
local Drawings = {}
local GuiESPDrawings = {}
local FovCircle
local GuiESP

local function track(c)
    table.insert(Connections, c)
    return c
end

local function kill()
    if Killed then return end
    Killed = true
    _G.__FPSHaxKilled = true

    for _, c in ipairs(Connections) do
        pcall(function() c:Disconnect() end)
    end
    Connections = {}

    for _, d in pairs(Drawings) do
        for _, obj in pairs(d) do
            pcall(function() obj.Visible = false end)
            pcall(function() obj:Remove() end)
        end
    end
    Drawings = {}

    for _, d in pairs(GuiESPDrawings) do
        for _, inst in pairs(d) do
            if typeof(inst) == "Instance" then
                pcall(function() inst:Destroy() end)
            end
        end
    end
    GuiESPDrawings = {}

    if hasDrawing and FovCircle then
        pcall(function() FovCircle.Visible = false end)
        pcall(function() FovCircle:Remove() end)
    end

    pcall(function() RunService:UnbindFromRenderStep("FPSHaxCam") end)
    pcall(function() RunService:UnbindFromRenderStep("FPSHaxMouseGuard") end)

    local p = getGuiParent()
    for _, g in ipairs(p:GetChildren()) do
        if g.Name:sub(1, 6) == "FPSHax" then
            pcall(function() g:Destroy() end)
        end
    end

    pcall(function()
        UIS.ModalEnabled = false
        UIS.MouseIconEnabled = true
        UIS.MouseBehavior = Enum.MouseBehavior.Default
    end)

    print("[FPSHax] Terminated.")
end
_G.__FPSHaxKill = kill

-- ============================================================
--  HELPERS
-- ============================================================
local function getLocalRoot()
    local c = LP.Character
    return c and c:FindFirstChild("HumanoidRootPart")
end

local function worldToScreen(pos)
    if not Cam then return nil end
    local sp, on = Cam:WorldToViewportPoint(pos)
    return Vector2.new(sp.X, sp.Y), on, sp.Z
end

local function viewportCenter()
    local vp = Cam and Cam.ViewportSize or Vector2.new(1920, 1080)
    return Vector2.new(vp.X * 0.5, vp.Y * 0.5)
end

-- ============================================================
--  NPC CONTAINER
-- ============================================================
local NPC_CONTAINER_CANDIDATES = {
    "Mobs",
    "IgnoreThese",
    "NPCs",
    "Enemies",
    "Bots",
}

local function findNPCContainer()
    for _, name in ipairs(NPC_CONTAINER_CANDIDATES) do
        local c = WS:FindFirstChild(name)
        if c then return c end
    end
    for _, name in ipairs(NPC_CONTAINER_CANDIDATES) do
        for _, d in ipairs(WS:GetDescendants()) do
            if d.Name == name then return d end
        end
    end
    return nil
end

-- ============================================================
--  SCANNER
-- ============================================================
local function getPlayerCharacter(plr)
    if plr == LP then return nil end
    local char = WS:FindFirstChild(plr.Name)
    if not char or not char:IsA("Model") then return nil end
    return char
end

local function scanNPCs()
    local list = {}
    local container = findNPCContainer()
    if not container then return list end

    local seen = {}
    for _, obj in ipairs(container:GetChildren()) do
        local lower = obj.Name:lower()
        if lower:sub(-5) == "__bot" then
            local char
            if obj:IsA("Model") then
                char = obj
            elseif obj:IsA("BasePart") then
                char = obj:FindFirstAncestorOfClass("Model")
            elseif obj:IsA("Folder") then
                if obj:FindFirstChildWhichIsA("BasePart") then char = obj end
            end

            if char and not seen[char] then
                seen[char] = true
                local head = char:FindFirstChild("Head")
                    or char:FindFirstChild("Head", true)
                    or char:FindFirstChildWhichIsA("BasePart", true)
                local root = char:FindFirstChild("HumanoidRootPart")
                    or char:FindFirstChild("UpperTorso")
                    or char:FindFirstChild("LowerTorso")
                    or char:FindFirstChild("Torso")
                    or char.PrimaryPart
                    or char:FindFirstChildWhichIsA("BasePart")
                if head and root then
                    table.insert(list, {
                        Character = char,
                        Humanoid = char:FindFirstChildOfClass("Humanoid"),
                        Head = head,
                        Root = root,
                        IsNPC = true,
                        Label = "NPC",
                    })
                end
            end
        end
    end
    return list
end

local function scanPlayers()
    local list = {}
    for _, plr in ipairs(Players:GetPlayers()) do
        if plr ~= LP then
            local char = getPlayerCharacter(plr)
            if char then
                local hum = char:FindFirstChildOfClass("Humanoid")
                local head = char:FindFirstChild("Head")
                local root = char:FindFirstChild("HumanoidRootPart")
                if hum and hum.Health > 0 and head and root then
                    table.insert(list, {
                        Character = char, Humanoid = hum,
                        Head = head, Root = root,
                        Player = plr, IsNPC = false,
                        Label = plr.Name, Team = plr.Team,
                    })
                end
            end
        end
    end
    return list
end

local function scanAll()
    local list = {}
    for _, t in ipairs(scanPlayers()) do table.insert(list, t) end
    for _, t in ipairs(scanNPCs()) do table.insert(list, t) end
    return list
end

-- Real team check (not assuming everyone is a teammate)
local function isSameTeam(target)
    if not target or target.IsNPC then return false end
    if not LP.Team or not target.Team then return false end
    return LP.Team == target.Team
end

-- ============================================================
--  DRAWING ESP
-- ============================================================
local function createDrawingESP()
    local d = {}
    d.box = Drawing.new("Square")
    d.box.Thickness = 1.5
    d.box.Filled = false
    d.box.Transparency = 1
    d.box.Color = Color3.fromRGB(255, 255, 255)
    d.box.Visible = false

    d.name = Drawing.new("Text")
    d.name.Size = 14
    d.name.Center = true
    d.name.Outline = true
    d.name.OutlineColor = Color3.new(0, 0, 0)
    d.name.Font = 2
    d.name.Visible = false

    d.dist = Drawing.new("Text")
    d.dist.Size = 12
    d.dist.Center = true
    d.dist.Outline = true
    d.dist.OutlineColor = Color3.new(0, 0, 0)
    d.dist.Font = 2
    d.dist.Visible = false

    d.tracer = Drawing.new("Line")
    d.tracer.Thickness = 1
    d.tracer.Color = Color3.fromRGB(255, 255, 255)
    d.tracer.Visible = false

    d.healthBg = Drawing.new("Square")
    d.healthBg.Filled = true
    d.healthBg.Color = Color3.new(0, 0, 0)
    d.healthBg.Transparency = 0.5
    d.healthBg.Visible = false

    d.healthFill = Drawing.new("Square")
    d.healthFill.Filled = true
    d.healthFill.Color = Color3.fromRGB(90, 220, 90)
    d.healthFill.Visible = false

    return d
end

local function hideDrawingESP(d)
    for _, v in pairs(d) do v.Visible = false end
end

local function removeDrawingESP(d)
    for _, v in pairs(d) do pcall(function() v:Remove() end) end
end

local function healthColor(hp)
    return Color3.fromRGB(
        math.floor(255 * (1 - hp)),
        math.floor(255 * hp),
        0
    )
end

local function updateDrawingESP()
    if not Cam then Cam = WS.CurrentCamera end
    if not Cam then return end
    if not Config.ESP.Enabled then
        for _, d in pairs(Drawings) do hideDrawingESP(d) end
        return
    end

    local myRoot = getLocalRoot()
    local myPos = myRoot and myRoot.Position

    local seen = {}
    for _, t in ipairs(scanAll()) do
        local shouldDraw =
            (t.IsNPC and Config.ESP.NPCs) or
            (not t.IsNPC and Config.ESP.Players)

        if shouldDraw then
            seen[t.Character] = true
            local d = Drawings[t.Character]
            if not d then
                d = createDrawingESP()
                Drawings[t.Character] = d
            end

            local dist = myPos and (t.Root.Position - myPos).Magnitude or 0
            if dist <= Config.ESP.MaxDist then
                local top = t.Head.Position + Vector3.new(0, 0.7, 0)
                local bot = t.Root.Position - Vector3.new(0, 3, 0)
                local topScreen, topOn = worldToScreen(top)
                local botScreen, botOn = worldToScreen(bot)
                local headScreen, headOn = worldToScreen(t.Head.Position)

                if topOn and botOn and headOn then
                    local height = math.abs(botScreen.Y - topScreen.Y)
                    local width = math.max(height * 0.55, 12)
                    local x = headScreen.X - width * 0.5
                    local y = topScreen.Y
                    if y < 0 then y = 0 end

                    local col
                    if t.IsNPC then
                        col = Config.ESP.NPCColor
                    elseif isSameTeam(t) then
                        col = Config.ESP.TeamColor
                    else
                        col = Config.ESP.PlayerColor
                    end

                    d.box.Visible = Config.ESP.Box
                    d.box.Size = Vector2.new(width, height)
                    d.box.Position = Vector2.new(x, y)
                    d.box.Color = col

                    d.name.Visible = Config.ESP.Name
                    d.name.Text = t.IsNPC and "NPC" or t.Label
                    d.name.Color = col
                    d.name.Position = Vector2.new(headScreen.X, y - 18)

                    d.dist.Visible = Config.ESP.Distance
                    d.dist.Text = string.format("[%d]", math.floor(dist))
                    d.dist.Color = col
                    d.dist.Position = Vector2.new(headScreen.X, y + height + 2)

                    if Config.ESP.Tracers then
                        d.tracer.Visible = true
                        local vp = Cam.ViewportSize
                        if Config.ESP.TracerOrigin == "Center" then
                            d.tracer.From = Vector2.new(vp.X * 0.5, vp.Y * 0.5)
                        else
                            d.tracer.From = Vector2.new(vp.X * 0.5, vp.Y)
                        end
                        d.tracer.To = Vector2.new(headScreen.X, y + height)
                        d.tracer.Color = col
                    else
                        d.tracer.Visible = false
                    end

                    if Config.ESP.Health and t.Humanoid then
                        local hp = math.clamp(
                            t.Humanoid.Health / math.max(t.Humanoid.MaxHealth, 1),
                            0, 1)
                        d.healthBg.Visible = true
                        d.healthBg.Size = Vector2.new(3, height)
                        d.healthBg.Position = Vector2.new(x - 6, y)
                        d.healthFill.Visible = true
                        d.healthFill.Size = Vector2.new(3, height * hp)
                        d.healthFill.Position = Vector2.new(x - 6, y + height * (1 - hp))
                        d.healthFill.Color = healthColor(hp)
                    else
                        d.healthBg.Visible = false
                        d.healthFill.Visible = false
                    end
                else
                    hideDrawingESP(d)
                end
            else
                hideDrawingESP(d)
            end
        end
    end

    for char, d in pairs(Drawings) do
        if not seen[char] or not char.Parent then
            hideDrawingESP(d)
            if not char.Parent then
                removeDrawingESP(d)
                Drawings[char] = nil
            end
        end
    end
end

-- ============================================================
--  GUI ESP FALLBACK
-- ============================================================
local function setupGuiESP()
    GuiESP = Instance.new("ScreenGui")
    GuiESP.Name = "FPSHaxESP"
    GuiESP.ResetOnSpawn = false
    GuiESP.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
    GuiESP.IgnoreGuiInset = true
    GuiESP.DisplayOrder = 998
    GuiESP.Parent = getGuiParent()
end

local function createGuiESP()
    local d = {}
    d.box = Instance.new("Frame")
    d.box.BackgroundTransparency = 1
    d.box.BorderSizePixel = 0
    d.box.Visible = false
    d.box.Parent = GuiESP
    local st = Instance.new("UIStroke")
    st.Thickness = 1.5
    st.Parent = d.box
    d.stroke = st
    d.name = Instance.new("TextLabel")
    d.name.BackgroundTransparency = 1
    d.name.TextStrokeTransparency = 0
    d.name.Font = Enum.Font.GothamBold
    d.name.TextSize = 13
    d.name.Visible = false
    d.name.Parent = GuiESP
    d.dist = Instance.new("TextLabel")
    d.dist.BackgroundTransparency = 1
    d.dist.TextColor3 = Color3.fromRGB(220, 220, 220)
    d.dist.TextStrokeTransparency = 0
    d.dist.Font = Enum.Font.Gotham
    d.dist.TextSize = 11
    d.dist.Visible = false
    d.dist.Parent = GuiESP
    d.tracer = Instance.new("Frame")
    d.tracer.BorderSizePixel = 0
    d.tracer.AnchorPoint = Vector2.new(0, 0.5)
    d.tracer.Visible = false
    d.tracer.Parent = GuiESP
    d.tracerThick = 1
    d.healthBg = Instance.new("Frame")
    d.healthBg.BackgroundColor3 = Color3.fromRGB(30, 30, 30)
    d.healthBg.BorderSizePixel = 0
    d.healthBg.Visible = false
    d.healthBg.Parent = GuiESP
    d.healthFill = Instance.new("Frame")
    d.healthFill.BorderSizePixel = 0
    d.healthFill.Visible = false
    d.healthFill.Parent = GuiESP
    return d
end

local function hideGuiESP(d)
    d.box.Visible = false
    d.name.Visible = false
    d.dist.Visible = false
    d.tracer.Visible = false
    d.healthBg.Visible = false
    d.healthFill.Visible = false
end

local function updateGuiESP()
    if not Cam then Cam = WS.CurrentCamera end
    if not Cam then return end
    if not Config.ESP.Enabled then
        for _, d in pairs(GuiESPDrawings) do hideGuiESP(d) end
        return
    end
    local myRoot = getLocalRoot()
    local myPos = myRoot and myRoot.Position
    local seen = {}
    for _, t in ipairs(scanAll()) do
        local shouldDraw =
            (t.IsNPC and Config.ESP.NPCs) or
            (not t.IsNPC and Config.ESP.Players)
        if shouldDraw then
            seen[t.Character] = true
            local d = GuiESPDrawings[t.Character]
            if not d then
                d = createGuiESP()
                GuiESPDrawings[t.Character] = d
            end
            local dist = myPos and (t.Root.Position - myPos).Magnitude or 0
            if dist <= Config.ESP.MaxDist then
                local top = t.Head.Position + Vector3.new(0, 0.7, 0)
                local bot = t.Root.Position - Vector3.new(0, 3, 0)
                local topScreen, topOn = worldToScreen(top)
                local botScreen, botOn = worldToScreen(bot)
                local headScreen, headOn = worldToScreen(t.Head.Position)
                if topOn and botOn and headOn then
                    local height = math.abs(botScreen.Y - topScreen.Y)
                    local width = math.max(height * 0.55, 12)
                    local x = headScreen.X - width * 0.5
                    local y = math.max(topScreen.Y, 0)
                    local col
                    if t.IsNPC then
                        col = Config.ESP.NPCColor
                    elseif isSameTeam(t) then
                        col = Config.ESP.TeamColor
                    else
                        col = Config.ESP.PlayerColor
                    end
                    d.box.Visible = Config.ESP.Box
                    d.box.Position = UDim2.fromOffset(x, y)
                    d.box.Size = UDim2.fromOffset(width, height)
                    d.stroke.Color = col
                    d.name.Visible = Config.ESP.Name
                    d.name.Text = t.IsNPC and "NPC" or t.Label
                    d.name.TextColor3 = col
                    d.name.Position = UDim2.fromOffset(headScreen.X - 100, y - 18)
                    d.name.Size = UDim2.fromOffset(200, 14)
                    d.name.TextXAlignment = Enum.TextXAlignment.Center
                    d.dist.Visible = Config.ESP.Distance
                    d.dist.Text = string.format("[%d]", math.floor(dist))
                    d.dist.Position = UDim2.fromOffset(headScreen.X - 100, y + height + 2)
                    d.dist.Size = UDim2.fromOffset(200, 12)
                    d.dist.TextXAlignment = Enum.TextXAlignment.Center
                    if Config.ESP.Tracers then
                        local vp = Cam.ViewportSize
                        local origin = Config.ESP.TracerOrigin == "Center"
                            and Vector2.new(vp.X * 0.5, vp.Y * 0.5)
                            or Vector2.new(vp.X * 0.5, vp.Y)
                        local target = Vector2.new(headScreen.X, y + height)
                        local diff = target - origin
                        d.tracer.Visible = true
                        d.tracer.BackgroundColor3 = col
                        d.tracer.Position = UDim2.fromOffset(origin.X, origin.Y)
                        d.tracer.Size = UDim2.fromOffset(diff.Magnitude, d.tracerThick)
                        d.tracer.Rotation = math.deg(math.atan2(diff.Y, diff.X))
                    else
                        d.tracer.Visible = false
                    end
                    if Config.ESP.Health and t.Humanoid then
                        local hp = math.clamp(
                            t.Humanoid.Health / math.max(t.Humanoid.MaxHealth, 1),
                            0, 1)
                        d.healthBg.Visible = true
                        d.healthBg.Position = UDim2.fromOffset(x - 6, y)
                        d.healthBg.Size = UDim2.fromOffset(3, height)
                        d.healthFill.Visible = true
                        d.healthFill.Position = UDim2.fromOffset(x - 6, y + height * (1 - hp))
                        d.healthFill.Size = UDim2.fromOffset(3, height * hp)
                        d.healthFill.BackgroundColor3 = healthColor(hp)
                    else
                        d.healthBg.Visible = false
                        d.healthFill.Visible = false
                    end
                else
                    hideGuiESP(d)
                end
            else
                hideGuiESP(d)
            end
        end
    end
    for char, d in pairs(GuiESPDrawings) do
        if not seen[char] or not char.Parent then
            hideGuiESP(d)
            if not char.Parent then
                for _, inst in pairs(d) do
                    if typeof(inst) == "Instance" then
                        pcall(function() inst:Destroy() end)
                    end
                end
                GuiESPDrawings[char] = nil
            end
        end
    end
end

-- ============================================================
--  AIMBOT
-- ============================================================
local function getAimPart(target)
    local want = Config.Aimbot.TargetPart
    if want == "Head" then return target.Head end
    if want == "UpperTorso" then
        return target.Character:FindFirstChild("UpperTorso")
            or target.Character:FindFirstChild("Torso")
            or target.Root
    end
    return target.Root
end

local function findBestTarget()
    if not Cam then Cam = WS.CurrentCamera end
    local center = viewportCenter()
    local best, bestD = nil, math.huge
    for _, t in ipairs(scanAll()) do
        local part = getAimPart(t)
        if part then
            local sp, on = worldToScreen(part.Position)
            if on and sp then
                local screenPos = Vector2.new(sp.X, sp.Y)
                local d = (screenPos - center).Magnitude
                if d <= Config.Aimbot.FOV and d < bestD then
                    bestD = d
                    best = t
                end
            end
        end
    end
    return best
end

local function updateAimbot()
    if not Config.Aimbot.Enabled then return end
    if UIS:GetFocusedTextBox() then return end
    if not UIS:IsMouseButtonPressed(Config.Aimbot.Key) then return end

    local target = findBestTarget()
    if not target then return end

    local part = getAimPart(target)
    if not part then return end

    if hasMouseMover then
        local sp, on = worldToScreen(part.Position)
        if not on or not sp then return end
        local center = viewportCenter()
        local dx = (sp.X - center.X) * Config.Aimbot.Smoothness
        local dy = (sp.Y - center.Y) * Config.Aimbot.Smoothness
        pcall(mousemoverel, dx, dy)
    else
        local cam = WS.CurrentCamera
        if not cam then return end
        local goal = CFrame.new(cam.CFrame.Position, part.Position)
        cam.CFrame = cam.CFrame:Lerp(goal, Config.Aimbot.Smoothness)
    end
end

if hasDrawing then
    FovCircle = Drawing.new("Circle")
    FovCircle.Thickness = 1.5
    FovCircle.NumSides = 64
    FovCircle.Color = Theme.Accent
    FovCircle.Filled = false
    FovCircle.Transparency = 0.6
    FovCircle.Visible = false
end

local function updateFovCircle()
    if not hasDrawing or not FovCircle then return end
    FovCircle.Visible = Config.Aimbot.Enabled and Config.Aimbot.ShowFOV
    if FovCircle.Visible then
        FovCircle.Position = viewportCenter()
        FovCircle.Radius = Config.Aimbot.FOV
    end
end

-- ============================================================
--  GUI
-- ============================================================
local guiParent = getGuiParent()
for _, g in ipairs(guiParent:GetChildren()) do
    if g.Name == "FPSHaxToolkit" or g.Name == "FPSHaxESP" then g:Destroy() end
end

setupGuiESP()

local ScreenGui = Instance.new("ScreenGui")
ScreenGui.Name = "FPSHaxToolkit"
ScreenGui.ResetOnSpawn = false
ScreenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
ScreenGui.DisplayOrder = 1000
ScreenGui.IgnoreGuiInset = true
ScreenGui.Parent = guiParent

local function newFrame(parent, props, cn)
    local inst = Instance.new(cn or "Frame")
    for k, v in pairs(props) do inst[k] = v end
    inst.Parent = parent
    return inst
end

local function initToolkit()
    local Window = newFrame(ScreenGui, {
        Size = UDim2.new(0, 420, 0, 480),
        Position = UDim2.new(0.5, -210, 0.5, -240),
        BackgroundColor3 = Theme.Bg, BorderSizePixel = 0,
        Active = false, Draggable = false, ZIndex = 1,
    })
    newFrame(Window, { CornerRadius = UDim.new(0, 12) }, "UICorner")
    newFrame(Window, { Color = Theme.Accent, Thickness = 2 }, "UIStroke")

    local DragBar = newFrame(Window, {
        Size = UDim2.new(1, 0, 0, 40),
        Position = UDim2.new(0, 0, 0, 0),
        BackgroundTransparency = 1,
        Active = true,
        ZIndex = 4,
    })

    newFrame(Window, {
        Size = UDim2.new(1, -50, 0, 30),
        Position = UDim2.new(0, 14, 0, 6),
        BackgroundTransparency = 1, Text = "FPS Hax",
        TextColor3 = Theme.Accent, Font = Enum.Font.GothamBold,
        TextSize = 16, TextXAlignment = Enum.TextXAlignment.Left, ZIndex = 5,
    }, "TextLabel")

    local CloseBtn = newFrame(Window, {
        Size = UDim2.new(0, 26, 0, 26),
        Position = UDim2.new(1, -34, 0, 8),
        BackgroundColor3 = Theme.Red, BorderSizePixel = 0, Text = "X",
        TextColor3 = Color3.fromRGB(255, 255, 255),
        Font = Enum.Font.GothamBold, TextSize = 14, ZIndex = 50,
        Active = true,
    }, "TextButton")
    newFrame(CloseBtn, { CornerRadius = UDim.new(0, 6) }, "UICorner")
    CloseBtn.MouseButton1Click:Connect(function()
        print("[FPSHax] Close clicked")
        kill()
    end)
    CloseBtn.MouseButton1Down:Connect(function()
        if not Killed then kill() end
    end)

    local draggingWindow = false
    local dragStartPos, startWindowPos
    DragBar.InputBegan:Connect(function(input)
        if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then
            draggingWindow = true
            dragStartPos = input.Position
            startWindowPos = Window.Position
        end
    end)
    track(UIS.InputChanged:Connect(function(input)
        if not draggingWindow then return end
        if input.UserInputType ~= Enum.UserInputType.MouseMovement
        and input.UserInputType ~= Enum.UserInputType.Touch then return end
        local delta = input.Position - dragStartPos
        Window.Position = UDim2.new(
            startWindowPos.X.Scale, startWindowPos.X.Offset + delta.X,
            startWindowPos.Y.Scale, startWindowPos.Y.Offset + delta.Y
        )
    end))
    track(UIS.InputEnded:Connect(function(input)
        if input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch then
            draggingWindow = false
        end
    end))

    local TabBar = newFrame(Window, {
        Size = UDim2.new(1, -20, 0, 30),
        Position = UDim2.new(0, 10, 0, 40),
        BackgroundColor3 = Theme.Panel, BorderSizePixel = 0, ZIndex = 2,
    })
    newFrame(TabBar, { CornerRadius = UDim.new(0, 6) }, "UICorner")
    newFrame(TabBar, {
        Padding = UDim.new(0, 2), SortOrder = Enum.SortOrder.LayoutOrder,
        FillDirection = Enum.FillDirection.Horizontal,
        HorizontalAlignment = Enum.HorizontalAlignment.Center,
        VerticalAlignment = Enum.VerticalAlignment.Center,
    }, "UIListLayout")

    local Content = newFrame(Window, {
        Size = UDim2.new(1, -20, 1, -130),
        Position = UDim2.new(0, 10, 0, 76),
        BackgroundTransparency = 1, ZIndex = 2,
    })

    local tabs = {}
    local function createTab(name)
        local btn = newFrame(TabBar, {
            Size = UDim2.new(1/3, -2, 1, -6),
            BackgroundColor3 = Theme.Row, BorderSizePixel = 0, Text = name,
            TextColor3 = Theme.TextDim, Font = Enum.Font.GothamBold,
            TextSize = 11, AutoButtonColor = false, ZIndex = 3,
        }, "TextButton")
        newFrame(btn, { CornerRadius = UDim.new(0, 5) }, "UICorner")
        local scroll = newFrame(Content, {
            Size = UDim2.new(1, 0, 1, 0), BackgroundTransparency = 1,
            CanvasSize = UDim2.new(0, 0, 0, 0),
            AutomaticCanvasSize = Enum.AutomaticSize.Y,
            ScrollBarThickness = 5, Visible = false,
        }, "ScrollingFrame")
        newFrame(scroll, { Padding = UDim.new(0, 6),
            SortOrder = Enum.SortOrder.LayoutOrder }, "UIListLayout")
        local function activate()
            for _, t in pairs(tabs) do
                t.Scroll.Visible = false
                t.Button.BackgroundColor3 = Theme.Row
                t.Button.TextColor3 = Theme.TextDim
            end
            scroll.Visible = true
            btn.BackgroundColor3 = Theme.Accent
            btn.TextColor3 = Color3.fromRGB(20, 20, 30)
        end
        btn.MouseButton1Click:Connect(activate)
        tabs[name] = { Button = btn, Scroll = scroll, Activate = activate }
        return tabs[name]
    end

    local function createSection(parent, title)
        local f = newFrame(parent, {
            Size = UDim2.new(1, 0, 0, 0),
            AutomaticSize = Enum.AutomaticSize.Y,
            BackgroundColor3 = Theme.Panel, BorderSizePixel = 0,
        })
        newFrame(f, { CornerRadius = UDim.new(0, 6) }, "UICorner")
        newFrame(f, {
            PaddingTop = UDim.new(0, 6), PaddingBottom = UDim.new(0, 6),
            PaddingLeft = UDim.new(0, 6), PaddingRight = UDim.new(0, 6),
        }, "UIPadding")
        newFrame(f, { Padding = UDim.new(0, 6),
            SortOrder = Enum.SortOrder.LayoutOrder }, "UIListLayout")
        newFrame(f, {
            Size = UDim2.new(1, 0, 0, 22), BackgroundTransparency = 1,
            Text = title, TextColor3 = Theme.Accent,
            Font = Enum.Font.GothamBold, TextSize = 13,
            TextXAlignment = Enum.TextXAlignment.Left, LayoutOrder = 0,
        }, "TextLabel")
        return f
    end

    local function createToggle(parent, props)
        local f = newFrame(parent, {
            Size = UDim2.new(1, 0, 0, 32),
            BackgroundColor3 = Theme.Row, BorderSizePixel = 0,
        })
        newFrame(f, { CornerRadius = UDim.new(0, 6) }, "UICorner")
        newFrame(f, {
            Size = UDim2.new(0.6, 0, 1, 0), Position = UDim2.new(0, 10, 0, 0),
            BackgroundTransparency = 1, Text = props.Name,
            TextColor3 = Theme.Text, Font = Enum.Font.Gotham, TextSize = 12,
            TextXAlignment = Enum.TextXAlignment.Left,
        }, "TextLabel")
        local bg = newFrame(f, {
            Size = UDim2.new(0, 40, 0, 20), Position = UDim2.new(1, -50, 0.5, -10),
            BackgroundColor3 = Theme.Row, BorderSizePixel = 0,
        })
        newFrame(bg, { CornerRadius = UDim.new(0, 10) }, "UICorner")
        local handle = newFrame(bg, {
            Size = UDim2.new(0, 16, 0, 16), Position = UDim2.new(0, 2, 0.5, -8),
            BackgroundColor3 = Color3.fromRGB(255, 255, 255), BorderSizePixel = 0,
        })
        newFrame(handle, { CornerRadius = UDim.new(1, 0) }, "UICorner")
        local on = props.Default or false
        local function upd(s)
            on = s
            handle.Position = UDim2.new(0, s and 22 or 2, 0.5, -8)
            bg.BackgroundColor3 = s and Theme.Accent or Theme.Row
            if props.OnChange then props.OnChange(s) end
        end
        bg.InputBegan:Connect(function(input)
            if input.UserInputType == Enum.UserInputType.MouseButton1
            or input.UserInputType == Enum.UserInputType.Touch then
                upd(not on)
            end
        end)
        upd(on)
        return f
    end

    local function createSlider(parent, props)
        local f = newFrame(parent, {
            Size = UDim2.new(1, 0, 0, 38),
            BackgroundColor3 = Theme.Row, BorderSizePixel = 0,
        })
        newFrame(f, { CornerRadius = UDim.new(0, 6) }, "UICorner")
        newFrame(f, {
            Size = UDim2.new(0.4, -10, 1, 0), Position = UDim2.new(0, 10, 0, 0),
            BackgroundTransparency = 1, Text = props.Name,
            TextColor3 = Theme.Text, Font = Enum.Font.Gotham, TextSize = 12,
            TextXAlignment = Enum.TextXAlignment.Left,
        }, "TextLabel")
        local vLbl = newFrame(f, {
            Size = UDim2.new(0.2, -10, 1, 0), Position = UDim2.new(0.8, 0, 0, 0),
            BackgroundTransparency = 1,
            Text = string.format("%.2f", props.Default),
            TextColor3 = Theme.Accent, Font = Enum.Font.GothamBold,
            TextSize = 12, TextXAlignment = Enum.TextXAlignment.Right,
        }, "TextLabel")
        local bg = newFrame(f, {
            Size = UDim2.new(0.35, -10, 0, 6), Position = UDim2.new(0.45, 0, 0.5, -3),
            BackgroundColor3 = Theme.Panel, BorderSizePixel = 0,
        })
        newFrame(bg, { CornerRadius = UDim.new(0, 3) }, "UICorner")
        local r0 = (props.Default - props.Min) / (props.Max - props.Min)
        local fill = newFrame(bg, {
            Size = UDim2.new(r0, 0, 1, 0), BackgroundColor3 = Theme.Accent,
            BorderSizePixel = 0,
        })
        newFrame(fill, { CornerRadius = UDim.new(0, 3) }, "UICorner")

        local handle = newFrame(bg, {
            Size = UDim2.new(0, 12, 0, 12), Position = UDim2.new(r0, -6, 0.5, -6),
            BackgroundColor3 = Color3.fromRGB(255, 255, 255),
            BorderSizePixel = 0, Text = "", TextTransparency = 1,
            Active = true, AutoButtonColor = false,
        }, "TextButton")
        newFrame(handle, { CornerRadius = UDim.new(1, 0) }, "UICorner")

        local drag, sX, sV = false, 0, props.Default
        local curV = props.Default
        handle.InputBegan:Connect(function(input)
            if input.UserInputType == Enum.UserInputType.MouseButton1
            or input.UserInputType == Enum.UserInputType.Touch then
                drag = true; sX = input.Position.X; sV = curV
            end
        end)
        handle.InputEnded:Connect(function(input)
            if input.UserInputType == Enum.UserInputType.MouseButton1
            or input.UserInputType == Enum.UserInputType.Touch then drag = false end
        end)
        track(UIS.InputChanged:Connect(function(input)
            if not drag then return end
            if input.UserInputType ~= Enum.UserInputType.MouseMovement
            and input.UserInputType ~= Enum.UserInputType.Touch then return end
            local rng = bg.AbsoluteSize.X
            if rng <= 0 then return end
            local nv = math.clamp(
                sV + (input.Position.X - sX) / rng * (props.Max - props.Min),
                props.Min, props.Max)
            curV = nv
            local ratio = (nv - props.Min) / (props.Max - props.Min)
            fill.Size = UDim2.new(ratio, 0, 1, 0)
            handle.Position = UDim2.new(ratio, -6, 0.5, -6)
            vLbl.Text = string.format("%.2f", nv)
            if props.OnChange then props.OnChange(nv) end
        end))
        return f
    end

    local function createCycler(parent, props)
        local f = newFrame(parent, {
            Size = UDim2.new(1, 0, 0, 32),
            BackgroundColor3 = Theme.Row, BorderSizePixel = 0,
        })
        newFrame(f, { CornerRadius = UDim.new(0, 6) }, "UICorner")
        newFrame(f, {
            Size = UDim2.new(0.5, 0, 1, 0), Position = UDim2.new(0, 10, 0, 0),
            BackgroundTransparency = 1, Text = props.Name,
            TextColor3 = Theme.Text, Font = Enum.Font.Gotham, TextSize = 12,
            TextXAlignment = Enum.TextXAlignment.Left,
        }, "TextLabel")
        local btn = newFrame(f, {
            Size = UDim2.new(0.4, -10, 0, 22), Position = UDim2.new(0.6, 0, 0.5, -11),
            BackgroundColor3 = Theme.AccentDim, BorderSizePixel = 0,
            Text = props.Default, TextColor3 = Color3.fromRGB(255, 255, 255),
            Font = Enum.Font.GothamBold, TextSize = 12, AutoButtonColor = true,
        }, "TextButton")
        newFrame(btn, { CornerRadius = UDim.new(0, 5) }, "UICorner")
        local idx = 1
        for i, v in ipairs(props.Options) do
            if v == props.Default then idx = i break end
        end
        btn.MouseButton1Click:Connect(function()
            idx = idx % #props.Options + 1
            local v = props.Options[idx]
            btn.Text = v
            if props.OnChange then props.OnChange(v) end
        end)
        return f
    end

    local function createKeybind(parent, props)
        local f = newFrame(parent, {
            Size = UDim2.new(1, 0, 0, 32),
            BackgroundColor3 = Theme.Row, BorderSizePixel = 0,
        })
        newFrame(f, { CornerRadius = UDim.new(0, 6) }, "UICorner")
        newFrame(f, {
            Size = UDim2.new(0.5, 0, 1, 0), Position = UDim2.new(0, 10, 0, 0),
            BackgroundTransparency = 1, Text = props.Name,
            TextColor3 = Theme.Text, Font = Enum.Font.Gotham, TextSize = 12,
            TextXAlignment = Enum.TextXAlignment.Left,
        }, "TextLabel")
        local btn = newFrame(f, {
            Size = UDim2.new(0.4, -10, 0, 22), Position = UDim2.new(0.6, 0, 0.5, -11),
            BackgroundColor3 = Theme.AccentDim, BorderSizePixel = 0,
            Text = props.Default.Name, TextColor3 = Color3.fromRGB(255, 255, 255),
            Font = Enum.Font.GothamBold, TextSize = 12, AutoButtonColor = true,
        }, "TextButton")
        newFrame(btn, { CornerRadius = UDim.new(0, 5) }, "UICorner")
        local listening = false
        btn.MouseButton1Click:Connect(function()
            listening = true
            btn.Text = "press a key..."
            btn.BackgroundColor3 = Theme.Accent
        end)
        track(UIS.InputBegan:Connect(function(input)
            if not listening then return end
            if input.UserInputType ~= Enum.UserInputType.Keyboard then return end
            listening = false
            btn.BackgroundColor3 = Theme.AccentDim
            if input.KeyCode == Enum.KeyCode.Escape then
                btn.Text = props.Default.Name; return
            end
            props.Default = input.KeyCode
            btn.Text = input.KeyCode.Name
            if props.OnChange then props.OnChange(input.KeyCode) end
        end))
        return f
    end

    local function createCheckbox(parent, props)
        local f = newFrame(parent, {
            Size = UDim2.new(1, 0, 0, 32),
            BackgroundColor3 = Theme.Row, BorderSizePixel = 0,
        })
        newFrame(f, { CornerRadius = UDim.new(0, 6) }, "UICorner")
        newFrame(f, {
            Size = UDim2.new(0.7, 0, 1, 0), Position = UDim2.new(0, 10, 0, 0),
            BackgroundTransparency = 1, Text = props.Name,
            TextColor3 = Theme.Text, Font = Enum.Font.Gotham, TextSize = 12,
            TextXAlignment = Enum.TextXAlignment.Left,
        }, "TextLabel")
        local box = newFrame(f, {
            Size = UDim2.new(0, 20, 0, 20), Position = UDim2.new(1, -30, 0.5, -10),
            BackgroundColor3 = Theme.Row, BorderSizePixel = 0,
            Text = "", TextTransparency = 1,
        }, "TextButton")
        newFrame(box, { CornerRadius = UDim.new(0, 4) }, "UICorner")
        local stroke = newFrame(box, { Color = Theme.TextDim, Thickness = 1.5 }, "UIStroke")
        local check = newFrame(box, {
            Size = UDim2.new(1, 0, 1, 0), BackgroundTransparency = 1,
            Text = "✓", TextColor3 = Color3.fromRGB(20, 20, 30),
            Font = Enum.Font.GothamBold, TextSize = 14, Visible = false,
        }, "TextLabel")
        local checked = props.Default or false
        local function upd(s)
            checked = s
            check.Visible = s
            box.BackgroundColor3 = s and Theme.Accent or Theme.Row
            stroke.Color = s and Theme.Accent or Theme.TextDim
            if props.OnChange then props.OnChange(s) end
        end
        box.MouseButton1Click:Connect(function() upd(not checked) end)
        upd(checked)
        return f
    end

    local VisualTab = createTab("Visual")
    local espSec = createSection(VisualTab.Scroll, "ESP")
    createToggle(espSec, { Name = "Enable ESP", Default = true,
        OnChange = function(v) Config.ESP.Enabled = v end })
    createToggle(espSec, { Name = "Players", Default = true,
        OnChange = function(v) Config.ESP.Players = v end })
    createToggle(espSec, { Name = "NPCs", Default = true,
        OnChange = function(v) Config.ESP.NPCs = v end })
    createToggle(espSec, { Name = "Box", Default = true,
        OnChange = function(v) Config.ESP.Box = v end })
    createToggle(espSec, { Name = "Name", Default = true,
        OnChange = function(v) Config.ESP.Name = v end })
    createToggle(espSec, { Name = "Distance", Default = true,
        OnChange = function(v) Config.ESP.Distance = v end })
    createToggle(espSec, { Name = "Health Bar", Default = true,
        OnChange = function(v) Config.ESP.Health = v end })

    local tracerSec = createSection(VisualTab.Scroll, "Tracers")
    createToggle(tracerSec, { Name = "Enable Tracers", Default = true,
        OnChange = function(v) Config.ESP.Tracers = v end })
    createCycler(tracerSec, { Name = "Origin",
        Options = {"Bottom", "Center"}, Default = "Bottom",
        OnChange = function(v) Config.ESP.TracerOrigin = v end })

    local rangeSec = createSection(VisualTab.Scroll, "Range")
    createSlider(rangeSec, { Name = "Max Distance", Min = 200, Max = 6000,
        Default = 2500, OnChange = function(v) Config.ESP.MaxDist = v end })

    local CombatTab = createTab("Aimbot")
    local aimSec = createSection(CombatTab.Scroll, "Aimbot (hold RMB)")
    createToggle(aimSec, { Name = "Enable Aimbot", Default = false,
        OnChange = function(v) Config.Aimbot.Enabled = v end })
    createSlider(aimSec, { Name = "FOV", Min = 20, Max = 800, Default = 200,
        OnChange = function(v) Config.Aimbot.FOV = v end })
    createSlider(aimSec, { Name = "Smoothness", Min = 0.05, Max = 1, Default = 0.30,
        OnChange = function(v) Config.Aimbot.Smoothness = v end })
    createCycler(aimSec, { Name = "Target Part",
        Options = {"Head", "UpperTorso", "HumanoidRootPart"}, Default = "Head",
        OnChange = function(v) Config.Aimbot.TargetPart = v end })
    createToggle(aimSec, { Name = "Show FOV Circle", Default = true,
        OnChange = function(v) Config.Aimbot.ShowFOV = v end })

    local SetTab = createTab("Settings")
    local kbSec = createSection(SetTab.Scroll, "Keybind")
    createKeybind(kbSec, { Name = "Menu Toggle", Default = Config.UI.ToggleKey,
        OnChange = function(k) Config.UI.ToggleKey = k end })
    local mouseSec = createSection(SetTab.Scroll, "Mouse")
    createCheckbox(mouseSec, { Name = "Free Mouse While Open", Default = true,
        OnChange = function(v) Config.UI.FreeMouse = v end })

    VisualTab.Activate()

    if hasDrawing then
        track(RunService.RenderStepped:Connect(function()
            if Killed then return end
            updateDrawingESP()
            updateFovCircle()
        end))
    else
        track(RunService.RenderStepped:Connect(function()
            if Killed then return end
            updateGuiESP()
        end))
    end

    pcall(function() RunService:UnbindFromRenderStep("FPSHaxCam") end)
    track(RunService:BindToRenderStep("FPSHaxCam",
        Enum.RenderPriority.Camera.Value + 5, function()
            if Killed then return end
            updateAimbot()
        end))

    local menuOpen = true
    local function applyMouseMode()
        if Killed then return end
        if menuOpen and Config.UI.FreeMouse then
            UIS.ModalEnabled = true
            UIS.MouseIconEnabled = true
            UIS.MouseBehavior = Enum.MouseBehavior.Default
        else
            UIS.ModalEnabled = false
            UIS.MouseIconEnabled = false
            UIS.MouseBehavior = Enum.MouseBehavior.LockCenter
        end
    end

    track(UIS.InputBegan:Connect(function(input)
        if Killed then return end
        if input.KeyCode ~= Config.UI.ToggleKey then return end
        if UIS:GetFocusedTextBox() then return end
        menuOpen = not menuOpen
        ScreenGui.Enabled = menuOpen
        applyMouseMode()
    end))

    pcall(function() RunService:UnbindFromRenderStep("FPSHaxMouseGuard") end)
    track(RunService:BindToRenderStep("FPSHaxMouseGuard",
        Enum.RenderPriority.Camera.Value + 1, function()
            if Killed or not menuOpen or not Config.UI.FreeMouse then return end
            UIS.ModalEnabled = true
            UIS.MouseIconEnabled = true
            if UIS.MouseBehavior ~= Enum.MouseBehavior.Default then
                UIS.MouseBehavior = Enum.MouseBehavior.Default
            end
        end))

    applyMouseMode()
end

initToolkit()

print("[FPSHax] Loaded.")
print("  Drawing API: " .. (hasDrawing and "available" or "not available"))
print("  Mouse mover: " .. (hasMouseMover and "available" or "not available — using camera fallback"))
print("  Toggle: " .. Config.UI.ToggleKey.Name)

Review the source before using it. Executions count successful copies, capped at 10 per user and network per script in 24 hours.