OPEN SOURCED Aimlock and ESP FOR

 Players = :()
 UserInputService = :()
 Camera = .CurrentCamera
 LocalPlayer = Players.LocalPlayer


 screenGui = .()
screenGui.Name = 
screenGui.Parent = :() 


 madeByLabel = .()
madeByLabel.Name = 
madeByLabel.Size = .(, , , )
madeByLabel.Position = .(, , , )
madeByLabel.Text = 
madeByLabel.TextColor3 = .(, , )
madeByLabel.Font = .Font.GothamBold 
madeByLabel.TextSize = 
madeByLabel.TextScaled = 
madeByLabel.BackgroundTransparency = 
madeByLabel.BackgroundColor3 = .(, , )
madeByLabel.TextStrokeTransparency = 
madeByLabel.TextStrokeColor3 = .(, , )
madeByLabel.Parent = screenGui


 gradient = .()
gradient.Parent = madeByLabel
gradient.Color = ColorSequence.({
    ColorSequenceKeypoint.(, .(, , )),
    ColorSequenceKeypoint.(, .(, , )),
    ColorSequenceKeypoint.(, .(, , ))
})
gradient.Rotation = 

 corner = .()
corner.CornerRadius = .(, )
corner.Parent = madeByLabel

 shadow = .()
shadow.Name = 
shadow.Size = madeByLabel.Size + .(, , , )
shadow.Position = madeByLabel.Position + .(, , , )
shadow.BackgroundColor3 = .(, , )
shadow.BackgroundTransparency = 
shadow.ZIndex = madeByLabel.ZIndex - 
shadow.Parent = screenGui

 shadowCorner = .()
shadowCorner.CornerRadius = .(, )
shadowCorner.Parent = shadow


 tweenService = :()
 tweenInfo = TweenInfo.(, .EasingStyle.Bounce, .EasingDirection.Out, , , )
 goal = {Size = .(, , , ), TextTransparency = }
 tween = tweenService:(madeByLabel, tweenInfo, goal)
tween:()


 fadeOutTweenInfo = TweenInfo.(, .EasingStyle.Linear, .EasingDirection.Out, , , )
 fadeOutGoal = {TextTransparency = }
 fadeOutTween = tweenService:(madeByLabel, fadeOutTweenInfo, fadeOutGoal)
 fadeOutGoalBackground = {BackgroundTransparency = }
 fadeOutTweenBackground = tweenService:(madeByLabel, fadeOutTweenInfo, fadeOutGoalBackground)

()
fadeOutTween:()
fadeOutTweenBackground:()

fadeOutTween.Completed:(()
    madeByLabel:()
)

fadeOutTweenBackground.Completed:(()
    shadow:()
)


 followButton = .()
followButton.Name = 
followButton.Size = .(, , , )
followButton.Position = .(, , , )
followButton.Text = 
followButton.TextColor3 = .(, , )
followButton.Font = .Font.GothamBold 
followButton.TextScaled = 
followButton.TextStrokeTransparency = 
followButton.TextStrokeColor3 = .(, , )
followButton.Parent = screenGui


 gradientButton = .()
gradientButton.Parent = followButton
gradientButton.Color = ColorSequence.({
    ColorSequenceKeypoint.(, .(, , )),
    ColorSequenceKeypoint.(, .(, , ))
})
gradientButton.Rotation = 

 cornerButton = .()
cornerButton.CornerRadius = .(, )
cornerButton.Parent = followButton

 shadowButton = .()
shadowButton.Name = 
shadowButton.Size = followButton.Size + .(, , , )
shadowButton.Position = followButton.Position + .(, , , )
shadowButton.BackgroundColor3 = .(, , )
shadowButton.BackgroundTransparency = 
shadowButton.ZIndex = followButton.ZIndex - 
shadowButton.Parent = screenGui

 shadowButtonCorner = .()
shadowButtonCorner.CornerRadius = .(, )
shadowButtonCorner.Parent = shadowButton


 isFollowingEnabled = 

followButton.MouseButton1Click:(()
    isFollowingEnabled =  isFollowingEnabled
     isFollowingEnabled 
        followButton.Text = 
        followButton.BackgroundColor3 = .(, , ) 
    
        followButton.Text = 
        followButton.BackgroundColor3 = .(, , ) 
    
)


 isRightMouseHeld = 
 targetPlayer = 


UserInputService.InputBegan:((input)
     input.UserInputType == .UserInputType.MouseButton2  isFollowingEnabled 
        isRightMouseHeld = 

        
         closestPlayer = 
         closestDistance = .huge

         _, player  (Players:()) 
             player ~= LocalPlayer  player.Character  player.Character:() 
                 head = player.Character.Head
                 headScreenPosition, onScreen = Camera:(head.Position)

                 onScreen 
                     mousePosition = UserInputService:()
                     distance = (.(headScreenPosition.X, headScreenPosition.Y) - mousePosition).Magnitude
                     distance < closestDistance 
                        closestDistance = distance
                        closestPlayer = player
                    
                
            
        

        targetPlayer = closestPlayer
    
)


UserInputService.InputEnded:((input)
     input.UserInputType == .UserInputType.MouseButton2 
        isRightMouseHeld = 
        targetPlayer = 
    
)


:().RenderStepped:(()
     isRightMouseHeld  targetPlayer  targetPlayer.Character 
         head = targetPlayer.Character:()
         head 
            Camera.CFrame = .(Camera.CFrame.Position, head.Position)
        
            targetPlayer = 
        
    
)












 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 = 
        }),
        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.DistanceLabel.Text = .(, distanceFromPlayer)
            components.DistanceLabel.Position = .(hrpPosition.X, hrpPosition.Y + height /  + )
            components.DistanceLabel.Visible = 

            
            components.NameLabel.Text = .(, player.DisplayName)
            components.NameLabel.Position = .(hrpPosition.X, hrpPosition.Y - height /  - )
            components.NameLabel.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.DistanceLabel.Visible = 
    components.NameLabel.Visible = 

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


 ESP:(player)
     components = self.espCache[player]
     components 
        components.Box:()
        components.DistanceLabel:()
        components.NameLabel:()
         _, 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)
)