100 Waves Later Scripts — No Key, Kill Aura & Silent Aim

For cards with gameplay results, tests were performed on November 3, 2026 on PC with Potassium and on Android with Delta. Each result describes what happened during those checks.

Cyerc — Silent Aim & Magic Bullet

Developer: Cyerc
Created: Created 2026-11-03

A compact option when you want aiming assistance without a settings window. A red line and small circle mark the selected target.

Selects a living zombie on screen nearest to the cursor

No menu, FOV setting, visibility check, or built-in off switch. This version does not include Godmode, Auto Revive, or automatic shooting.

Details

Cyerc — Silent Aim & Magic Bullet functions

Selects a living zombie on screen nearest to the cursor

Access: NO KEY

Tags: PC MOBILE

Languages: English

Compatibility: Potassium Delta Arceus X Codex Other

Script code

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

local CastRays = require(ReplicatedStorage.Shared.GunSystem.Utility.castRays)

local Camera = workspace.CurrentCamera

local Line = Drawing.new("Line")
Line.Color = Color3.fromRGB(255, 0, 0)

local Circle = Drawing.new("Circle")
Circle.Color = Color3.fromRGB(255, 0, 0)
Circle.Radius = 5

local GetClosestZombie = function()
    local ClosestDistance = math.huge
    local MouseLocation = UserInputService:GetMouseLocation()

    local Part = nil
    local Humanoid = nil
    local Position = nil

    for Index, Value in pairs(workspace.ServerZombies:GetChildren()) do
        local HeadPart = Value:FindFirstChild("Head")
        local HumanoidClass = Value:FindFirstChildOfClass("Humanoid")
        if not (HeadPart and HumanoidClass and HumanoidClass.Health > 1) then
             continue
        end

        local ViewportPoint, OnScreen = Camera:WorldToViewportPoint(HeadPart.Position)
        if not OnScreen then
            continue
        end

        local ScreenPosition = Vector2.new(ViewportPoint.X, ViewportPoint.Y)
        local Distance = (ScreenPosition - MouseLocation).Magnitude
        if Distance < ClosestDistance then
            Part = HeadPart
            Humanoid = HumanoidClass
            Position = ScreenPosition
            
            ClosestDistance = Distance
        end
    end

    return Part, Humanoid, Position
end

RunService.RenderStepped:Connect(function()
    local Part, Humanoid, Position = GetClosestZombie()
    Line.Visible = Part and true or false
    Circle.Visible = Part and true or false

    if Part and Humanoid then
        local MouseLocation = UserInputService:GetMouseLocation()
        Line.From = MouseLocation
        Line.To = Position
        Circle.Position = Position
    end
end)

local Old; Old = hookfunction(CastRays, function(...)
    local Part, Humanoid = GetClosestZombie()
    if Part and Humanoid then
        return {{
            normal = Vector3.zero,
            instance = Part,
            taggedHumanoid = Humanoid,
            position = Part.Position
        }}
    end

    return Old(...)
end)

Zombie Combat — Silent Aim, ESP & Movement

Developer: nyaa
Created: Created 2026-11-03

Choose this menu when you want control over target selection and how much information appears during a wave. Silent Aim and ESP start disabled, so enable the tools you need after loading.

Aim: FOV Radius, Maximum Distance, Visibility Check, Head Priority, Movement Prediction, Prediction Time, Closest World Priority, Lowest Health Priority
Visuals: 2D Boxes, Health Bar, Names & Health, Distance, Tracers, Zombie Counter
Player: Movement Override, Walk Speed, Jump Power, Infinite Jump, Noclip, Fly, Fly Speed
+1 more

Enable Movement Override to apply the Walk Speed and Jump Power sliders. Fly uses W/A/S/D, Space and Left Ctrl in this version; touch flight controls are not included.

Details

Zombie Combat — Silent Aim, ESP & Movement functions

Aim: FOV Radius, Maximum Distance, Visibility Check, Head Priority, Movement Prediction, Prediction Time, Closest World Priority, Lowest Health Priority
Visuals: 2D Boxes, Health Bar, Names & Health, Distance, Tracers, Zombie Counter
Player: Movement Override, Walk Speed, Jump Power, Infinite Jump, Noclip, Fly, Fly Speed
Utility: Anti Knockback, Fall Protection, Auto Interact, Interact Radius

Access: NO KEY

Tags: PC MOBILE

Languages: English

Compatibility: Potassium Delta Arceus X Codex Other

Script code

local ENV = getgenv()

if ENV.ZombieCombat then
    pcall(function()
        ENV.ZombieCombat:Unload()
    end)

    ENV.ZombieCombat = nil
    task.wait()
end

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

local LocalPlayer = Players.LocalPlayer

local Library = loadstring(game:HttpGet(
    "https://raw.githubusercontent.com/ImInsane-1337/neverlose-ui/refs/heads/main/source/library.lua"
))()

local Script = {
    Unloaded = false,

    Settings = {
        SilentAim = false,
        FOV = 250,
        ShowFOV = true,
        TargetLine = true,
        VisibilityCheck = false,
        MaximumAimDistance = 2500,
        HeadshotOnly = true,
        Prediction = false,
        PredictionTime = 0.08,
        ClosestWorldPriority = false,
        LowestHealthPriority = false,

        ESP = false,
        ESPBoxes = true,
        ESPHealthBar = true,
        ESPNames = true,
        ESPDistance = true,
        ESPTracers = false,
        ESPMaximumDistance = 2500,
        ESPColor = Color3.fromRGB(255, 255, 255),
        ESPAlpha = 1,

        Movement = false,
        WalkSpeed = 24,
        JumpPower = 50,
        InfiniteJump = false,
        Noclip = false,
        Fly = false,
        FlySpeed = 60,
        AntiKnockback = false,
        FallProtection = true,
        AutoInteract = false,
        AutoInteractRadius = 12,
    },

    Target = {
        Zombie = nil,
        Part = nil,
        Humanoid = nil,
        ScreenPosition = nil,
        ScreenDistance = math.huge,
        WorldDistance = math.huge,
    },

    Connections = {},
    Drawings = {},
    ZombieESP = {},
    CollisionState = {},
    LastSafeCFrame = nil,
    LastInteractScan = 0,
}

ENV.ZombieCombat = Script
ENV.ZombieCombatLibrary = Library

local GunUtility = ReplicatedStorage
    :WaitForChild("Shared")
    :WaitForChild("GunSystem")
    :WaitForChild("Utility")

local CastRaysModule = GunUtility:WaitForChild("castRays")
local CastRays = require(CastRaysModule)

assert(
    type(CastRays) == "function",
    "ReplicatedStorage.Shared.GunSystem.Utility.castRays did not return a function"
)

assert(
    type(hookfunction) == "function",
    "This script requires hookfunction support"
)

local function newDrawing(className, properties)
    local object = Drawing.new(className)

    for property, value in pairs(properties) do
        object[property] = value
    end

    return object
end

local FOVCircle = newDrawing("Circle", {
    Visible = false,
    Filled = false,
    Thickness = 1,
    NumSides = 64,
    Radius = Script.Settings.FOV,
    Color = Script.Settings.ESPColor,
    Transparency = 1,
})

local TargetLine = newDrawing("Line", {
    Visible = false,
    Thickness = 1,
    Color = Script.Settings.ESPColor,
    Transparency = 1,
})

