Universal esp open src

 Players = :()
 RunService = :()
 Camera = .CurrentCamera


 LocalPlayer = Players.LocalPlayer
 LocalCharacter = LocalPlayer  LocalPlayer.Character  LocalPlayer.CharacterAdded:()
 LocalHumanoidRootPart = LocalCharacter:()

 ESP = {}
ESP.__index = ESP

 ESP.()
     self = ({}, ESP)
    self.espCache = {}
     self


 ESP:(, properties)
     drawing = .()
     prop, val  (properties) 
        drawing[prop] = val
    
     drawing


 ESP:()
     {
        Box = self:(, {
            Thickness = ,
            Transparency = ,
            Color = .(, , ),
            Filled = 
        }),
        Tracer = self:(, {
            Thickness = ,
            Transparency = ,
            Color = .(, , )
        }),
        DistanceLabel = self:(, {
            Size = ,
            Center = ,
            Outline = ,
            Color = .(, , ),
            OutlineColor = .(, , )
        }),
        NameLabel = self:(, {
            Size = ,
            Center = ,
            Outline = ,
            Color = .(, , ),
            OutlineColor = .(, , )
        }),
        HealthBar = {
            Outline = self:(, {
                Thickness = ,
                Transparency = ,
                Color = .(, , ),
                Filled = 
            }),
            Health = self:(, {
                Thickness = ,
                Transparency = ,
Color = .(, , ),
                Filled = 
            })
        },
        ItemLabel = self:(, {
            Size = ,
            Center = ,
            Outline = ,
            Color = .(, , ),
            OutlineColor = .(, , )
        }),
        SkeletonLines = {}
    }


 bodyConnections = {
    R15 = {
        {, },
        {, },
        {, },
        {, },
        {, },
        {, },
        {, },
        {, },
        {, },
        {, },
        {, },
        {, },
        {, },
        {, }
    },
    R6 = {
        {, },
        {, },
        {, },
        {, },
        {, }
    }
}

 ESP:(components, character, player)
     hrp = character:()
     humanoid = character:()

     hrp  humanoid 
         hrpPosition, onScreen = Camera:(hrp.Position)
         mousePosition = Camera:(LocalPlayer:().Hit.p)

         onScreen 
             screenWidth, screenHeight = Camera.ViewportSize.X, Camera.ViewportSize.Y
             factor =  / (hrpPosition.Z * .(.(Camera.FieldOfView * )) * ) * 
             width, height = .(screenHeight /  * factor), .(screenWidth /  * factor)
             distanceFromPlayer = .((LocalHumanoidRootPart.Position - hrp.Position).magnitude)

            components.Box.Size = .(width, height)
            components.Box.Position = .(hrpPosition.X - width / , hrpPosition.Y - height / )
            components.Box.Visible = 

            
            components.Tracer.From = .(mousePosition.X, mousePosition.Y)
            components.Tracer.To = .(hrpPosition.X, hrpPosition.Y + height / )
            components.Tracer.Visible = 

            
            components.DistanceLabel.Text = .(, distanceFromPlayer)
            components.DistanceLabel.Position = .(hrpPosition.X, hrpPosition.Y + height /  + )
            components.DistanceLabel.Visible = 

            
            components.NameLabel.Text = .(, player.Name)
            components.NameLabel.Position = .(hrpPosition.X, hrpPosition.Y - height /  - )
            components.NameLabel.Visible = 

            
             healthBarHeight = height
             healthBarWidth = 
             healthFraction = humanoid.Health / humanoid.MaxHealth

            components.HealthBar.Outline.Size = .(healthBarWidth, healthBarHeight)
            components.HealthBar.Outline.Position = .(components.Box.Position.X - healthBarWidth - , components.Box.Position.Y)
            components.HealthBar.Outline.Visible = 

            components.HealthBar.Health.Size = .(healthBarWidth - , healthBarHeight * healthFraction)
            components.HealthBar.Health.Position = .(components.HealthBar.Outline.Position.X + , components.HealthBar.Outline.Position.Y + healthBarHeight * ( - healthFraction))
            components.HealthBar.Health.Visible = 

            
             backpack = player.Backpack
 tool = backpack:()  character:()
             tool 
                components.ItemLabel.Text = .(, tool.Name)
            
                components.ItemLabel.Text = 
            
            components.ItemLabel.Position = .(hrpPosition.X, hrpPosition.Y + height /  + )
            components.ItemLabel.Visible = 

            
             connections = bodyConnections[humanoid.RigType.Name]  {}
             _, connection  (connections) 
                 partA = character:(connection[])
                 partB = character:(connection[])
                 partA  partB 
                     line = components.SkeletonLines[connection[] ..  .. connection[]]  self:(, {Thickness = , Color = .(, , )})
                     posA, onScreenA = Camera:(partA.Position)
                     posB, onScreenB = Camera:(partB.Position)
                     onScreenA  onScreenB 
                        line.From = .(posA.X, posA.Y)
                        line.To = .(posB.X, posB.Y)
                        line.Visible = 
                        components.SkeletonLines[connection[] ..  .. connection[]] = line
                    
                        line.Visible = 
                    
                
            
        
            self:(components)
        
    
        self:(components)
    


 ESP:(components)
    components.Box.Visible = 
    components.Tracer.Visible = 
    components.DistanceLabel.Visible = 
    components.NameLabel.Visible = 
    components.HealthBar.Outline.Visible = 
    components.HealthBar.Health.Visible = 
    components.ItemLabel.Visible = 

     _, line  (components.SkeletonLines) 
        line.Visible = 
    


 ESP:(player)
     components = self.espCache[player]
     components 
        components.Box:()
        components.Tracer:()
        components.DistanceLabel:()
        components.NameLabel:()
        components.HealthBar.Outline:()
        components.HealthBar.Health:()
        components.ItemLabel:()
         _, line  (components.SkeletonLines) 
            line:()
        
        self.espCache[player] = 
    


 espInstance = ESP.()

RunService.RenderStepped:(()
     _, player  (Players:()) 
         player ~= LocalPlayer 
             character = player.Character
             character 
                  espInstance.espCache[player] 
                    espInstance.espCache[player] = espInstance:()
                
                espInstance:(espInstance.espCache[player], character, player)
            
                 espInstance.espCache[player] 
                    espInstance:(espInstance.espCache[player])
                
            
        
    
)

Players.PlayerRemoving:((player)
    espInstance:(player)
)