MOBILE READY XENO READY AIMBOT ESP SOURCE CODE

 UI = (:())()

 Players = :()
 RunService = :()
 UserInputService = :()
 Workspace = :()

 LocalPlayer = Players.LocalPlayer
 Camera = Workspace.CurrentCamera

 IsMobile = UserInputService.TouchEnabled   UserInputService.KeyboardEnabled

 Config = {
    ESP_Enabled = ,
    ESP_Box = ,
    ESP_Name = ,
    ESP_Distance = ,
    ESP_Health = ,
    ESP_Skeleton = ,
    ESP_TeamCheck = ,
    ESP_MaxDistance = ,
    ESP_BoxColor = .(, , ),
    
    AIM_Enabled = ,
    AIM_FOV = IsMobile    ,
    AIM_Smooth = ,
    AIM_TeamCheck = ,
    AIM_TargetPart = ,
    AIM_ShowFOV = ,
    AIM_Sticky = ,
    AIM_StickyTime = 
}

 Bones = {{,},{,},{,},{,},{,}}

 State = {
    Unloaded = ,
    AimTarget = ,
    AimTargetChar = ,
    LastTargetSwitch = ,
    Aiming = ,
    MobileAiming = ,
    MobileAimToggled = ,
    AimHoldMode = 
}

 Cache = {
    Targets = {},
    ESP = {},
    Visibility = {}
}

 Connections = {}

  (char)
     char  char:()


  (char)
     char  char:()


  (char)
     char  char:()


  (char)
     hum = (char)
     hum  hum.Health > 


  (char)
      LocalPlayer.Character    
      char   char.Parent    
     localParent = LocalPlayer.Character.Parent
     charParent = char.Parent
      localParent   charParent    
     localParent == charParent


  (char)
      char   char.Parent    
     parentName = char.Parent.Name:()
     parentName:()  parentName:()  parentName:() 
         
    
     


  (position)
     char = LocalPlayer.Character
     root = (char)
      root   .huge 
     (position - root.Position).Magnitude


  (position)
     cam = Workspace.CurrentCamera
      cam   .(, ), ,  
     screenPos, onScreen = cam:(position)
     .(screenPos.X, screenPos.Y), onScreen, screenPos.Z


  (char)
      char    
     cam = Camera
      cam    
     origin = cam.CFrame.Position
     rayParams = RaycastParams.()
    rayParams.FilterType = .RaycastFilterType.Exclude
     filter = {cam}
     LocalPlayer.Character  .(filter, LocalPlayer.Character) 
    .(filter, char)
    rayParams.FilterDescendantsInstances = filter
    
     head = (char)
     head 
         dir = (head.Position - origin)
         result = Workspace:(origin, dir.Unit * dir.Magnitude, rayParams)
          result  (result.Position - head.Position).Magnitude <  
             
        
    
     


  ()
     new = {}
     myChar = LocalPlayer.Character
     _, obj  (Workspace:()) 
         obj.Name ==   obj:() 
             parent = obj.Parent
             parent  parent ~= myChar  obj.Position.Y > - 
                 (parent)   
                 hum = (parent)
                 hum  hum.Health >  
                    new[parent] = obj
                
            
        
    
    Cache.Targets = new


 ESP = {}

 ESP.()
     drawings = {
        Box = {.(), .(), .(), .()},
        Name = .(),
        Distance = .(),
        HealthBg = .(),
        HealthBar = .(),
        Skeleton = {}
    }
    
     i = ,  
        drawings.Skeleton[i] = .()
        drawings.Skeleton[i].Thickness = 
        drawings.Skeleton[i].Visible = 
    
    
     _, line  (drawings.Box) 
        line.Thickness = 
        line.Visible = 
    
    
    drawings.Name.Size = IsMobile    
    drawings.Name.Font = .Fonts.Monospace
    drawings.Name.Center = 
    drawings.Name.Outline = 
    drawings.Name.Visible = 
    
    drawings.Distance.Size = IsMobile    
    drawings.Distance.Font = .Fonts.Monospace
    drawings.Distance.Center = 
    drawings.Distance.Outline = 
    drawings.Distance.Visible = 
    
    drawings.HealthBg.Thickness = IsMobile    
    drawings.HealthBg.Color = .(, , )
    drawings.HealthBg.Visible = 
    
    drawings.HealthBar.Thickness = IsMobile    
    drawings.HealthBar.Visible = 
    
     drawings


 ESP.(char)
      Cache.ESP[char] 
        Cache.ESP[char] = ESP.()
    
     Cache.ESP[char]


 ESP.(drawings)
      drawings   
     _, line  (drawings.Box)  line.Visible =  
    drawings.Name.Visible = 
    drawings.Distance.Visible = 
    drawings.HealthBg.Visible = 
    drawings.HealthBar.Visible = 
     _, line  (drawings.Skeleton)  line.Visible =  


 ESP.(drawings)
      drawings   
    (()
         _, line  (drawings.Box)  line:() 
        drawings.Name:()
        drawings.Distance:()
        drawings.HealthBg:()
        drawings.HealthBar:()
         _, line  (drawings.Skeleton)  line:() 
    )


 ESP.(char, root)
     drawings = ESP.(char)
    
      Config.ESP_Enabled 
        ESP.(drawings)
        
    
    
      (char) 
        ESP.(drawings)
        
    
    
     Config.ESP_TeamCheck  (char) 
        ESP.(drawings)
        
    
    
     distance = (root.Position)
     distance > Config.ESP_MaxDistance 
        ESP.(drawings)
        
    
    
     head = (char)
     headPos = head  head.Position  (root.Position + .(, , ))
     feetPos = root.Position - .(, , )
    
     rootScreen, onScreen, depth = (root.Position)
     headScreen = (headPos + .(, , ))
     feetScreen = (feetPos)
    
      onScreen  depth <=  
        ESP.(drawings)
        
    
    
     visible = Cache.Visibility[char]  
     color = visible  .(, , )  Config.ESP_BoxColor
    
     boxHeight = .(feetScreen.Y - headScreen.Y)
     boxWidth = boxHeight * 
     cx = rootScreen.X
    
     Config.ESP_Box 
        drawings.Box[].From = .(cx - boxWidth/, headScreen.Y)
        drawings.Box[].To = .(cx + boxWidth/, headScreen.Y)
        drawings.Box[].From = .(cx + boxWidth/, headScreen.Y)
        drawings.Box[].To = .(cx + boxWidth/, feetScreen.Y)
        drawings.Box[].From = .(cx + boxWidth/, feetScreen.Y)
        drawings.Box[].To = .(cx - boxWidth/, feetScreen.Y)
        drawings.Box[].From = .(cx - boxWidth/, feetScreen.Y)
        drawings.Box[].To = .(cx - boxWidth/, headScreen.Y)
         _, line  (drawings.Box) 
            line.Color = color
            line.Visible = 
        
    
         _, line  (drawings.Box)  line.Visible =  
    
    
     Config.ESP_Name 
         name = char.Name
         _, p  (Players:()) 
             p.Character == char  name = p.Name;  
        
        drawings.Name.Text = name
        drawings.Name.Position = .(cx, headScreen.Y - )
        drawings.Name.Color = color
        drawings.Name.Visible = 
    
        drawings.Name.Visible = 
    
    
     Config.ESP_Distance 
        drawings.Distance.Text = .(distance) .. 
        drawings.Distance.Position = .(cx, feetScreen.Y + )
        drawings.Distance.Color = .(, , )
        drawings.Distance.Visible = 
    
        drawings.Distance.Visible = 
    
    
     Config.ESP_Health 
         hum = (char)
         hum 
             pct = .(hum.Health / hum.MaxHealth, , )
             barX = cx - boxWidth/ - 
             barHeight = boxHeight * pct
            
            drawings.HealthBg.From = .(barX, headScreen.Y)
            drawings.HealthBg.To = .(barX, feetScreen.Y)
            drawings.HealthBg.Visible = 
            
             healthColor = pct >   .(, , )  pct >   .(, , )  .(, , )
            drawings.HealthBar.From = .(barX, feetScreen.Y - barHeight)
            drawings.HealthBar.To = .(barX, feetScreen.Y)
            drawings.HealthBar.Color = healthColor
            drawings.HealthBar.Visible = 
        
            drawings.HealthBg.Visible = 
            drawings.HealthBar.Visible = 
        
    
        drawings.HealthBg.Visible = 
        drawings.HealthBar.Visible = 
    
    
     Config.ESP_Skeleton 
         skelColor = visible  .(, , )  .(, , )
         i, bone  (Bones) 
             p1 = char:(bone[])
             p2 = char:(bone[])
             p1  p2 
                 s1, o1 = (p1.Position)
                 s2, o2 = (p2.Position)
                 o1  o2 
                    drawings.Skeleton[i].From = s1
                    drawings.Skeleton[i].To = s2
                    drawings.Skeleton[i].Color = skelColor
                    drawings.Skeleton[i].Visible = 
                
                    drawings.Skeleton[i].Visible = 
                
            
                drawings.Skeleton[i].Visible = 
            
        
    
         _, line  (drawings.Skeleton)  line.Visible =  
    


 Radar = {}
