I'll create a custom pathfinding solution for Roblox that aims to outperform PathfindingService. This will be a LocalScript that uses a combination of A* algorithm with optimizations for performance. -- Custom Pathfinding Module local CustomPathfinding = {} CustomPathfinding.__index = CustomPathfinding -- Configuration local GRID_SIZE = 4 -- Smaller grid for more precision local MAX_ITERATIONS = 1000 -- Prevent infinite loops local HEURISTIC_WEIGHT = 1.2 -- Weight for heuristic (A*) local DIAGONAL_COST = 1.414 -- Cost for diagonal movement -- Node class local Node = {} Node.__index = Node function Node.new(position, parent, g, h) local self = setmetatable({}, Node) self.position = position self.parent = parent self.g = g or 0 -- Cost from start self.h = h or 0 -- Heuristic to end self.f = self.g + self.h -- Total cost return self end -- Helper functions local function getNearestPlayer(character) local players = game:GetService("Players"):GetPlayers() local nearestPlayer, minDistance = nil, math.huge local myPosition = character:GetPivot().Position for _, player in ipairs(players) do if player ~= game:GetService("Players").LocalPlayer and player.Character then local targetPosition = player.Character:GetPivot().Position local distance = (targetPosition - myPosition).Magnitude if distance < minDistance then minDistance = distance nearestPlayer = player.Character end end end return nearestPlayer end local function isPositionWalkable(position, character) local params = RaycastParams.new() params.FilterDescendantsInstances = {character} params.FilterType = Enum.RaycastFilterType.Blacklist -- Check if position is above ground local ray = Ray.new(position + Vector3.new(0, 5, 0), Vector3.new(0, -10, 0)) local hit = workspace:Raycast(ray.Origin, ray.Direction, params) if not hit then return false end -- Check for obstacles at position local parts = workspace:GetPartsInPart(Region3.new( position - Vector3.new(GRID_SIZE/2, 2, GRID_SIZE/2), position + Vector3.new(GRID_SIZE/2, 2, GRID_SIZE/2) )) for _, part in ipairs(parts) do if part.CanCollide and not part:IsA("BasePart") then return false end end return true end local function getNeighbors(node, target, character) local neighbors = {} local directions = { Vector3.new(GRID_SIZE, 0, 0), Vector3.new(-GRID_SIZE, 0, 0), Vector3.new(0, 0, GRID_SIZE), Vector3.new(0, 0, -GRID_SIZE), Vector3.new(GRID_SIZE, 0, GRID_SIZE), Vector3.new(GRID_SIZE, 0, -GRID_SIZE), Vector3.new(-GRID_SIZE, 0, GRID_SIZE), Vector3.new(-GRID_SIZE, 0, -GRID_SIZE) } for _, dir in ipairs(directions) do local newPos = node.position + dir if isPositionWalkable(newPos, character) then local g = node.g + (dir.Magnitude > GRID_SIZE and DIAGONAL_COST or 1) local h = (newPos - target).Magnitude * HEURISTIC_WEIGHT table.insert(neighbors, Node.new(newPos, node, g, h)) end end return neighbors end -- Main pathfinding function function CustomPathfinding.findPath(start, target, character) local openSet = {} local closedSet = {} local startNode = Node.new(start) local targetNode = Node.new(target) table.insert(openSet, startNode) local iterations = 0 while #openSet > 0 and iterations < MAX_ITERATIONS do iterations = iterations + 1 -- Find node with lowest f cost table.sort(openSet, function(a, b) return a.f < b.f end) local currentNode = table.remove(openSet, 1) table.insert(closedSet, currentNode) -- Check if we reached the target if (currentNode.position - targetNode.position).Magnitude < GRID_SIZE then local path = {} local node = currentNode while node do table.insert(path, 1, node.position) node = node.parent end return path end -- Process neighbors local neighbors = getNeighbors(currentNode, target, character) for _, neighbor in ipairs(neighbors) do local inClosed = false for _, closedNode in ipairs(closedSet) do if (closedNode.position - neighbor.position).Magnitude < GRID_SIZE/2 then inClosed = true break end end if inClosed then continue end local inOpen = false local existingNode = nil for _, openNode in ipairs(openSet) do if (openNode.position - neighbor.position).Magnitude < GRID_SIZE/2 then inOpen = true existingNode = openNode break end end if not inOpen then table.insert(openSet, neighbor) elseif neighbor.g < existingNode.g then existingNode.parent = currentNode existingNode.g = neighbor.g existingNode.f = existingNode.g + existingNode.h end end end return nil -- No path found end -- Path visualization function CustomPathfinding.visualizePath(path, parent) if not path then return end -- Clear previous visualization for _, child in ipairs(parent:GetChildren()) do if child.Name == "PathVisualization" then child:Destroy() end end local folder = Instance.new("Folder") folder.Name = "PathVisualization" folder.Parent = parent for i = 1, #path - 1 do local part = Instance.new("Part") part.Size = Vector3.new(0.2, 0.2, (path[i+1] - path[i]).Magnitude) part.CFrame = CFrame.new((path[i] + path[i+1])/2, path[i+1]) part.Anchored = true part.CanCollide = false part.Transparency = 0.5 part.Color = Color3.fromRGB(0, 255, 0) part.Name = "PathSegment" part.Parent = folder end end -- Main loop function CustomPathfinding.start(character) local RunService = game:GetService("RunService") local lastUpdate = 0 local currentPath = nil RunService.Heartbeat:Connect(function(dt) lastUpdate = lastUpdate + dt if lastUpdate < 0.1 then return end -- Update 10 times per second lastUpdate = 0 local target = getNearestPlayer(character) if not target then return end local start = character:GetPivot().Position local targetPos = target:GetPivot().Position -- Only recalculate path if target moved significantly if not currentPath or (targetPos - currentPath[#currentPath]).Magnitude > GRID_SIZE * 2 then currentPath = CustomPathfinding.findPath(start, targetPos, character) if currentPath then CustomPathfinding.visualizePath(currentPath, character) end end end) end return CustomPathfinding -- LocalScript to be placed in StarterPlayerScripts local CustomPathfinding = require(script:WaitForChild("CustomPathfinding")) local Players = game:GetService("Players") local player = Players.LocalPlayer player.CharacterAdded:Connect(function(character) -- Wait for humanoid to exist local humanoid = character:WaitForChild("Humanoid") -- Start pathfinding CustomPathfinding.start(character) -- Follow path when it exists local currentPath = nil local currentTargetIndex = 1 game:GetService("RunService").Heartbeat:Connect(function() if not currentPath or currentTargetIndex > #currentPath then return end local targetPos = currentPath[currentTargetIndex] local myPos = character:GetPivot().Position -- Move towards current target point humanoid:MoveTo(targetPos) -- Check if reached current target point if (targetPos - myPos).Magnitude < 2 then currentTargetIndex = currentTargetIndex + 1 end end) -- Update path reference when new path is calculated script:GetPropertyChangedSignal("Path"):Connect(function() if script:GetAttribute("Path") then currentPath = script:GetAttribute("Path") currentTargetIndex = 1 end end) end) This implementation includes several optimizations: 1. Grid-based A* algorithm with configurable grid size 2. Diagonal movement support 3. Dynamic path updating only when needed 4. Efficient collision checking 5. Visual path debugging 6. Throttled updates to reduce lag To use this: 1. Place both scripts in StarterPlayerScripts 2. The CustomPathfinding module will handle path calculation 3. The PathfindingController will make the character follow the path