local TargetPoint = newDrawing("Circle", {
    Visible = false,
    Filled = false,
    Thickness = 1,
    NumSides = 24,
    Radius = 5,
    Color = Script.Settings.ESPColor,
    Transparency = 1,
})

Script.Drawings.FOVCircle = FOVCircle
Script.Drawings.TargetLine = TargetLine
Script.Drawings.TargetPoint = TargetPoint

local ZombieCounter = newDrawing("Text", {
    Visible = false,
    Center = false,
    Outline = true,
    Size = 16,
    Position = Vector2.new(15, 80),
    Color = Script.Settings.ESPColor,
    Transparency = 1,
    Text = "Zombies: 0",
})

Script.Drawings.ZombieCounter = ZombieCounter

local function getCamera()
    return Workspace.CurrentCamera
end

local function getZombieFolder()
    return Workspace:FindFirstChild("ServerZombies")
end

local function getZombieHumanoid(zombie)
    if not zombie then
        return nil
    end

    return zombie:FindFirstChildOfClass("Humanoid")
end

local function getZombieRoot(zombie)
    if not zombie then
        return nil
    end

    return zombie:FindFirstChild("HumanoidRootPart")
        or zombie:FindFirstChild("Torso")
        or zombie:FindFirstChild("Upper")
        or zombie.PrimaryPart
end

local function getZombieAimPart(zombie)
    if not zombie then
        return nil
    end

    if Script.Settings.HeadshotOnly then
        return zombie:FindFirstChild("Head")
            or zombie:FindFirstChild("Upper")
            or zombie:FindFirstChild("Torso")
            or zombie:FindFirstChild("HumanoidRootPart")
    end

    return zombie:FindFirstChild("Upper")
        or zombie:FindFirstChild("Torso")
        or zombie:FindFirstChild("HumanoidRootPart")
        or zombie:FindFirstChild("Head")
end

local function isZombieAlive(zombie, humanoid)
    return zombie ~= nil
        and zombie.Parent ~= nil
        and humanoid ~= nil
        and humanoid.Parent ~= nil
        and humanoid.Health > 0
end

local function getMousePosition()
    return UserInputService:GetMouseLocation()
end

local function isTargetVisible(targetPart)
    if not Script.Settings.VisibilityCheck then
        return true
    end

    local camera = getCamera()

    if not camera or not targetPart or not targetPart.Parent then
        return false
    end

    local ignore = {}

    if LocalPlayer.Character then
        table.insert(ignore, LocalPlayer.Character)
    end

    local raycastParams = RaycastParams.new()
    raycastParams.FilterType = Enum.RaycastFilterType.Exclude
    raycastParams.FilterDescendantsInstances = ignore
    raycastParams.IgnoreWater = true

    local origin = camera.CFrame.Position
    local direction = targetPart.Position - origin

    local result = Workspace:Raycast(
        origin,
        direction,
        raycastParams
    )

    if not result then
        return true
    end

    return result.Instance == targetPart
        or result.Instance:IsDescendantOf(targetPart.Parent)
end

local function clearTarget()
    Script.Target.Zombie = nil
    Script.Target.Part = nil
    Script.Target.Humanoid = nil
    Script.Target.ScreenPosition = nil
    Script.Target.ScreenDistance = math.huge
    Script.Target.WorldDistance = math.huge
end

local function targetStillValid()
    local target = Script.Target
    local camera = getCamera()

    if not camera then
        return false
    end

    if not target.Zombie
        or not target.Part
        or not target.Humanoid
        or not isZombieAlive(target.Zombie, target.Humanoid)
    then
        return false
    end

    if not target.Part:IsDescendantOf(target.Zombie) then
        return false
    end

    local viewportPoint, onScreen =
        camera:WorldToViewportPoint(target.Part.Position)

    if not onScreen or viewportPoint.Z <= 0 then
        return false
    end

    local mousePosition = getMousePosition()
    local screenPosition = Vector2.new(
        viewportPoint.X,
        viewportPoint.Y
    )

    local screenDistance =
        (screenPosition - mousePosition).Magnitude

    local worldDistance =
        (camera.CFrame.Position - target.Part.Position).Magnitude

    if screenDistance > Script.Settings.FOV then
        return false
    end

    if worldDistance > Script.Settings.MaximumAimDistance then
        return false
    end

    if not isTargetVisible(target.Part) then
        return false
    end

    target.ScreenPosition = screenPosition
    target.ScreenDistance = screenDistance
    target.WorldDistance = worldDistance

    return true
end

local function findClosestZombie()
    local camera = getCamera()
    local zombieFolder = getZombieFolder()

    if not camera or not zombieFolder then
        clearTarget()
        return
    end

    local mousePosition = getMousePosition()
    local cameraPosition = camera.CFrame.Position

    local bestZombie
    local bestPart
    local bestHumanoid
    local bestScreenPosition
    local bestScreenDistance = Script.Settings.FOV
    local bestWorldDistance = math.huge

    for _, zombie in ipairs(zombieFolder:GetChildren()) do
        if not zombie:IsA("Model") then
            continue
        end

        local humanoid = getZombieHumanoid(zombie)
        local aimPart = getZombieAimPart(zombie)

        if not aimPart or not isZombieAlive(zombie, humanoid) then
            continue
        end

        local viewportPoint, onScreen =
            camera:WorldToViewportPoint(aimPart.Position)

        if not onScreen or viewportPoint.Z <= 0 then
            continue
        end

        local worldDistance =
            (cameraPosition - aimPart.Position).Magnitude

        if worldDistance > Script.Settings.MaximumAimDistance then
            continue
        end

        local screenPosition = Vector2.new(
            viewportPoint.X,
            viewportPoint.Y
        )

        local screenDistance =
            (screenPosition - mousePosition).Magnitude

        local isBetter

        if Script.Settings.LowestHealthPriority then
            local currentHealth = humanoid.Health
            local bestHealth = bestHumanoid and bestHumanoid.Health or math.huge
            isBetter = currentHealth < bestHealth
                or (currentHealth == bestHealth and screenDistance < bestScreenDistance)
        elseif Script.Settings.ClosestWorldPriority then
            isBetter = worldDistance < bestWorldDistance
                or (worldDistance == bestWorldDistance and screenDistance < bestScreenDistance)
        else
            isBetter = screenDistance < bestScreenDistance
        end

        if not isBetter then
            continue
        end

        if not isTargetVisible(aimPart) then
            continue
        end

        bestZombie = zombie
        bestPart = aimPart
        bestHumanoid = humanoid
        bestScreenPosition = screenPosition
        bestScreenDistance = screenDistance
        bestWorldDistance = worldDistance
    end

    if not bestPart then
        clearTarget()
        return
    end

    Script.Target.Zombie = bestZombie
    Script.Target.Part = bestPart
    Script.Target.Humanoid = bestHumanoid
    Script.Target.ScreenPosition = bestScreenPosition
    Script.Target.ScreenDistance = bestScreenDistance
    Script.Target.WorldDistance = bestWorldDistance
end

local function updateTarget()
    if not Script.Settings.SilentAim then
        clearTarget()
        return
    end

    if targetStillValid() then
        return
    end

    findClosestZombie()
end

local function tableContainsDirections(value)
    if type(value) ~= "table" then
        return false
    end

    local vectorCount = 0

    for _, child in pairs(value) do
        if typeof(child) == "Vector3" then
            vectorCount += 1
        elseif type(child) == "table" then
            if typeof(child.direction) == "Vector3"
                or typeof(child.Direction) == "Vector3"
            then
                vectorCount += 1
            end
        end

        if vectorCount > 0 then
            return true
        end
    end

    return false