Radar.Frame = 
Radar.Dots = {}
Radar.Size = 
Radar.Range = 
Radar.Enabled = 

 Radar.()
     ScreenGui = :().LocalPlayer:()
      ScreenGui 
        ScreenGui = :()
    
    
     radarFrame = .()
    radarFrame.Name = 
    radarFrame.BackgroundColor3 = .(, , )
    radarFrame.BorderSizePixel = 
    radarFrame.Position = .(, , , -)
    radarFrame.Size = .(, Radar.Size, , Radar.Size)
    radarFrame.ZIndex = 
    
    (()
        radarFrame.Parent = :()
    )
      radarFrame.Parent 
        radarFrame.Parent = :().LocalPlayer.PlayerGui
    
    
     corner = .()
    corner.CornerRadius = .(, )
    corner.Parent = radarFrame
    
     stroke = .()
    stroke.Color = .(, , )
    stroke.Thickness = 
    stroke.Parent = radarFrame
    
     cross1 = .()
    cross1.BackgroundColor3 = .(, , )
    cross1.BorderSizePixel = 
    cross1.Size = .(, , , )
    cross1.Position = .(, , , )
    cross1.ZIndex = 
    cross1.Parent = radarFrame
    
     cross2 = .()
    cross2.BackgroundColor3 = .(, , )
    cross2.BorderSizePixel = 
    cross2.Size = .(, , , )
    cross2.Position = .(, , , )
    cross2.ZIndex = 
    cross2.Parent = radarFrame
    
     center = .()
    center.BackgroundColor3 = .(, , )
    center.BorderSizePixel = 
    center.Size = .(, , , )
    center.Position = .(, -, , -)
    center.ZIndex = 
    center.Parent = radarFrame
    
     centerCorner = .()
    centerCorner.CornerRadius = .(, )
    centerCorner.Parent = center
    
    Radar.Frame = radarFrame
    
     i = ,  
         dot = .()
        dot.Name =  .. i
        dot.BackgroundColor3 = .(, , )
        dot.BorderSizePixel = 
        dot.Size = .(, , , )
        dot.Visible = 
        dot.ZIndex = 
        dot.Parent = radarFrame
        
         dotCorner = .()
        dotCorner.CornerRadius = .(, )
        dotCorner.Parent = dot
        
        Radar.Dots[i] = dot
    


 Radar.()
      Radar.Enabled   Radar.Frame 
         Radar.Frame  Radar.Frame.Visible =  
        
    
    
    Radar.Frame.Visible = 
    Radar.Frame.Size = .(, Radar.Size, , Radar.Size)
    
     myChar = LocalPlayer.Character
      myChar   
    
     myRoot = (myChar)
      myRoot   
    
     cam = Camera
      cam   
    
     myPos = myRoot.Position
     camLook = cam.CFrame.LookVector
     angle = .(camLook.X, camLook.Z)
    
     dotIndex = 
     char, root  (Cache.Targets) 
         dotIndex > #Radar.Dots   
          root   root.Parent   
        
         offset = root.Position - myPos
         dist = .(offset.X * offset.X + offset.Z * offset.Z)
        
         dist <= Radar.Range 
             rotatedX = offset.X * .(-angle) - offset.Z * .(-angle)
             rotatedZ = offset.X * .(-angle) + offset.Z * .(-angle)
            
             scale = Radar.Size / (Radar.Range * )
             screenX = rotatedX * scale
             screenY = -rotatedZ * scale
            
             dot = Radar.Dots[dotIndex]
            dot.Position = .(, screenX - , , screenY - )
            
             visible = Cache.Visibility[char]  
            dot.BackgroundColor3 = visible  .(, , )  .(, , )
            dot.Visible = 
            
            dotIndex = dotIndex + 
        
    
    
     i = dotIndex, #Radar.Dots 
        Radar.Dots[i].Visible = 
    


 Radar.()
     Radar.Frame 
        (() Radar.Frame:() )
        Radar.Frame = 
    
    Radar.Dots = {}


 Aimbot = {}

 FOVCircle = 
 TargetCircle = 

  ()
     FOVCircle   
    
     success = (()
        FOVCircle = .()
        FOVCircle.Thickness = 
        FOVCircle.NumSides = 
        FOVCircle.Filled = 
        FOVCircle.Visible = 
        FOVCircle.Color = .(, , )
        FOVCircle.Transparency = 
        FOVCircle.Radius = 
        
         cam = Workspace.CurrentCamera
         cam 
             center = cam.ViewportSize / 
            FOVCircle.Position = .(center.X, center.Y)
        
        
        TargetCircle = .()
        TargetCircle.Thickness = 
        TargetCircle.NumSides = 
        TargetCircle.Filled = 
        TargetCircle.Visible = 
        TargetCircle.Color = .(, , )
        TargetCircle.Transparency = 
        TargetCircle.Radius = 
    )
    
     success  FOVCircle 
        UI.(, )
    


 Aimbot.()
      FOVCircle 
        ()
    
      FOVCircle   
    
     cam = Workspace.CurrentCamera
      cam   
    
     center = cam.ViewportSize / 
    FOVCircle.Position = .(center.X, center.Y)
    FOVCircle.Radius = Config.AIM_FOV
    FOVCircle.Visible = Config.AIM_ShowFOV
    
     Config.AIM_Enabled 
        FOVCircle.Color = .(, , )
    
        FOVCircle.Color = .(, , )
    
    
     TargetCircle 
        (()
             State.AimTarget  State.AimTarget.Parent  State.Aiming  Config.AIM_Enabled 
                 screenPos, onScreen = cam:(State.AimTarget.Position)
                 onScreen  screenPos.Z >  
                    TargetCircle.Position = .(screenPos.X, screenPos.Y)
                    TargetCircle.Visible = 
                
                    TargetCircle.Visible = 
                
            
                TargetCircle.Visible = 
            
        )
    


 Aimbot.(char)
     Config.AIM_TargetPart ==  
         (char)
     Config.AIM_TargetPart ==  
         char:()  (char)
    
     (char)


 Aimbot.()
     cam = Workspace.CurrentCamera
      cam   ,  
    
     screenCenter = cam.ViewportSize / 
     centerVec = .(screenCenter.X, screenCenter.Y)
     now = ()
    
     Config.AIM_Sticky  State.AimTargetChar 
         currentChar = State.AimTargetChar
         currentChar  currentChar.Parent  (currentChar) 
              (Config.AIM_TeamCheck  (currentChar)) 
                 targetPart = Aimbot.(currentChar)
                 targetPart  targetPart.Parent 
                     sp, onScreen = cam:(targetPart.Position)
                     onScreen  sp.Z >  
                         dist = (.(sp.X, sp.Y) - centerVec).Magnitude
                         dist < Config.AIM_FOV *  
                             targetPart, currentChar
                        
                    
                
            
        
        State.AimTargetChar = 
    
    
     bestTarget = 
     bestChar = 
     bestDist = .huge
    
     char, root  (Cache.Targets) 
          char   char.Parent   
          (char)   
         Config.AIM_TeamCheck  (char)   
        
         targetPart = Aimbot.(char)
          targetPart   targetPart.Parent   
        
         sp, onScreen = cam:(targetPart.Position)
          onScreen  sp.Z <=    
        
         screenDist = (.(sp.X, sp.Y) - centerVec).Magnitude
        
         screenDist <= Config.AIM_FOV  screenDist < bestDist 
            bestDist = screenDist
            bestTarget = targetPart
            bestChar = char
        
    
    
     bestTarget  bestChar ~= State.AimTargetChar 
        State.LastTargetSwitch = now
        State.AimTargetChar = bestChar
    
    
     bestTarget, bestChar


