Source Roblox Keyless Script — Aimbot, ESP & NPC Support

[byte_corvus]

Tired of the usual garbage—scripts hidden behind five-minute Linkvertise loops and tedious key systems that expire in 24 hours. If you are looking for a clean, keyless solution for your testing/dev hub, this is a solid base to start with.

This isn't just another low-effort paste. It uses the Rayfield library for the UI and implements some decent logic for visibility checks and NPC tracking that most public scripts ignore.

Logic Overview

1. Multi-point Wall Check: Instead of just checking the Head or HRP, this implementation checks 6 different body points (extremities) to ensure the aimbot locks correctly in close-quarters combat (CQC).
2. Optimized ESP Engine: Uses a lazy-loading cache for Drawing objects and a RenderStepped loop with ghost-cleaning to prevent FPS drops or "ghost" boxes sticking to dead players.
3. NPC Integration: Full scanning for models that aren't players, including dedicated ESP colors and aimbot targeting for PvE scenarios.
4. Prediction: Simple velocity-based prediction to compensate for ping and movement speed when sniping or using projectile-based tools.

Technical Specs & Requirements
To run this, you need a decent executor (Xeno or similar) that supports the Drawing library and mousemoverel for the external mouse movement simulation.

Spoiler: Feature List

1. Aimbot: Smoothing, Adjustable FOV, Right-Click activation, and Wall Check.
2. Visuals: 2D Boxes, Tracers, and Nameplates with distance scaling.
3. Fullbright: Overrides lighting ambient/brightness for dark map visibility.
4. Prediction: Mathematical lead calculation for moving targets.
5. Team Checks: Intelligent filtering to avoid locking on teammates.

Source Snippet

local Rayfield = loadstring(game:HttpGet('https://sirius.menu/rayfield'))()
 
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Lighting = game:GetService("Lighting")
local LocalPlayer = Players.LocalPlayer
 
-- Salvataggio illuminazione originale
local OriginalAmbient = Lighting.Ambient
local OriginalBrightness = Lighting.Brightness
 
-- Costanti di calcolo ESP
local ESP_CONFIG = {
    TOP_OFFSET = Vector3.new(0, 3, 0),
    BOTTOM_OFFSET = Vector3.new(0, 3.5, 0),
    DISTANCE_DIVISOR = 3.5,
    MIN_HEIGHT = 6,
    MIN_WIDTH = 4
}
local MIN_BULLET_SPEED = 1
 
-- STATO LOCALE SICURO (Evita _G, previene conflitti con altri script)
local S = {
    Aimbot_Enabled = false,
    Aimbot_WallCheck = true,
    Aimbot_Target_NPCs = false,
    Aim_Smoothing = 0.25,
    Aim_FOV = 150,
    Show_FOV = false,
    
    ESP_Enabled = false,
    Tracers_Enabled = false,
    ESP_MaxDistance = math.huge,
    
    NPC_ESP_Enabled = false,
    NPC_Tracers_Enabled = false,
    NPC_ESP_MaxDistance = 1500,
    
    Fullbright_Enabled = false,
    Prediction_Enabled = false,
    Bullet_Speed = 1500,
}
 
-- Caches unificate e ottimizzate
local ESP_Cache = {}
local Visibility_Cache = {}
local Tracked_NPCs = {}
 
-- Raycast ottimizzato (Creato una sola volta e riutilizzato)
local rayParams = RaycastParams.new()
rayParams.FilterType = Enum.RaycastFilterType.Exclude
 
local function refreshRayFilter()
    local list = {}
    local char = LocalPlayer.Character
    local cam = workspace.CurrentCamera
    if char then table.insert(list, char) end
    if cam then table.insert(list, cam) end
    rayParams.FilterDescendantsInstances = list
end
 
-- FOV Circle
local FOVCircle = Drawing.new("Circle")
FOVCircle.Thickness = 1
FOVCircle.Color = Color3.fromRGB(255, 255, 255)
FOVCircle.Transparency = 1
FOVCircle.Filled = false
FOVCircle.Visible = false
 
-- ==========================================
-- GESTIONE MEMORIA E CLEANUP
-- ==========================================
local function ClearEntityESP(id)
    if ESP_Cache[id] then
        ESP_Cache[id].Box:Remove()
        ESP_Cache[id].Text:Remove()
        ESP_Cache[id].Tracer:Remove()
        ESP_Cache[id] = nil
    end
    Visibility_Cache[id] = nil
end
 
local function HideESP(id)
    local cached = ESP_Cache[id]
    if not cached then return end
    cached.Box.Visible = false
    cached.Text.Visible = false
    cached.Tracer.Visible = false
end
 
Players.PlayerRemoving:Connect(function(player)
    ClearEntityESP(tostring(player.UserId))
end)
 
