OPEN SOURCE ESP

 Players = :()
 RunService = :()
 LocalPlayer = Players.LocalPlayer
 Camera = .CurrentCamera
 ESP = {
    players = {}
}
 SHOW_DISTANCE = 
 SHOW_NAMES = 
 SHOW_BOXES = 
 SHOW_TRACERS = 
 MAX_DISTANCE = 
 previousPositions = {}
 ESP:(, properties)
     drawing = .()
     prop, value  (properties) 
        drawing[prop] = value
    
     drawing

 ESP:(player)
     player == LocalPlayer   
    
     drawings = {
        boxTL = self:(, {Thickness = }), 
        boxTR = self:(, {Thickness = }),
        boxBL = self:(, {Thickness = }), 
        boxBR = self:(, {Thickness = }), 
        boxTLv = self:(, {Thickness = }), 
        boxTRv = self:(, {Thickness = }), 
        boxBLv = self:(, {Thickness = }),
        boxBRv = self:(, {Thickness = }), 
        tracer = self:(, {Thickness = }),
        name = self:(, {
            Size = ,
            Center = ,
            Outline = , 
            Font =  
        })
    }
    
    self.players[player] = drawings


 ESP:(player)
     drawings = self.players[player]
     drawings 
         _, drawing  (drawings) 
            drawing:()
        
        self.players[player] = 
    
    previousPositions[(player.UserId)] = 


 ESP:(player)
     isTeammate = 
     teamName = 
     color = .(, , )
    
     player.Team 
         player.Team == LocalPlayer.Team   player.Neutral 
            isTeammate = 
            teamName = 
            color = .(, , )
        
            teamName = player.Team.Name  
        
    
    
     .(player.Name) ==   .(.(player.Name), ) 
        teamName = 
        color = .(, , )
     .(.(player.Name), ) 
        teamName =  
        color = .(, , )
    
    
     isTeammate, teamName, color


 ESP:(character)
     rootPart = character:()
     head = character:()
    
      rootPart   head 
         ,  
    
    
     minX, maxX, minY, maxY, minZ, maxZ = rootPart.Position.X, rootPart.Position.X, rootPart.Position.Y, rootPart.Position.Y, rootPart.Position.Z, rootPart.Position.Z
    
     _, part  (character:()) 
         part:() 
             partPos = part.Position
             partSize = part.Size
            minX = .(minX, partPos.X - partSize.X/)
            maxX = .(maxX, partPos.X + partSize.X/)
            minY = .(minY, partPos.Y - partSize.Y/)
            maxY = .(maxY, partPos.Y + partSize.Y/)
        
    
    
     width = (maxX - minX) * 
     height = (maxY - minY) * 
    
    width = .(width, , )
    height = .(height, , )
    
     width, height


 ESP:()
     player, drawings  (self.players) 
         character = player.Character
          character 
             _, drawing  (drawings) 
                drawing.Visible = 
            
            
        
        
         humanoid = character:()
         head = character:()
         rootPart = character:()
        
          humanoid   head   rootPart  humanoid.Health <=  
             _, drawing  (drawings) 
                drawing.Visible = 
            
            
        
        
         currentPos = rootPart.Position
         playerKey = (player.UserId)
        
          previousPositions[playerKey] 
            previousPositions[playerKey] = currentPos
        
        
         smoothFactor = 
         smoothedPos = previousPositions[playerKey] + (currentPos - previousPositions[playerKey]) * smoothFactor
        previousPositions[playerKey] = smoothedPos
        
         headPos, headVisible = Camera:(head.Position)
         rootPos, rootVisible = Camera:(smoothedPos)
        
          headVisible   rootVisible 
             _, drawing  (drawings) 
                drawing.Visible = 
            
            
        
        
         distance = (LocalPlayer.Character  LocalPlayer.Character:()) 
             (LocalPlayer.Character.HumanoidRootPart.Position - smoothedPos).Magnitude 
             
        
         distance > MAX_DISTANCE 
             _, drawing  (drawings) 
                drawing.Visible = 
            
            
        
        
         isTeammate, teamName, color = self:(player)
         boxWidth, boxHeight = self:(character)
         distanceScale = .( / (distance / ), , )
        boxWidth = boxWidth * distanceScale
        boxHeight = boxHeight * distanceScale
        boxWidth = .(boxWidth, )
        boxHeight = .(boxHeight, )
         boxPos = .(rootPos.X, rootPos.Y - boxHeight / )
         cornerLength = .(boxWidth * , , )
         SHOW_BOXES 
            drawings.boxTL.From = .(boxPos.X - boxWidth/, boxPos.Y - boxHeight/)
            drawings.boxTL.To = .(boxPos.X - boxWidth/ + cornerLength, boxPos.Y - boxHeight/)
            drawings.boxTL.Color = color
            drawings.boxTL.Visible = 
            
            drawings.boxTLv.From = .(boxPos.X - boxWidth/, boxPos.Y - boxHeight/)
            drawings.boxTLv.To = .(boxPos.X - boxWidth/, boxPos.Y - boxHeight/ + cornerLength)
            drawings.boxTLv.Color = color
            drawings.boxTLv.Visible = 
            
            drawings.boxTR.From = .(boxPos.X + boxWidth/, boxPos.Y - boxHeight/)
            drawings.boxTR.To = .(boxPos.X + boxWidth/ - cornerLength, boxPos.Y - boxHeight/)
            drawings.boxTR.Color = color
            drawings.boxTR.Visible = 
            
            drawings.boxTRv.From = .(boxPos.X + boxWidth/, boxPos.Y - boxHeight/)
            drawings.boxTRv.To = .(boxPos.X + boxWidth/, boxPos.Y - boxHeight/ + cornerLength)
            drawings.boxTRv.Color = color
            drawings.boxTRv.Visible = 
            
            drawings.boxBL.From = .(boxPos.X - boxWidth/, boxPos.Y + boxHeight/)
            drawings.boxBL.To = .(boxPos.X - boxWidth/ + cornerLength, boxPos.Y + boxHeight/)
            drawings.boxBL.Color = color
            drawings.boxBL.Visible = 
            
            drawings.boxBLv.From = .(boxPos.X - boxWidth/, boxPos.Y + boxHeight/)
            drawings.boxBLv.To = .(boxPos.X - boxWidth/, boxPos.Y + boxHeight/ - cornerLength)
            drawings.boxBLv.Color = color
            drawings.boxBLv.Visible = 
            
            drawings.boxBR.From = .(boxPos.X + boxWidth/, boxPos.Y + boxHeight/)
            drawings.boxBR.To = .(boxPos.X + boxWidth/ - cornerLength, boxPos.Y + boxHeight/)
            drawings.boxBR.Color = color
            drawings.boxBR.Visible = 
            
            drawings.boxBRv.From = .(boxPos.X + boxWidth/, boxPos.Y + boxHeight/)
            drawings.boxBRv.To = .(boxPos.X + boxWidth/, boxPos.Y + boxHeight/ - cornerLength)
            drawings.boxBRv.Color = color
            drawings.boxBRv.Visible = 
        
        
         SHOW_TRACERS 
            drawings.tracer.From = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y)
            drawings.tracer.To = .(boxPos.X, boxPos.Y + boxHeight/)
            drawings.tracer.Color = color
            drawings.tracer.Visible = 
        
        
         SHOW_NAMES 
             displayText = player.Name
             SHOW_DISTANCE 
                displayText = .(, player.Name, .(distance))
            
            displayText = displayText ..  .. teamName
            
            drawings.name.Position = .(boxPos.X, boxPos.Y - boxHeight/ - )
            drawings.name.Text = displayText
            drawings.name.Color = .(, , ) 
            drawings.name.Visible = 
        
    


 ESP:()
    self.players = {}
    
     _, player  (Players:()) 
         player ~= LocalPlayer 
            self:(player)
        
    
    
    Players.PlayerAdded:((player)
         player ~= LocalPlayer 
            self:(player)
        
    )
    
    Players.PlayerRemoving:((player)
        self:(player)
    )
    
     frameCount = 
    RunService.RenderStepped:(()
        frameCount = frameCount + 
         frameCount %  ==   
            self:()
        
    )

ESP:()
()
()