RunService:(, , ()
     State.Unloaded   
      Config.AIM_Enabled 
        State.Aiming = 
        
    
    
     cam = Workspace.CurrentCamera
      cam   
    
     keyDown = State.MobileAiming
    
      keyDown 
         rmb = UserInputService:(.UserInputType.MouseButton2)
        keyDown = rmb
    
    
      keyDown 
        State.Aiming = 
        
    
    
    State.Aiming = 
     target, targetChar = Aimbot.()
      target   target.Parent 
        State.AimTarget = 
        
    
    
    State.AimTarget = target
    
     camPos = cam.CFrame.Position
     targetPos = target.Position
    
     targetCF = .(camPos, targetPos)
    
     smoothAmount =  - Config.AIM_Smooth
    smoothAmount = .(smoothAmount, , )
    
     currentCF = cam.CFrame
     newCF = currentCF:(targetCF, smoothAmount)
    
    cam.CFrame = newCF
    
    (()
         vm = cam:()
         vm 
             cb = vm:()
             cb  cb.CFrame = newCF 
             hrp = vm:()
             hrp  hrp.CFrame = newCF 
        
    )
    
    (()
         net = .ReplicatedStorage:()
         net 
             lv = net:()
             lv  lv:(newCF.LookVector) 
        
    )
)

 lastRefresh = 
 lastVisRefresh = 

  ()
     State.Unloaded   
    
    Camera = Workspace.CurrentCamera
      Camera   
    
     now = ()
    
     now - lastRefresh >  
        lastRefresh = now
        ()
    
    
     now - lastVisRefresh >  
        lastVisRefresh = now
         char  (Cache.Targets) 
            Cache.Visibility[char] = (char)
        
    
    
     char  (Cache.ESP) 
          Cache.Targets[char] 
            ESP.(Cache.ESP[char])
            ESP.(Cache.ESP[char])
            Cache.ESP[char] = 
        
    
    
     char, root  (Cache.Targets) 
         root  root.Parent 
            ESP.(char, root)
        
    
    
    Aimbot.()
    Radar.()


  ()
     char, drawings  (Cache.ESP) 
        ESP.(drawings)
    
    Cache.ESP = {}
    
    (() FOVCircle:() )
    (() TargetCircle:() )
    
    Radar.()


  ()
     State.Unloaded   
    State.Unloaded = 
    
    State.MobileAiming = 
    State.MobileAimToggled = 
    State.Aiming = 
    
    (() RunService:() )
    
     _, conn  (Connections) 
        (() conn:() )
    
    Connections = {}
    
    ()
    
     AimBtn 
        (() AimBtn:() )
    
    
    (()
         cam = Workspace.CurrentCamera
         cam 
            cam.CameraType = .CameraType.Custom
        
    )
    
    UI.(, )