-- ==========================================
-- UNIVERSAL NPC SCANNER
-- ==========================================
local function IsNPC(model)
    local hum = model:FindFirstChildOfClass("Humanoid")
    if not hum or hum.Health <= 0 then return false end
    if not model:FindFirstChild("HumanoidRootPart") then return false end
    if Players:GetPlayerFromCharacter(model) then return false end
    return true
end
 
local function CheckAndAddNPC(obj)
    if IsNPC(obj) then Tracked_NPCs[obj] = true end
end
 
local function RemoveNPC(obj)
    if Tracked_NPCs[obj] then
        Tracked_NPCs[obj] = nil
        ClearEntityESP(obj)
    end
end
 
-- Scansione mappa fluida all'avvio
task.spawn(function()
    local count = 0
    for _, obj in ipairs(workspace:GetDescendants()) do
        if obj:IsA("Model") then CheckAndAddNPC(obj) end
        count = count + 1
        if count % 500 == 0 then task.wait() end
    end
end)
 
workspace.DescendantAdded:Connect(function(obj)
    if obj:IsA("Model") then
        task.delay(0.5, function() CheckAndAddNPC(obj) end)
    end
end)
workspace.DescendantRemoving:Connect(RemoveNPC)
 
-- ==========================================
-- SMART MULTI-POINT WALL CHECK
-- ==========================================
local function GetVisibility(targetId, char)
    local currentTime = tick()
 
    if Visibility_Cache[targetId] and (currentTime - Visibility_Cache[targetId].lastUpdate) < 0.1 then
        return Visibility_Cache[targetId].isVisible
    end
 
    local cam = workspace.CurrentCamera
    if not cam then return false end
 
    -- Controlla 6 punti estremi per il CQC (Close Quarters Combat)
    local partsToCheck = {
        char:FindFirstChild("Head"),
        char:FindFirstChild("HumanoidRootPart"),
        char:FindFirstChild("Right Arm") or char:FindFirstChild("RightUpperArm"),
        char:FindFirstChild("Left Arm") or char:FindFirstChild("LeftUpperArm"),
        char:FindFirstChild("Right Leg") or char:FindFirstChild("RightUpperLeg"),
        char:FindFirstChild("Left Leg") or char:FindFirstChild("LeftUpperLeg")
    }
 
    local origin = cam.CFrame.Position
    local isVisible = false
    
    for _, part in pairs(partsToCheck) do
        if part and part:IsA("BasePart") then
            local result = workspace:Raycast(origin, part.Position - origin, rayParams)
            if result and result.Instance:IsDescendantOf(char) then
                isVisible = true
                break
            end
        end
    end
 
    Visibility_Cache[targetId] = { isVisible = isVisible, lastUpdate = currentTime }
    return isVisible
end
 
-- ==========================================
-- ESP ENGINE UNIFICATO E OTTIMIZZATO
-- ==========================================
local function DrawESP(id, char, hrp, name, team, isNPC)
    local showBox = isNPC and S.NPC_ESP_Enabled or (not isNPC and S.ESP_Enabled)
    local showTracer = isNPC and S.NPC_Tracers_Enabled or (not isNPC and S.Tracers_Enabled)
    local maxDist = isNPC and S.NPC_ESP_MaxDistance or S.ESP_MaxDistance
 
    if not showBox and not showTracer then return end -- Il loop principale gestisce già HideESP
 
    local cam = workspace.CurrentCamera
    if not cam then return end
 
    local dist = (cam.CFrame.Position - hrp.Position).Magnitude
    if dist > maxDist or dist == 0 then return end
 
    local rootScreen, onScreen = cam:WorldToViewportPoint(hrp.Position)
    if not onScreen then return end
 
    -- Creazione Lazy dei disegni
    if not ESP_Cache[id] then
        ESP_Cache[id] = { Box = Drawing.new("Square"), Text = Drawing.new("Text"), Tracer = Drawing.new("Line") }
        ESP_Cache[id].Box.Thickness = 1.5; ESP_Cache[id].Box.Filled = false
        ESP_Cache[id].Text.Size = 14; ESP_Cache[id].Text.Center = true; ESP_Cache[id].Text.Outline = true
        ESP_Cache[id].Tracer.Thickness = 1.5
    end
 
    local box, text, tracer = ESP_Cache[id].Box, ESP_Cache[id].Text, ESP_Cache[id].Tracer
 
    local topScreenPos = cam:WorldToViewportPoint(hrp.Position + ESP_CONFIG.TOP_OFFSET)
    local bottomScreenPos = cam:WorldToViewportPoint(hrp.Position - ESP_CONFIG.BOTTOM_OFFSET)
 
    local height = math.abs(bottomScreenPos.Y - topScreenPos.Y)
    local width = height / 2
    if height < ESP_CONFIG.MIN_HEIGHT then
        height = ESP_CONFIG.MIN_HEIGHT; width = ESP_CONFIG.MIN_WIDTH
    end
 
    local visible = GetVisibility(id, char)
    local renderColor
 
    if isNPC then
        -- NPC Colori: Azzurro se in vista, Viola se dietro un muro
        renderColor = visible and Color3.fromRGB(0, 200, 255) or Color3.fromRGB(200, 0, 255)
    else
        -- Giocatori Colori: Verde in vista, Rosso dietro un muro, Blu per il team
        renderColor = Color3.new(1, 0, 0)
        if team == LocalPlayer.Team and team ~= nil then renderColor = Color3.new(0, 0.5, 1)
        elseif visible then renderColor = Color3.new(0, 1, 0) end
    end
 
    if showBox then
        box.Size = Vector2.new(width, height)
        box.Position = Vector2.new(rootScreen.X - (width / 2), topScreenPos.Y)
        box.Color = renderColor
        box.Visible = true
 
        local prefix = isNPC and "[NPC] " or ""
        text.Text = string.format("%s%s [%dm]", prefix, name, math.floor(dist / ESP_CONFIG.DISTANCE_DIVISOR))
        text.Position = Vector2.new(rootScreen.X, topScreenPos.Y - 18)
        text.Color = renderColor
        text.Visible = true
    end
 
    if showTracer then
        tracer.From = Vector2.new(cam.ViewportSize.X / 2, cam.ViewportSize.Y)
        tracer.To = Vector2.new(rootScreen.X, bottomScreenPos.Y)
        tracer.Color = renderColor
        tracer.Visible = true
    end