end

local function findDirectionTable(arguments)
    for index = 1, arguments.n do
        local value = arguments[index]

        if tableContainsDirections(value) then
            return value, index
        end
    end

    return nil, nil
end

local function getReferencePositions()
    local positions = {}

    local camera = getCamera()

    if camera then
        table.insert(positions, camera.CFrame.Position)
    end

    local character = LocalPlayer.Character

    if character then
        local head = character:FindFirstChild("Head")
        local root = character:FindFirstChild("HumanoidRootPart")

        if head then
            table.insert(positions, head.Position)
        end

        if root then
            table.insert(positions, root.Position)
        end
    end

    return positions
end

local function distanceToNearestReference(position, references)
    local closest = math.huge

    for _, reference in ipairs(references) do
        closest = math.min(
            closest,
            (position - reference).Magnitude
        )
    end

    return closest
end

local function findRayOrigin(arguments, directionTableIndex)
    local references = getReferencePositions()
    local bestOrigin
    local bestDistance = math.huge

    for index = 1, arguments.n do
        if index == directionTableIndex then
            continue
        end

        local value = arguments[index]
        local candidate

        if typeof(value) == "Vector3" then
            candidate = value
        elseif typeof(value) == "CFrame" then
            candidate = value.Position
        elseif typeof(value) == "Ray" then
            candidate = value.Origin
        elseif type(value) == "table" then
            if typeof(value.origin) == "Vector3" then
                candidate = value.origin
            elseif typeof(value.Origin) == "Vector3" then
                candidate = value.Origin
            end
        end

        if candidate then
            local referenceDistance =
                distanceToNearestReference(candidate, references)

            if referenceDistance < bestDistance then
                bestDistance = referenceDistance
                bestOrigin = candidate
            end
        end
    end

    if bestOrigin and bestDistance <= 50 then
        return bestOrigin
    end

    local camera = getCamera()

    if camera then
        return camera.CFrame.Position
    end

    return nil
end

local function redirectDirection(
    originalDirection,
    rayOrigin,
    targetPosition
)
    if typeof(originalDirection) ~= "Vector3" then
        return originalDirection
    end

    local targetOffset = targetPosition - rayOrigin
    local targetDistance = targetOffset.Magnitude

    if targetDistance <= 0.001 then
        return originalDirection
    end

    local originalLength = originalDirection.Magnitude

    if originalLength <= 0.001 then
        originalLength = targetDistance
    end

    return targetOffset.Unit * originalLength
end

local function redirectDirectionTable(
    directionTable,
    rayOrigin,
    targetPosition
)
    local changed = false

    for key, value in pairs(directionTable) do
        if typeof(value) == "Vector3" then
            directionTable[key] = redirectDirection(
                value,
                rayOrigin,
                targetPosition
            )

            changed = true
        elseif type(value) == "table" then
            local entryOrigin = rayOrigin

            if typeof(value.origin) == "Vector3" then
                entryOrigin = value.origin
            elseif typeof(value.Origin) == "Vector3" then
                entryOrigin = value.Origin
            end

            if typeof(value.direction) == "Vector3" then
                value.direction = redirectDirection(
                    value.direction,
                    entryOrigin,
                    targetPosition
                )

                changed = true
            elseif typeof(value.Direction) == "Vector3" then
                value.Direction = redirectDirection(
                    value.Direction,
                    entryOrigin,
                    targetPosition
                )

                changed = true
            end
        end
    end

    return changed
end

local OldCastRays

OldCastRays = hookfunction(
    CastRays,
    newcclosure(function(...)
        if Script.Unloaded or not Script.Settings.SilentAim then
            return OldCastRays(...)
        end

        local target = Script.Target

        if not target.Part
            or not target.Humanoid
            or not isZombieAlive(target.Zombie, target.Humanoid)
        then
            return OldCastRays(...)
        end

        local arguments = table.pack(...)

        local directionTable, directionTableIndex =
            findDirectionTable(arguments)

        if not directionTable then
            return OldCastRays(...)
        end

        local rayOrigin = findRayOrigin(
            arguments,
            directionTableIndex
        )

        if not rayOrigin then
            return OldCastRays(...)
        end
        local targetPosition = target.Part.Position

        if Script.Settings.Prediction then
            targetPosition += target.Part.AssemblyLinearVelocity
                * Script.Settings.PredictionTime
        end

        redirectDirectionTable(
            directionTable,
            rayOrigin,
            targetPosition
        )

        return OldCastRays(
            table.unpack(arguments, 1, arguments.n)
        )
    end)
)

local function createESPObject(zombie)
    if Script.ZombieESP[zombie] then
        return Script.ZombieESP[zombie]
    end

    local esp = {
        Zombie = zombie,

        BoxOutline = newDrawing("Square", {
            Visible = false,
            Filled = false,
            Thickness = 3,
            Color = Color3.fromRGB(0, 0, 0),
            Transparency = 1,
        }),

        Box = newDrawing("Square", {
            Visible = false,
            Filled = false,
            Thickness = 1,
            Color = Script.Settings.ESPColor,
            Transparency = Script.Settings.ESPAlpha,
        }),

        HealthOutline = newDrawing("Square", {
            Visible = false,
            Filled = true,
            Color = Color3.fromRGB(0, 0, 0),
            Transparency = 1,
        }),

        HealthBackground = newDrawing("Square", {
            Visible = false,
            Filled = true,
            Color = Color3.fromRGB(35, 35, 35),
            Transparency = 1,
        }),

        HealthFill = newDrawing("Square", {
            Visible = false,
            Filled = true,
            Color = Color3.fromRGB(0, 255, 0),
            Transparency = 1,
        }),

        NameText = newDrawing("Text", {
            Visible = false,
            Center = true,
            Outline = true,
            Size = 13,
            Color = Script.Settings.ESPColor,
            Transparency = Script.Settings.ESPAlpha,
            Text = "",
        }),

        DistanceText = newDrawing("Text", {
            Visible = false,
            Center = true,
            Outline = true,
            Size = 12,
            Color = Script.Settings.ESPColor,
            Transparency = Script.Settings.ESPAlpha,
            Text = "",
        }),

        Tracer = newDrawing("Line", {
            Visible = false,
            Thickness = 1,
            Color = Script.Settings.ESPColor,
            Transparency = Script.Settings.ESPAlpha,
        }),
    }

    Script.ZombieESP[zombie] = esp

    return esp
end

local function hideESPObject(esp)
    if not esp then
        return
    end

    esp.BoxOutline.Visible = false
    esp.Box.Visible = false
    esp.HealthOutline.Visible = false
    esp.HealthBackground.Visible = false
    esp.HealthFill.Visible = false
    esp.NameText.Visible = false
    esp.DistanceText.Visible = false
    esp.Tracer.Visible = false
end

local function removeESPObject(zombie)
    local esp = Script.ZombieESP[zombie]

    if not esp then
        return
    end

    for key, object in pairs(esp) do
        if key ~= "Zombie" and object then
            pcall(function()
                object.Visible = false
                object:Remove()
            end)
        end
    end

    Script.ZombieESP[zombie] = nil
end