()
Aimbot.()

Radar.()

Connections.Render = RunService.RenderStepped:(MainLoop)

 IsMobile 
    UI.({ Title = , Subtitle = , Duration = , Fullscreen =  })

    UI.({ Title = , Subtitle = , Duration =  })

.()

 Window = UI.({
    Title = ,
    Subtitle = ,
    Theme = ,
    Size = IsMobile  .(, , , )  .(, , , ),
    ShowUserInfo = ,
    ShowActiveList =  IsMobile,
    Logo = UI.Logos.XanBar,
    ShowLogo = 
})

 AimbotTab = Window:(, UI.Icons.Aimbot)

AimbotTab:()

AimbotTab:(, { Default = , Flag = , ShowInActiveList =  }, (v)
    Config.AIM_Enabled = v
      v 
        State.MobileAiming = 
        State.MobileAimToggled = 
        State.Aiming = 
        State.AimTarget = 
        State.AimTargetChar = 
    
)

AimbotTab:(, {, }, (v)
    Config.AIM_TargetPart = v
)

AimbotTab:(, { Min = , Max = , Default = Config.AIM_FOV, Increment = , Suffix = , Flag =  }, (v)
    Config.AIM_FOV = v
     FOVCircle  FOVCircle.Radius = v 
)

AimbotTab:(, { Min = , Max = , Default = , Increment = , Flag =  }, (v)
    Config.AIM_Smooth = v
)