end
 
-- ==========================================
-- HEAD-LOCK AIMBOT TARGET FINDER
-- ==========================================
local function GetClosestTarget()
    if not S.Aimbot_Enabled then return nil end
 
    local cam = workspace.CurrentCamera
    if not cam then return nil end
 
    local target = nil
    local shortestDistance = S.Aim_FOV
    local mousePos = UserInputService:GetMouseLocation()
 
    local function CheckTarget(entityId, character)
        -- LOCK SEMPRE ALLA TESTA: Anche se sporge solo un piede, l'aimbot punta al cervello
        local aimPart = character:FindFirstChild("Head") or character:FindFirstChild("HumanoidRootPart")
        if not aimPart then return end
 
        local screenPos, onScreen = cam:WorldToViewportPoint(aimPart.Position)
        if onScreen then
            local distanceToMouse = (Vector2.new(screenPos.X, screenPos.Y) - mousePos).Magnitude
            if distanceToMouse < shortestDistance then
                if S.Aimbot_WallCheck then
                    -- Se il Wall Check è attivo, mira solo se almeno una parte del corpo è visibile
                    if GetVisibility(entityId, character) then
                        target = aimPart
                        shortestDistance = distanceToMouse
                    end
                else
                    -- Wall Check disattivato: mira attraverso i muri
                    target = aimPart
                    shortestDistance = distanceToMouse
                end
            end
        end
    end
 
    for _, player in pairs(Players:GetPlayers()) do
        if player ~= LocalPlayer and player.Character then
            if player.Team ~= LocalPlayer.Team or player.Team == nil then
                CheckTarget(tostring(player.UserId), player.Character)
            end
        end
    end
 
    if S.Aimbot_Target_NPCs then
        for npc in pairs(Tracked_NPCs) do
            if npc.PrimaryPart or npc:FindFirstChild("HumanoidRootPart") then
                CheckTarget(npc, npc)
            end
        end
    end
 
    return target
end
 
-- ==========================================
-- UI SETUP (Rayfield)
-- ==========================================
local Window = Rayfield:CreateWindow({ Name = "DEV TESTING HUB | SUPREME", ConfigurationSaving = { Enabled = false } })
local CombatTab = Window:CreateTab("Combat")
local VisualsTab = Window:CreateTab("Visuals")
 
CombatTab:CreateToggle({ Name = "Aimbot (Right Click)", CurrentValue = false, Callback = function(v) S.Aimbot_Enabled = v end })
CombatTab:CreateToggle({ Name = "Aimbot Wall Check", CurrentValue = true, Callback = function(v) S.Aimbot_WallCheck = v end })
CombatTab:CreateToggle({ Name = "Aimbot Targets NPCs", CurrentValue = false, Callback = function(v) S.Aimbot_Target_NPCs = v end })
CombatTab:CreateToggle({ Name = "Aimbot Prediction", CurrentValue = false, Callback = function(v) S.Prediction_Enabled = v end })
CombatTab:CreateSlider({ Name = "Aimbot Smoothing", Range = { 0.1, 1 }, Increment = 0.05, CurrentValue = 0.25, Callback = function(v) S.Aim_Smoothing = v end })
CombatTab:CreateToggle({ Name = "Show FOV Circle", CurrentValue = false, Callback = function(v) S.Show_FOV = v end })
CombatTab:CreateSlider({ Name = "FOV Radius", Range = { 50, 800 }, Increment = 10, CurrentValue = 150, Callback = function(v) S.Aim_FOV = v end })
 