local function getModelScreenBounds(model)
    local camera = getCamera()

    if not camera or not model then
        return nil
    end

    local success, boundingCFrame, boundingSize =
        pcall(model.GetBoundingBox, model)

    if not success or not boundingCFrame or not boundingSize then
        return nil
    end

    local half = boundingSize * 0.5

    local offsets = {
        Vector3.new(-half.X, -half.Y, -half.Z),
        Vector3.new(-half.X, -half.Y, half.Z),
        Vector3.new(-half.X, half.Y, -half.Z),
        Vector3.new(-half.X, half.Y, half.Z),
        Vector3.new(half.X, -half.Y, -half.Z),
        Vector3.new(half.X, -half.Y, half.Z),
        Vector3.new(half.X, half.Y, -half.Z),
        Vector3.new(half.X, half.Y, half.Z),
    }

    local minimumX = math.huge
    local minimumY = math.huge
    local maximumX = -math.huge
    local maximumY = -math.huge
    local projected = 0

    for _, offset in ipairs(offsets) do
        local worldPosition =
            boundingCFrame:PointToWorldSpace(offset)

        local viewportPoint =
            camera:WorldToViewportPoint(worldPosition)

        if viewportPoint.Z > 0 then
            projected += 1

            minimumX = math.min(minimumX, viewportPoint.X)
            minimumY = math.min(minimumY, viewportPoint.Y)
            maximumX = math.max(maximumX, viewportPoint.X)
            maximumY = math.max(maximumY, viewportPoint.Y)
        end
    end

    if projected == 0 then
        return nil
    end

    local viewportSize = camera.ViewportSize

    if maximumX < 0
        or maximumY < 0
        or minimumX > viewportSize.X
        or minimumY > viewportSize.Y
    then
        return nil
    end

    local width = maximumX - minimumX
    local height = maximumY - minimumY

    if width <= 1 or height <= 1 then
        return nil
    end

    return Vector2.new(minimumX, minimumY),
        Vector2.new(width, height)
end

local function getHealthColor(percent)
    percent = math.clamp(percent, 0, 1)

    return Color3.fromRGB(
        math.floor(255 * (1 - percent)),
        math.floor(255 * percent),
        0
    )
end

local function updateZombieESP()
    local folder = getZombieFolder()
    local camera = getCamera()

    if not Script.Settings.ESP or not folder or not camera then
        for _, esp in pairs(Script.ZombieESP) do
            hideESPObject(esp)
        end

        return
    end

    for zombie, esp in pairs(Script.ZombieESP) do
        if not zombie.Parent or zombie.Parent ~= folder then
            removeESPObject(zombie)
            continue
        end

        local humanoid = getZombieHumanoid(zombie)
        local root = getZombieRoot(zombie)

        if not root or not isZombieAlive(zombie, humanoid) then
            hideESPObject(esp)
            continue
        end

        local distance =
            (camera.CFrame.Position - root.Position).Magnitude

        if distance > Script.Settings.ESPMaximumDistance then
            hideESPObject(esp)
            continue
        end

        local boxPosition, boxSize =
            getModelScreenBounds(zombie)

        if not boxPosition or not boxSize then
            hideESPObject(esp)
            continue
        end

        local showBox = Script.Settings.ESPBoxes
        local showHealth = Script.Settings.ESPHealthBar

        esp.BoxOutline.Visible = showBox
        esp.Box.Visible = showBox

        if showBox then
            esp.BoxOutline.Position = boxPosition
            esp.BoxOutline.Size = boxSize

            esp.Box.Position = boxPosition
            esp.Box.Size = boxSize
            esp.Box.Color = Script.Settings.ESPColor
            esp.Box.Transparency = Script.Settings.ESPAlpha
        end

        esp.HealthOutline.Visible = showHealth
        esp.HealthBackground.Visible = showHealth
        esp.HealthFill.Visible = showHealth

        if showHealth then
            local healthPercent = 0

            if humanoid.MaxHealth > 0 then
                healthPercent = math.clamp(
                    humanoid.Health / humanoid.MaxHealth,
                    0,
                    1
                )
            end

            local barWidth = 3
            local barGap = 5
            local padding = 1

            local barX = boxPosition.X - barGap - barWidth
            local barY = boxPosition.Y
            local barHeight = boxSize.Y
            local fillHeight = barHeight * healthPercent

            esp.HealthOutline.Position = Vector2.new(
                barX - padding,
                barY - padding
            )

            esp.HealthOutline.Size = Vector2.new(
                barWidth + padding * 2,
                barHeight + padding * 2
            )

            esp.HealthBackground.Position = Vector2.new(
                barX,
                barY
            )

            esp.HealthBackground.Size = Vector2.new(
                barWidth,
                barHeight
            )

            esp.HealthFill.Position = Vector2.new(
                barX,
                barY + barHeight - fillHeight
            )

            esp.HealthFill.Size = Vector2.new(
                barWidth,
                math.max(fillHeight, 0)
            )

            esp.HealthFill.Color = getHealthColor(healthPercent)
            esp.HealthFill.Transparency =
                Script.Settings.ESPAlpha
        end

        local zombieType = zombie:GetAttribute("Type") or zombie.Name
        local showName = Script.Settings.ESPNames
        local showDistance = Script.Settings.ESPDistance
        local showTracer = Script.Settings.ESPTracers

        esp.NameText.Visible = showName
        esp.DistanceText.Visible = showDistance
        esp.Tracer.Visible = showTracer

        if showName then
            esp.NameText.Position = Vector2.new(
                boxPosition.X + boxSize.X * 0.5,
                boxPosition.Y - 16
            )
            esp.NameText.Text = string.format(
                "%s  [%d/%d]",
                tostring(zombieType),
                math.max(0, math.floor(humanoid.Health + 0.5)),
                math.max(1, math.floor(humanoid.MaxHealth + 0.5))
            )
            esp.NameText.Color = Script.Settings.ESPColor
            esp.NameText.Transparency = Script.Settings.ESPAlpha
        end

        if showDistance then
            esp.DistanceText.Position = Vector2.new(
                boxPosition.X + boxSize.X * 0.5,
                boxPosition.Y + boxSize.Y + 2
            )
            esp.DistanceText.Text = string.format("%d studs", math.floor(distance + 0.5))
            esp.DistanceText.Color = Script.Settings.ESPColor
            esp.DistanceText.Transparency = Script.Settings.ESPAlpha
        end

        if showTracer then
            esp.Tracer.From = Vector2.new(
                camera.ViewportSize.X * 0.5,
                camera.ViewportSize.Y - 2
            )
            esp.Tracer.To = Vector2.new(
                boxPosition.X + boxSize.X * 0.5,
                boxPosition.Y + boxSize.Y
            )
            esp.Tracer.Color = Script.Settings.ESPColor
            esp.Tracer.Transparency = Script.Settings.ESPAlpha
        end
    end
end

local CurrentZombieFolder
local FolderAddedConnection
local FolderRemovedConnection

local function registerExistingZombies()
    local folder = getZombieFolder()

    if not folder then
        return
    end

    for _, zombie in ipairs(folder:GetChildren()) do
        if zombie:IsA("Model") then
            createESPObject(zombie)
        end
    end
end