AimbotTab:(, )

AimbotTab:()

AimbotTab:(, { Default = , Flag =  }, (v)
    Config.AIM_ShowFOV = v
      FOVCircle  () 
     FOVCircle  FOVCircle.Visible = v 
)

AimbotTab:(, { Default = , Flag =  }, (v)
    Config.AIM_Sticky = v
)

AimbotTab:(, { Min = , Max = , Default = , Increment = , Suffix = , Flag =  }, (v)
    Config.AIM_StickyTime = v
)

AimbotTab:(, { Default = , Flag =  }, (v)
    Config.AIM_TeamCheck = v
)

 ESPTab = Window:(, UI.Icons.ESP)

ESPTab:()

ESPTab:(, { Default = , Flag = , ShowInActiveList =  }, (v)
    Config.ESP_Enabled = v
)

ESPTab:(, { Default = UI.(, , ), Flag =  }, (color)
    Config.ESP_BoxColor = color
)

ESPTab:(, { Min = , Max = , Default = , Increment = , Suffix = , Flag =  }, (v)
    Config.ESP_MaxDistance = v
)

ESPTab:()

ESPTab:(, { Default = , Flag =  }, (v)
    Config.ESP_Box = v
)

ESPTab:(, { Default = , Flag =  }, (v)
    Config.ESP_Name = v
)