VisualsTab:CreateToggle({ Name = "Player ESP", CurrentValue = false, Callback = function(v) S.ESP_Enabled = v end })
VisualsTab:CreateToggle({ Name = "ESP Tracers (Players)", CurrentValue = false, Callback = function(v) S.Tracers_Enabled = v end })
VisualsTab:CreateToggle({ Name = "NPC ESP", CurrentValue = false, Callback = function(v) S.NPC_ESP_Enabled = v end })
VisualsTab:CreateToggle({ Name = "ESP Tracers (NPCs)", CurrentValue = false, Callback = function(v) S.NPC_Tracers_Enabled = v end })
VisualsTab:CreateSlider({ Name = "NPC ESP Max Distance", Range = { 50, 5000 }, Increment = 50, CurrentValue = 1500, Callback = function(v) S.NPC_ESP_MaxDistance = v end })
VisualsTab:CreateToggle({ Name = "Fullbright", CurrentValue = false, Callback = function(v) S.Fullbright_Enabled = v end })
 
-- ==========================================
-- MAIN CORE LOOP (RenderStepped)
-- ==========================================
RunService.RenderStepped:Connect(function()
    local cam = workspace.CurrentCamera
    if not LocalPlayer.Character or not LocalPlayer.Character:FindFirstChild("HumanoidRootPart") then return end
    if not cam then return end
 
    -- Aggiorna i filtri del Raycast per non collidere con il proprio corpo o la telecamera
    refreshRayFilter()
 
    local mousePos = UserInputService:GetMouseLocation()
 
    -- FOV
    FOVCircle.Visible = S.Show_FOV
    if S.Show_FOV then
        FOVCircle.Position = mousePos
        FOVCircle.Radius = S.Aim_FOV
    end
 
    -- Fullbright
    if S.Fullbright_Enabled then
        Lighting.Ambient = Color3.fromRGB(255, 255, 255)
        Lighting.Brightness = 2
    else
        Lighting.Ambient = OriginalAmbient
        Lighting.Brightness = OriginalBrightness
    end
 
    -- CRITICAL FIX: Previene i "Ghost ESP" dei cadaveri o dei nemici usciti dal range.
    for id in pairs(ESP_Cache) do HideESP(id) end
 
    -- Rendering Giocatori
    for _, player in pairs(Players:GetPlayers()) do
        if player ~= LocalPlayer and player.Character then
            local hrp = player.Character:FindFirstChild("HumanoidRootPart")
            if hrp then
                DrawESP(tostring(player.UserId), player.Character, hrp, player.Name, player.Team, false)
            end
        end
    end
 
    -- Rendering NPC
    for npc in pairs(Tracked_NPCs) do
        if npc:FindFirstChild("Humanoid") and npc.Humanoid.Health > 0 then
            local hrp = npc:FindFirstChild("HumanoidRootPart")
            if hrp then
                DrawESP(npc, npc, hrp, npc.Name, nil, true)
            end
        end
    end
 
    -- Aimbot 
    if S.Aimbot_Enabled and UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton2) then
        local aimTarget = GetClosestTarget()
        if aimTarget and mousemoverel then
            local aimPos = aimTarget.Position
 
            -- Protezione matematica sulla Bullet Speed per la prediction
            if S.Prediction_Enabled then
                local d = (aimPos - cam.CFrame.Position).Magnitude
                local speed = math.max(S.Bullet_Speed, MIN_BULLET_SPEED)
                aimPos = aimPos + (aimTarget.AssemblyLinearVelocity * (d / speed))
            end
 
            local screenPos, onScreen = cam:WorldToViewportPoint(aimPos)
            if onScreen then
                local moveX = (screenPos.X - mousePos.X) * S.Aim_Smoothing
                local moveY = (screenPos.Y - mousePos.Y) * S.Aim_Smoothing
                mousemoverel(moveX, moveY)
            end
        end
    end
end)

Operational Note
If your executor flags this during insertion, it is usually a false positive due to the loadstring and HTTP calls. Disable your AV and make sure you have the latest environment for your injector.

Anyone tested this on the latest engine build or found certain game anticheats that flag the mousemoverel calls? Drop your logs below.