local function connectZombieFolder()
    local folder = getZombieFolder()

    if folder == CurrentZombieFolder then
        return
    end

    if FolderAddedConnection then
        FolderAddedConnection:Disconnect()
        FolderAddedConnection = nil
    end

    if FolderRemovedConnection then
        FolderRemovedConnection:Disconnect()
        FolderRemovedConnection = nil
    end

    CurrentZombieFolder = folder

    if not folder then
        return
    end

    registerExistingZombies()

    FolderAddedConnection =
        folder.ChildAdded:Connect(function(zombie)
            if Script.Unloaded then
                return
            end

            if zombie:IsA("Model") then
                createESPObject(zombie)
            end
        end)

    FolderRemovedConnection =
        folder.ChildRemoved:Connect(function(zombie)
            removeESPObject(zombie)
        end)

    Script.Connections.FolderAdded = FolderAddedConnection
    Script.Connections.FolderRemoved = FolderRemovedConnection
end


local function getCharacterParts()
    local character = LocalPlayer.Character
    if not character then
        return nil, nil, nil
    end

    return character,
        character:FindFirstChildOfClass("Humanoid"),
        character:FindFirstChild("HumanoidRootPart")
end

local function restoreCollision()
    for part, original in pairs(Script.CollisionState) do
        if part and part.Parent then
            pcall(function()
                part.CanCollide = original
            end)
        end
    end
    table.clear(Script.CollisionState)
end

local function updateMovement()
    local character, humanoid, root = getCharacterParts()
    if not character or not humanoid or not root then
        return
    end

    if Script.Settings.Movement then
        humanoid.WalkSpeed = Script.Settings.WalkSpeed
        humanoid.UseJumpPower = true
        humanoid.JumpPower = Script.Settings.JumpPower
    end

    if Script.Settings.Noclip then
        for _, object in ipairs(character:GetDescendants()) do
            if object:IsA("BasePart") then
                if Script.CollisionState[object] == nil then
                    Script.CollisionState[object] = object.CanCollide
                end
                object.CanCollide = false
            end
        end
    elseif next(Script.CollisionState) then
        restoreCollision()
    end

    if Script.Settings.AntiKnockback and not Script.Settings.Fly then
        local velocity = root.AssemblyLinearVelocity
        local horizontal = Vector3.new(velocity.X, 0, velocity.Z)

        if horizontal.Magnitude > Script.Settings.WalkSpeed * 2.5 then
            horizontal = horizontal.Unit * Script.Settings.WalkSpeed * 2.5
        end

        root.AssemblyLinearVelocity = Vector3.new(
            horizontal.X,
            math.clamp(velocity.Y, -85, 85),
            horizontal.Z
        )
    end

    if Script.Settings.Fly then
        local camera = getCamera()
        if camera then
            local direction = Vector3.zero

            if UserInputService:IsKeyDown(Enum.KeyCode.W) then
                direction += camera.CFrame.LookVector
            end
            if UserInputService:IsKeyDown(Enum.KeyCode.S) then
                direction -= camera.CFrame.LookVector
            end
            if UserInputService:IsKeyDown(Enum.KeyCode.D) then
                direction += camera.CFrame.RightVector
            end
            if UserInputService:IsKeyDown(Enum.KeyCode.A) then
                direction -= camera.CFrame.RightVector
            end
            if UserInputService:IsKeyDown(Enum.KeyCode.Space) then
                direction += Vector3.yAxis
            end
            if UserInputService:IsKeyDown(Enum.KeyCode.LeftControl) then
                direction -= Vector3.yAxis
            end

            if direction.Magnitude > 0 then
                direction = direction.Unit
            end

            root.AssemblyLinearVelocity = direction * Script.Settings.FlySpeed
            root.AssemblyAngularVelocity = Vector3.zero
            humanoid.PlatformStand = false
        end
    end

    if Script.Settings.FallProtection then
        local floor = humanoid.FloorMaterial
        if floor ~= Enum.Material.Air and root.Position.Y > Workspace.FallenPartsDestroyHeight + 20 then
            Script.LastSafeCFrame = root.CFrame
        elseif root.Position.Y < Workspace.FallenPartsDestroyHeight + 10
            and Script.LastSafeCFrame
        then
            root.CFrame = Script.LastSafeCFrame + Vector3.new(0, 4, 0)
            root.AssemblyLinearVelocity = Vector3.zero
        end
    end
end

local function updateAutoInteract()
    if not Script.Settings.AutoInteract then
        return
    end

    local now = os.clock()
    if now - Script.LastInteractScan < 0.25 then
        return
    end
    Script.LastInteractScan = now

    local _, _, root = getCharacterParts()
    if not root then
        return
    end

    for _, object in ipairs(Workspace:GetDescendants()) do
        if object:IsA("ProximityPrompt")
            and object.Enabled
            and object.Parent
            and object.Parent:IsA("BasePart")
            and (object.Parent.Position - root.Position).Magnitude
                <= Script.Settings.AutoInteractRadius
        then
            pcall(function()
                fireproximityprompt(object)
            end)
        end
    end
end

Script.Connections.InfiniteJump =
    UserInputService.JumpRequest:Connect(function()
        if Script.Unloaded or not Script.Settings.InfiniteJump then
            return
        end

        local _, humanoid = getCharacterParts()
        if humanoid then
            humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
        end
    end)

Script.Connections.RenderStepped =
    RunService.RenderStepped:Connect(function()
        if Script.Unloaded then
            return
        end

        connectZombieFolder()
        updateTarget()
        updateZombieESP()
        updateMovement()
        updateAutoInteract()

        local folder = getZombieFolder()
        local aliveCount = 0
        if folder then
            for _, zombie in ipairs(folder:GetChildren()) do
                local humanoid = getZombieHumanoid(zombie)
                if zombie:IsA("Model") and isZombieAlive(zombie, humanoid) then
                    aliveCount += 1
                end
            end
        end

        ZombieCounter.Visible = Script.Settings.ESP
        ZombieCounter.Text = "Zombies: " .. tostring(aliveCount)
        ZombieCounter.Color = Script.Settings.ESPColor

        local mousePosition = getMousePosition()

        FOVCircle.Position = mousePosition
        FOVCircle.Radius = Script.Settings.FOV
        FOVCircle.Color = Script.Settings.ESPColor
        FOVCircle.Transparency = Script.Settings.ESPAlpha

        FOVCircle.Visible =
            Script.Settings.SilentAim
            and Script.Settings.ShowFOV

        local target = Script.Target

        local hasTarget =
            Script.Settings.SilentAim
            and target.Part ~= nil
            and target.Humanoid ~= nil
            and target.ScreenPosition ~= nil

        TargetLine.Visible =
            hasTarget and Script.Settings.TargetLine

        TargetPoint.Visible = hasTarget

        TargetLine.Color = Script.Settings.ESPColor
        TargetPoint.Color = Script.Settings.ESPColor

        TargetLine.Transparency = Script.Settings.ESPAlpha
        TargetPoint.Transparency = Script.Settings.ESPAlpha

        if hasTarget then
            TargetLine.From = mousePosition
            TargetLine.To = target.ScreenPosition
            TargetPoint.Position = target.ScreenPosition
        end
    end)

local Window = Library:Window({
    Name = "Zombie Combat",
    SubName = "Silent Aim & ESP",
    Logo = "7733960981",
    MenuKeybind = Enum.KeyCode.RightShift,
})

local CombatPage = Window:Page({
    Name = "Combat",
    Icon = "rbxassetid://7733674079",
})

local VisualPage = Window:Page({
    Name = "Visuals",
    Icon = "rbxassetid://7733779610",
})

local AimSection = CombatPage:Section({
    Name = "Silent Aim",
    Side = 1,
})