ESPTab:(, { Default = , Flag =  }, (v)
    Config.ESP_Distance = v
)

ESPTab:(, { Default = , Flag =  }, (v)
    Config.ESP_Health = v
)

ESPTab:(, { Default = , Flag =  }, (v)
    Config.ESP_Skeleton = v
)

ESPTab:()

ESPTab:(, { Default = , Flag =  }, (v)
    Config.ESP_TeamCheck = v
)

ESPTab:()

ESPTab:(, { Default = , Flag = , ShowInActiveList =  }, (v)
    Radar.Enabled = v
)

ESPTab:(, { Min = , Max = , Default = , Increment = , Suffix = , Flag =  }, (v)
    Radar.Size = v
)

ESPTab:(, { Min = , Max = , Default = , Increment = , Suffix = , Flag =  }, (v)
    Radar.Range = v
)

 MiscTab = Window:(, UI.Icons.Misc)

MiscTab:()

MiscTab:(, ()
    UI.(, )
    .()
    Window:()
    ()
)

 AimBtn = 

 IsMobile 
    AimBtn = UI.({ 
        Position = .(, -, , -),
        HoldMode = ,
        Callback = (state)
            State.MobileAimToggled = state
            State.MobileAiming = state
            State.Aiming = state
            
             state 
                UI.()
            
                State.AimTarget = 
                State.AimTargetChar = 
                UI.()
            
        
    })
    
    AimbotTab:()
    
    AimbotTab:(, {, }, (v)
         isHold = v == 
        State.AimHoldMode = isHold
         AimBtn  AimBtn.SetHoldMode 
            AimBtn:(isHold)
        
         isHold 
            State.MobileAimToggled = 
            State.MobileAiming = 
        
        UI.(v .. )
    )
    
    AimbotTab:(, { Default = , Flag =  }, (v)
         v 
            AimBtn:()
            UI.()
        
            AimBtn:()
            UI.()
        
    )
    
    AimbotTab:(, )
    
    UI.({ 
        Position = .(, -, , ), 
        Size = , 
        Icon = UI.Logos.XanBar, 
        Label = , 
        Draggable = , 
        Callback = () Window:()  
    })
    
     MobileTab = Window:(, UI.Icons.Settings)
    
    MobileTab:()
    
    MobileTab:(, { Default = , Flag =  }, (v) 
         AimBtn 
             v  AimBtn:()  AimBtn:()  
        
    )
    
    MobileTab:(, )
    
    UI.(, )

    Connections.InputBegan = UserInputService.InputBegan:((input, processed)
         processed   
         input.KeyCode == .KeyCode.Insert 
            Window:()
         input.KeyCode == .KeyCode.Home 
            Window:()
            ()
        
    )


UI.(, )