AimSection:Toggle({
    Name = "Silent Aim",
    Flag = "ZombieSilentAim",
    Default = Script.Settings.SilentAim,

    Callback = function(value)
        Script.Settings.SilentAim = value

        if not value then
            clearTarget()
            TargetLine.Visible = false
            TargetPoint.Visible = false
            FOVCircle.Visible = false
        end
    end,
})

AimSection:Slider({
    Name = "FOV Radius",
    Flag = "ZombieAimFOV",
    Min = 25,
    Max = 1000,
    Default = Script.Settings.FOV,
    Decimals = 1,
    Suffix = " px",

    Callback = function(value)
        Script.Settings.FOV = value
        FOVCircle.Radius = value
    end,
})

AimSection:Slider({
    Name = "Maximum Distance",
    Flag = "ZombieAimDistance",
    Min = 100,
    Max = 10000,
    Default = Script.Settings.MaximumAimDistance,
    Decimals = 1,
    Suffix = " studs",

    Callback = function(value)
        Script.Settings.MaximumAimDistance = value
    end,
})

AimSection:Toggle({
    Name = "Visibility Check",
    Flag = "ZombieVisibilityCheck",
    Default = Script.Settings.VisibilityCheck,

    Callback = function(value)
        Script.Settings.VisibilityCheck = value
        clearTarget()
    end,
})

AimSection:Toggle({
    Name = "Show FOV Circle",
    Flag = "ZombieShowFOV",
    Default = Script.Settings.ShowFOV,

    Callback = function(value)
        Script.Settings.ShowFOV = value

        if not value then
            FOVCircle.Visible = false
        end
    end,
})

AimSection:Toggle({
    Name = "Target Line",
    Flag = "ZombieTargetLine",
    Default = Script.Settings.TargetLine,

    Callback = function(value)
        Script.Settings.TargetLine = value

        if not value then
            TargetLine.Visible = false
        end
    end,
})

AimSection:Toggle({
    Name = "Head Priority",
    Flag = "ZombieHeadPriority",
    Default = Script.Settings.HeadshotOnly,
    Callback = function(value)
        Script.Settings.HeadshotOnly = value
        clearTarget()
    end,
})

AimSection:Toggle({
    Name = "Movement Prediction",
    Flag = "ZombiePrediction",
    Default = Script.Settings.Prediction,
    Callback = function(value)
        Script.Settings.Prediction = value
    end,
})

AimSection:Slider({
    Name = "Prediction Time",
    Flag = "ZombiePredictionTime",
    Min = 0,
    Max = 0.5,
    Default = Script.Settings.PredictionTime,
    Decimals = 2,
    Suffix = " s",
    Callback = function(value)
        Script.Settings.PredictionTime = value
    end,
})

AimSection:Toggle({
    Name = "Closest World Priority",
    Flag = "ZombieClosestWorld",
    Default = Script.Settings.ClosestWorldPriority,
    Callback = function(value)
        Script.Settings.ClosestWorldPriority = value
        if value then
            Script.Settings.LowestHealthPriority = false
        end
        clearTarget()
    end,
})

AimSection:Toggle({
    Name = "Lowest Health Priority",
    Flag = "ZombieLowestHealth",
    Default = Script.Settings.LowestHealthPriority,
    Callback = function(value)
        Script.Settings.LowestHealthPriority = value
        if value then
            Script.Settings.ClosestWorldPriority = false
        end
        clearTarget()
    end,
})

local ESPSection = VisualPage:Section({
    Name = "Zombie ESP",
    Side = 1,
})

ESPSection:Toggle({
    Name = "Zombie ESP",
    Flag = "ZombieESP",
    Default = Script.Settings.ESP,

    Callback = function(value)
        Script.Settings.ESP = value

        if value then
            registerExistingZombies()
        else
            for _, esp in pairs(Script.ZombieESP) do
                hideESPObject(esp)
            end
        end
    end,
})

ESPSection:Toggle({
    Name = "2D Boxes",
    Flag = "ZombieESPBoxes",
    Default = Script.Settings.ESPBoxes,

    Callback = function(value)
        Script.Settings.ESPBoxes = value
    end,
})

ESPSection:Toggle({
    Name = "Health Bar",
    Flag = "ZombieESPHealthBar",
    Default = Script.Settings.ESPHealthBar,

    Callback = function(value)
        Script.Settings.ESPHealthBar = value
    end,
})

ESPSection:Toggle({
    Name = "Names & Health",
    Flag = "ZombieESPNames",
    Default = Script.Settings.ESPNames,
    Callback = function(value)
        Script.Settings.ESPNames = value
    end,
})

ESPSection:Toggle({
    Name = "Distance",
    Flag = "ZombieESPDistanceText",
    Default = Script.Settings.ESPDistance,
    Callback = function(value)
        Script.Settings.ESPDistance = value
    end,
})

ESPSection:Toggle({
    Name = "Tracers",
    Flag = "ZombieESPTracers",
    Default = Script.Settings.ESPTracers,
    Callback = function(value)
        Script.Settings.ESPTracers = value
    end,
})

ESPSection:Slider({
    Name = "Maximum Distance",
    Flag = "ZombieESPDistance",
    Min = 100,
    Max = 10000,
    Default = Script.Settings.ESPMaximumDistance,
    Decimals = 1,
    Suffix = " studs",

    Callback = function(value)
        Script.Settings.ESPMaximumDistance = value
    end,
})

local PlayerPage = Window:Page({
    Name = "Player",
    Icon = "rbxassetid://7733960981",
})

local MovementSection = PlayerPage:Section({
    Name = "Movement",
    Side = 1,
})

MovementSection:Toggle({
    Name = "Movement Override",
    Flag = "MovementOverride",
    Default = Script.Settings.Movement,
    Callback = function(value)
        Script.Settings.Movement = value
    end,
})

MovementSection:Slider({
    Name = "Walk Speed",
    Flag = "MovementWalkSpeed",
    Min = 16,
    Max = 100,
    Default = Script.Settings.WalkSpeed,
    Decimals = 1,
    Suffix = " studs/s",
    Callback = function(value)
        Script.Settings.WalkSpeed = value
    end,
})

MovementSection:Slider({
    Name = "Jump Power",
    Flag = "MovementJumpPower",
    Min = 30,
    Max = 150,
    Default = Script.Settings.JumpPower,
    Decimals = 1,
    Callback = function(value)
        Script.Settings.JumpPower = value
    end,
})

MovementSection:Toggle({
    Name = "Infinite Jump",
    Flag = "MovementInfiniteJump",
    Default = Script.Settings.InfiniteJump,
    Callback = function(value)
        Script.Settings.InfiniteJump = value
    end,
})

MovementSection:Toggle({
    Name = "Noclip",
    Flag = "MovementNoclip",
    Default = Script.Settings.Noclip,
    Callback = function(value)
        Script.Settings.Noclip = value
        if not value then
            restoreCollision()
        end
    end,
})

MovementSection:Toggle({
    Name = "Fly",
    Flag = "MovementFly",
    Default = Script.Settings.Fly,
    Callback = function(value)
        Script.Settings.Fly = value
        if not value then
            local _, _, root = getCharacterParts()
            if root then
                root.AssemblyLinearVelocity = Vector3.zero
            end
        end
    end,
})

MovementSection:Slider({
    Name = "Fly Speed",
    Flag = "MovementFlySpeed",
    Min = 10,
    Max = 250,
    Default = Script.Settings.FlySpeed,
    Decimals = 1,
    Suffix = " studs/s",
    Callback = function(value)
        Script.Settings.FlySpeed = value
    end,
})

local UtilitySection = PlayerPage:Section({
    Name = "Safety & Utility",
    Side = 2,
})

UtilitySection:Toggle({
    Name = "Anti Knockback",
    Flag = "MovementAntiKnockback",
    Default = Script.Settings.AntiKnockback,
    Callback = function(value)
        Script.Settings.AntiKnockback = value
    end,
})

UtilitySection:Toggle({
    Name = "Fall Protection",
    Flag = "MovementFallProtection",
    Default = Script.Settings.FallProtection,
    Callback = function(value)
        Script.Settings.FallProtection = value
    end,
})

UtilitySection:Toggle({
    Name = "Auto Interact",
    Flag = "UtilityAutoInteract",
    Default = Script.Settings.AutoInteract,
    Callback = function(value)
        Script.Settings.AutoInteract = value
    end,
})

UtilitySection:Slider({
    Name = "Interact Radius",
    Flag = "UtilityInteractRadius",
    Min = 3,
    Max = 30,
    Default = Script.Settings.AutoInteractRadius,
    Decimals = 1,
    Suffix = " studs",
    Callback = function(value)
        Script.Settings.AutoInteractRadius = value
    end,
})

function Script:Unload()
    if self.Unloaded then
        return
    end

    self.Unloaded = true

    clearTarget()
    restoreCollision()

    local _, humanoid, root = getCharacterParts()
    if humanoid then
        humanoid.PlatformStand = false
    end
    if root then
        root.AssemblyLinearVelocity = Vector3.zero
    end

    for _, connection in pairs(self.Connections) do
        pcall(function()
            connection:Disconnect()
        end)
    end

    table.clear(self.Connections)

    if FolderAddedConnection then
        pcall(function()
            FolderAddedConnection:Disconnect()
        end)

        FolderAddedConnection = nil
    end

    if FolderRemovedConnection then
        pcall(function()
            FolderRemovedConnection:Disconnect()
        end)

        FolderRemovedConnection = nil
    end

    local zombies = {}

    for zombie in pairs(self.ZombieESP) do
        table.insert(zombies, zombie)
    end

    for _, zombie in ipairs(zombies) do
        removeESPObject(zombie)
    end

    for _, drawing in pairs(self.Drawings) do
        pcall(function()
            drawing.Visible = false
            drawing:Remove()
        end)
    end

    table.clear(self.Drawings)

    pcall(function()
        Library:Unload()
    end)

    if ENV.ZombieCombat == self then
        ENV.ZombieCombat = nil
    end

    if ENV.ZombieCombatLibrary == Library then
        ENV.ZombieCombatLibrary = nil
    end
end

connectZombieFolder()
registerExistingZombies()

print("[Zombie Combat] Loaded")
print("[Zombie Combat] Z toggles the menu")

Signal Hub — Auto Fire, Melee & Farm Tools

Developer: Signal Hub
Created: Created 2026-11-03

The broadest hub in this selection, with separate tabs for guns, melee, movement and collection. Start with the tab that matches your equipped weapon.

Targeting: Auto Fire [G], Silent Aim, Look At Target, Single / Auto / Hold click modes, Fire Rate
Gun positioning: Teleport Above Head, Gun TP Height
Melee: Auto Melee [M], Melee Rate, Melee TP Above Head, Melee TP Height
+2 more

Leave Teleport Above Head off. It can place your character inside the zombie spawn area and leave you stuck in a zone that cannot normally be entered.

Details

Signal Hub — Auto Fire, Melee & Farm Tools functions

Targeting: Auto Fire [G], Silent Aim, Look At Target, Single / Auto / Hold click modes, Fire Rate
Gun positioning: Teleport Above Head, Gun TP Height
Melee: Auto Melee [M], Melee Rate, Melee TP Above Head, Melee TP Height
Movement: Noclip [N], Hip Height, CFrame Walk [C], CFrame Speed
Collection: Auto Mystery Box, Auto Ammo Box, Scrap Exploit, Collect Amount

Access: NO KEY

Tags: PC MOBILE

Languages: English

Compatibility: Potassium Delta Arceus X Codex Other

Script code

loadstring(game:HttpGet("https://gist.githubusercontent.com/zero0signal/42d7996465553f42054aa34ae4273377/raw/d6c95829ac35d5b075ad0262a95859dc24afc44d/Signal100WavesLater"))()

Tora IsMe — Bring Mobs, Auto Shoot & Auto Collect

Developer: Tora IsMe
Created: Created 2026-11-03

Choose this menu to bring zombies in front of your character instead of chasing them around the map. Zombie Distance controls how far away they are placed: 2–20 studs, with 6 as the starting value.

Bring Mobs
Auto Shoot
Auto Collect
+2 more

Fly uses keyboard controls; this version has no touch flight controls. Turn Bring Mobs off to release the zombies anchored by the script. Gameplay testing is pending.

Details

Tora IsMe — Bring Mobs, Auto Shoot & Auto Collect functions

Bring Mobs
Auto Shoot
Auto Collect
HipHeight: 2–50
Fly (WASD)

Access: NO KEY

Tags: OPEN SOURCE

Languages: English

Script code

if game:GetService("CoreGui"):FindFirstChild("ToraScript") then
    game:GetService("CoreGui").ToraScript:Destroy()
end

local lib = loadstring(game:HttpGet("https://raw.githubusercontent.com/liebertsx/Tora-Library/main/src/librarynew", true))()
local win = lib:CreateWindow("Survive Wave Z")

local dist = 6

win:AddSlider({text="Zombie Distance",min=2,max=20,value=6,callback=function(v) dist=v end})

local bringOn = false
win:AddToggle({text="Bring Mobs",callback=function(t)
    bringOn = t
    if t then
        spawn(function()
            while bringOn do
                task.wait()
                for _,z in workspace.ServerZombies:GetDescendants() do
                    if z.Name=="Humanoid" and z.Health>0 and z.RootPart then
                        z.RootPart.CFrame = game.Players.LocalPlayer.Character.HumanoidRootPart.CFrame*CFrame.new(0,0,-dist)
                        z.RootPart.Anchored = true
                    end
                end
                task.wait(.15)
            end
            for _,z in workspace.ServerZombies:GetDescendants() do
                if z.Name=="Humanoid" and z.RootPart then z.RootPart.Anchored=false end
            end
        end)
    end
end})

local shootOn = false
win:AddToggle({text="Auto Shoot",callback=function(t)
    shootOn = t
    if t then
        spawn(function()
            while shootOn do
                task.wait()
                local gun = game.Players.LocalPlayer.Character:FindFirstChildOfClass("Model")
                if gun and workspace.ServerZombies:FindFirstChildOfClass("Model") then
                    gun:SetAttribute("IsShooting",true)
                    task.wait()
                    gun:SetAttribute("IsShooting",false)
                end
            end)
        end)
    end
end})

local collectOn = false
win:AddToggle({text="Auto Collect",callback=function(t)
    collectOn = t
    if t then
        spawn(function()
            while collectOn do
                task.wait()
                for _,p in workspace:GetChildren() do
                    if p:IsA("Part") and p.Name~="Part" and p.Name~="Terrain" then
                        p.CFrame = game.Players.LocalPlayer.Character.HumanoidRootPart.CFrame
                    end
                end
            end)
        end)
    end
end})

win:AddSlider({text="HipHeight",min=2,max=50,value=2,callback=function(v)
    if game.Players.LocalPlayer.Character then
        game.Players.LocalPlayer.Character.Humanoid.HipHeight = v
    end
end})

local flying = false
local speed = 120
local keys = {w=false,s=false,a=false,d=false}
local velo, gyro

local function fly()
    local plr = game.Players.LocalPlayer
    local char = plr.Character or plr.CharacterAdded:Wait()
    local root = char:FindFirstChild("HumanoidRootPart") or char:WaitForChild("HumanoidRootPart")
    
    if velo then velo:Destroy() end
    if gyro then gyro:Destroy() end
    
    velo = Instance.new("BodyVelocity",root)
    velo.MaxForce = Vector3.new(1e9,1e9,1e9)
    velo.Velocity = Vector3.new()
    
    gyro = Instance.new("BodyGyro",root)
    gyro.MaxTorque = Vector3.new(1e9,1e9,1e9)
    gyro.P = 15000
    gyro.CFrame = root.CFrame
    
    flying = true
    spawn(function()
        while flying and root.Parent do
            task.wait()
            local cam = workspace.CurrentCamera
            local dir = Vector3.new(
                (keys.d and 1 or 0) - (keys.a and 1 or 0),
                0,
                -( (keys.w and 1 or 0) - (keys.s and 1 or 0) )
            )
            if dir.Magnitude > 0 then
                velo.Velocity = cam.CFrame:VectorToWorldSpace(dir.Unit * speed)
            else
                velo.Velocity = Vector3.new()
            end
            gyro.CFrame = cam.CFrame
        end
        if velo then velo:Destroy() end
        if gyro then gyro:Destroy() end
    end)
end

game:GetService("UserInputService").InputBegan:Connect(function(k,gp)
    if gp or not flying then return end
    if k.KeyCode == Enum.KeyCode.W then keys.w = true end
    if k.KeyCode == Enum.KeyCode.S then keys.s = true end
    if k.KeyCode == Enum.KeyCode.A then keys.a = true end
    if k.KeyCode == Enum.KeyCode.D then keys.d = true end
end)

game:GetService("UserInputService").InputEnded:Connect(function(k)
    if not flying then return end
    if k.KeyCode == Enum.KeyCode.W then keys.w = false end
    if k.KeyCode == Enum.KeyCode.S then keys.s = false end
    if k.KeyCode == Enum.KeyCode.A then keys.a = false end
    if k.KeyCode == Enum.KeyCode.D then keys.d = false end
end)

win:AddToggle({text="Fly (WASD)",callback=function(t)
    flying = t
    if t then fly() end
end})

win:AddLabel({text="YouTube: Tora IsMe"})
lib:Init()

LuckyX128345 — Auto Kill Zombies

Developer: LuckyX128345
Created: Created 2026-11-03

A lightweight option for repeated wave clearing when you do not need a hub interface.

Automatically requests explosions at zombie positions
Repeats every 0.1 seconds

No adjustable range or on/off toggle is included. Leave and rejoin the game to stop this continuous loop.

Details

LuckyX128345 — Auto Kill Zombies functions

Automatically requests explosions at zombie positions
Repeats every 0.1 seconds

Access: NO KEY

Tags: PC MOBILE

Languages: English

Compatibility: Potassium Delta Arceus X Codex Other

Script code

local rm = game:GetService("ReplicatedStorage").Packages._Index["sleitnick_knit@1.6.0"].knit.Services.ExplosionService.RF.GenerateExplosion

while true do
	for _, z in pairs(workspace.Zombies:GetChildren()) do
		local hrp = z:FindFirstChild("HumanoidRootPart")
		if hrp then pcall(function() rm:InvokeServer(hrp.Position, math.huge, 2, "EXPLOSIVE CROSSBOW") end) end
	end
	task.wait(0.1)
end

LuckyX128345 — Custom Scrap Pickup Amount

Developer: LuckyX128345
Created: Created 2026-11-03

Increase the number in local amount = 32124 before running the script to raise the scrap reward per zombie kill. Keep the value numeric, without quotation marks.

Only reacts to objects added after it loads. Existing pickups are not processed.

Details

Access: NO KEY

Tags: PC MOBILE

Languages: English

Compatibility: Potassium Delta Arceus X Codex Other

Script code

local RS = game:GetService("ReplicatedStorage")
local remote = RS.Packages._Index["sleitnick_knit@1.6.0"].knit.Services.PickupManager.RE.Collect
local amount = 32124 -- Amount of how much scrap you want everytime you kill an zombie

workspace.DescendantAdded:Connect(function(v)
	local id = v:GetAttribute("Id")
	if id then
		pcall(function()
			remote:FireServer(id, "SCRAP", amount)
		end)
	end
end)

Auto Revive — Self & Teammates

Created: Created 2026-11-03

For keeping a run going after players go down, without managing a hub menu.

No manual toggle is included. Players who were already down before the listener loaded are not scanned.

Details

Access: NO KEY

Tags: PC MOBILE

Languages: English

Compatibility: Potassium Delta Arceus X Codex Other

Script code

local rm = game:GetService("ReplicatedStorage").Packages._Index["sleitnick_knit@1.6.0"].knit.Services.RaidManagementService.RE

rm.CreateReviveBillboard.OnClientEvent:Connect(function(a1, a2)
	task.wait(0.1)
	pcall(function()
		rm.RevivePromptTriggeredClient:FireServer(a2)
    end)
end)

Troubleshooting

The script throws an error as soon as I run it. What should I report?

Copy the first error message and include the script name, executor and device. Note whether it happened in the lobby or during a wave; an error naming a missing object can indicate a changed game structure.

A damage or scrap request runs, but nothing changes. Is the advertised result guaranteed?

No. The game server can reject the request. Check zombie health or the actual scrap balance rather than relying on an animation or popup; a visible effect alone does not confirm the result.

100 Waves Later Scripts — No Key, Kill Aura & Silent Aim

What is 100 Waves Later?

100 Waves Later video

Cyerc — Silent Aim & Magic Bullet

Cyerc — Silent Aim & Magic Bullet functions

Zombie Combat — Silent Aim, ESP & Movement

Zombie Combat — Silent Aim, ESP & Movement functions

Signal Hub — Auto Fire, Melee & Farm Tools

Signal Hub — Auto Fire, Melee & Farm Tools functions

Tora IsMe — Bring Mobs, Auto Shoot & Auto Collect

Tora IsMe — Bring Mobs, Auto Shoot & Auto Collect functions

LuckyX128345 — Auto Kill Zombies

LuckyX128345 — Auto Kill Zombies functions

LuckyX128345 — Custom Scrap Pickup Amount

Auto Revive — Self & Teammates

How to start

Check your executor’s features

Troubleshooting

What is 100 Waves Later?

100 Waves Later video

Cyerc — Silent Aim & Magic Bullet functions

Zombie Combat — Silent Aim, ESP & Movement functions

Signal Hub — Auto Fire, Melee & Farm Tools functions

Tora IsMe — Bring Mobs, Auto Shoot & Auto Collect functions

LuckyX128345 — Auto Kill Zombies functions

How to start

Check your executor’s features

Troubleshooting

More scripts you may like

Infected Lands Scripts (No Key) — Loot ESP & Map Markers

Chess Duels Script NO KEY — Auto Play and Best Move Arrows

Escape The Matrix Script NO KEY — (Auto Gigs)

PURGATORIO Script — Enemy Lock-On and ESP