XENO COMPATIBLE AIM ESP CHAMS SOURCE CODE

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

 LocalPlayer = Players.LocalPlayer
 Mouse = LocalPlayer:()

 mousemoverel = mousemoverel  (Input  Input.MouseMove)  

 Config = {
    ESP_Enabled = ,
    ESP_Box = ,
    ESP_BoxStyle = ,
    ESP_Name = ,
    ESP_Distance = ,
    ESP_Tracer = ,
    ESP_DeadCheck = ,
    ESP_MaxDist = ,
    ESP_Chams = ,
    ESP_TeamCheck = ,
    ESP_Rainbow = ,
    
    RADAR_Enabled = ,
    RADAR_Size = ,
    RADAR_Range = ,
    
    AIM_Enabled = ,
    AIM_FOV = ,
    AIM_Smooth = ,
    AIM_ShowFOV = ,
    AIM_TargetPart = ,
    AIM_TeamCheck = ,
    
    MISC_Noclip = ,
    MISC_FullBright = ,
    
    MENU_Open = ,
    MENU_Tab = 
}

 Tuning = {
    CacheRate = ,
    CleanupRate = ,
    BoxRatio = ,
    CornerLen = ,
    RadarDotSize = 
}

 Palette = {
    Enemy = .(, , ),
    Dead = .(, , ),
    Tracer = .(, , ),
    
    RadarBg = .(, , ),
    RadarBorder = .(, , ),
    RadarGrid = .(, , ),
    RadarYou = .(, , ),
    
    MenuBg = .(, , ),
    MenuPanel = .(, , ),
    MenuBorder = .(, , ),
    MenuAccent = .(, , ),
    MenuText = .(, , ),
    MenuTextDim = .(, , ),
    MenuOn = .(, , ),
    MenuOff = .(, , ),
    MenuTab = .(, , ),
    MenuTabActive = .(, , ),
    
    FOV_Circle = .(, , ),
    FOV_Active = .(, , )
}

 State = {
    Unloaded = ,
    Aiming = ,
    RainbowHue = 
}

 OriginalLighting = {
    Brightness = Lighting.Brightness,
    Ambient = Lighting.Ambient
}

 DeathTracker = {}
 WeaponPatterns = {
    , , , , 
    , , , , , ,
    , , , , , , , , , 
}

 Connections = {}
 chamsObjects = {}

 UI = {}
UI.ScreenGui = .()
UI.ScreenGui.Name = 
UI.ScreenGui.ResetOnSpawn = 
UI.ScreenGui.ZIndexBehavior = .ZIndexBehavior.Sibling
UI.ScreenGui.DisplayOrder = 
UI.ScreenGui.IgnoreGuiInset = 

(() UI.ScreenGui.Parent = :() )
  UI.ScreenGui.Parent 
    UI.ScreenGui.Parent = LocalPlayer:()


  (obj)
      obj:()   ,  
     obj.Name ==    ,  
     obj.Name:()   ,  
    
     weaponPos = 
     isWeapon = 
    
     objNameLower = obj.Name:()
     _, pattern  (WeaponPatterns) 
         objNameLower:(pattern, , ) 
            isWeapon = 
            
        
    
    
      isWeapon 
         _, child  (obj:()) 
             childNameLower = child.Name:()
             _, pattern  (WeaponPatterns) 
                 childNameLower:(pattern, , ) 
                    isWeapon = 
                     child:() 
                        weaponPos = child.Position
                    
                    
                
            
             isWeapon   
        
    
    
     isWeapon   weaponPos 
         part = obj:(, )
         part  weaponPos = part.Position 
    
    
     isWeapon, weaponPos


  (position, radius)
     weapons = {}
     _, obj  (Workspace:()) 
         isWeapon, weaponPos = (obj)
         isWeapon  weaponPos  (weaponPos - position).Magnitude < radius 
            weapons[obj] = 
        
    
     weapons


  (position, knownWeapons, radius)
     _, obj  (Workspace:()) 
         isWeapon, weaponPos = (obj)
         isWeapon  weaponPos  (weaponPos - position).Magnitude < radius   knownWeapons[obj] 
             
        
    
     


  (model)
     root = model:()
      root    
    
     pos = root.Position
     now = ()
    
      DeathTracker[model] 
        DeathTracker[model] = {
            lastPos = pos, lastMoveTime = now, wasActive = ,
            isDead = , frozenTime = ,
            knownWeapons = (pos, ), lastWeaponCheck = now
        }
         
    
    
     data = DeathTracker[model]
     delta = (pos - data.lastPos)
     isMoving = .(delta.X, , delta.Z).Magnitude >   .(delta.Y) > 
    
     isMoving 
        data.lastMoveTime = now
        data.wasActive = 
        data.frozenTime = 
        data.knownWeapons = (pos, )
        data.lastWeaponCheck = now
        data.isDead = 
    
        data.frozenTime = now - data.lastMoveTime
    
    
      data.isDead  data.wasActive  data.frozenTime >   data.frozenTime <  
         now - data.lastWeaponCheck >  
            data.lastWeaponCheck = now
             (pos, data.knownWeapons, ) 
                data.isDead = 
            
        
    
    
    data.lastPos = pos
     data.isDead


  ()
     model, _  (DeathTracker) 
          model   model.Parent 
            DeathTracker[model] = 
        
    


  (model)
     myChar = LocalPlayer.Character
      myChar    
     model == myChar    
     myRoot = myChar:()
     modelRoot = model:()
     myRoot  modelRoot  (myRoot.Position - modelRoot.Position).Magnitude <  
         
    
     


  (model)
      model:()  model.Name ~=     
     (model)    
     Config.ESP_TeamCheck  model:()    
     


  (model)
     model:()


  ()
     .(State.RainbowHue, , )


  ()
     Config.ESP_Rainbow  ()  Palette.Enemy


 ESP = {
    cache = {},
    posCache = {},
    lastPosUpdate = ,
    lastCleanup = 
}

 ESP.(model)
     ESP.cache[model]   
    
     box = .()
    box.Name = 
    box.BackgroundTransparency = 
    box.BorderSizePixel = 
    box.Visible = 
    box.Parent = UI.ScreenGui
    
     boxStroke = .()
    boxStroke.Color = Palette.Enemy
    boxStroke.Thickness = 
    boxStroke.Parent = box
    
     corners = {}
     i = ,  
         c = .()
        c.Name =  .. i
        c.BackgroundColor3 = Palette.Enemy
        c.BorderSizePixel = 
        c.Visible = 
        c.Parent = UI.ScreenGui
        corners[i] = c
    
    
     name = .()
    name.Name = 
    name.BackgroundTransparency = 
    name.Font = .Font.RobotoMono
    name.TextSize = 
    name.TextColor3 = .(, , )
    name.TextStrokeTransparency = 
    name.Text = 
    name.Size = .(, , , )
    name.TextXAlignment = .TextXAlignment.Center
    name.Visible = 
    name.Parent = UI.ScreenGui
    
     dist = .()
    dist.Name = 
    dist.BackgroundTransparency = 
    dist.Font = .Font.RobotoMono
    dist.TextSize = 
    dist.TextColor3 = .(, , )
    dist.TextStrokeTransparency = 
    dist.Size = .(, , , )
    dist.TextXAlignment = .TextXAlignment.Center
    dist.Visible = 
    dist.Parent = UI.ScreenGui
    
     tracer = .()
    tracer.Name = 
    tracer.BackgroundColor3 = Palette.Tracer
    tracer.BorderSizePixel = 
    tracer.AnchorPoint = .(, )
    tracer.Visible = 
    tracer.Parent = UI.ScreenGui
    
     deadX1 = .()
    deadX1.Name = 
    deadX1.BackgroundColor3 = Palette.Dead
    deadX1.BorderSizePixel = 
    deadX1.Rotation = 
    deadX1.Visible = 
    deadX1.Parent = UI.ScreenGui
    
     deadX2 = .()
    deadX2.Name = 
    deadX2.BackgroundColor3 = Palette.Dead
    deadX2.BorderSizePixel = 
    deadX2.Rotation = -
    deadX2.Visible = 
    deadX2.Parent = UI.ScreenGui
    
    ESP.cache[model] = {
        Box = box, BoxStroke = boxStroke, Corners = corners,
        Name = name, Dist = dist, Tracer = tracer, DeadX1 = deadX1, DeadX2 = deadX2
    }


 ESP.(esp)
      esp   
    esp.Box.Visible = 
     _, c  (esp.Corners)  c.Visible =  
    esp.Name.Visible = 
    esp.Dist.Visible = 
    esp.Tracer.Visible = 
    esp.DeadX1.Visible = 
    esp.DeadX2.Visible = 


 ESP.(esp)
      esp   
    (() esp.Box:() )
     _, c  (esp.Corners)  (() c:() ) 
    (() esp.Name:() )
    (() esp.Dist:() )
    (() esp.Tracer:() )
    (() esp.DeadX1:() )
    (() esp.DeadX2:() )


 ESP.(esp, model, posData, cam, screenSize)
      esp   model   
    
     root = model:()
      root 
        ESP.(esp)
        
    
    
     rootPos = posData.pos
     dist = posData.dist
    
     dist > Config.ESP_MaxDist 
        ESP.(esp)
        
    
    
     rs = cam:(rootPos)
    
     rs.Z <=   rs.X < -  rs.X > screenSize.X +   rs.Y < -  rs.Y > screenSize.Y +  
        ESP.(esp)
        
    
    
     isDead = Config.ESP_DeadCheck  (model)  
     baseCol = isDead  Palette.Dead  ()
    
     baseSize =  / .(rs.Z, )
     boxHeight = .(baseSize, , screenSize.Y * )
     boxWidth = .(boxHeight * Tuning.BoxRatio, , screenSize.X * )
    
     cx, cy = rs.X, rs.Y
     boxTop = cy - boxHeight * 
     boxBottom = cy + boxHeight * 
     boxLeft = cx - boxWidth / 
     boxRight = cx + boxWidth / 
    
    esp.DeadX1.Visible = 
    esp.DeadX2.Visible = 
    
     isDead 
        esp.Box.Visible = 
         _, c  (esp.Corners)  c.Visible =  
        
         xSize = .(boxWidth, boxHeight) * 
        esp.DeadX1.Position = .(, cx - xSize, , cy - )
        esp.DeadX1.Size = .(, xSize * , , )
        esp.DeadX1.Visible = 
        esp.DeadX2.Position = .(, cx - xSize, , cy - )
        esp.DeadX2.Size = .(, xSize * , , )
        esp.DeadX2.Visible = 
        
        esp.Name.Text = 
        esp.Name.Position = .(, cx - , , cy - boxHeight *  - )
        esp.Name.TextColor3 = Palette.Dead
        esp.Name.Visible = 
        esp.Dist.Visible = 
        esp.Tracer.Visible = 
    
         Config.ESP_Box 
             Config.ESP_BoxStyle ==  
                 _, c  (esp.Corners)  c.Visible =  
                esp.Box.Position = .(, boxLeft, , boxTop)
                esp.Box.Size = .(, boxWidth, , boxHeight)
                esp.BoxStroke.Color = baseCol
                esp.Box.Visible = 
            
                esp.Box.Visible = 
                 cl = Tuning.CornerLen
                 corners = esp.Corners
                corners[].Position = .(, boxLeft, , boxTop)
                corners[].Size = .(, cl, , )
                corners[].Position = .(, boxLeft, , boxTop)
                corners[].Size = .(, , , cl)
                corners[].Position = .(, boxRight - cl, , boxTop)
                corners[].Size = .(, cl, , )
                corners[].Position = .(, boxRight - , , boxTop)
                corners[].Size = .(, , , cl)
                corners[].Position = .(, boxLeft, , boxBottom - )
                corners[].Size = .(, cl, , )
                corners[].Position = .(, boxLeft, , boxBottom - cl)
                corners[].Size = .(, , , cl)
                corners[].Position = .(, boxRight - cl, , boxBottom - )
                corners[].Size = .(, cl, , )
                corners[].Position = .(, boxRight - , , boxBottom - cl)
                corners[].Size = .(, , , cl)
                 _, c  (corners) 
                    c.BackgroundColor3 = baseCol
                    c.Visible = 
                
            
        
            esp.Box.Visible = 
             _, c  (esp.Corners)  c.Visible =  
        
        
         Config.ESP_Name 
            esp.Name.Text = 
            esp.Name.Position = .(, cx - , , boxTop - )
            esp.Name.TextColor3 = baseCol
            esp.Name.Visible = 
        
            esp.Name.Visible = 
        
        
         Config.ESP_Distance 
            esp.Dist.Text = .(dist) .. 
            esp.Dist.Position = .(, cx - , , boxBottom + )
            esp.Dist.Visible = 
        
            esp.Dist.Visible = 
        
        
         Config.ESP_Tracer 
            esp.Tracer.Position = .(, cx, , boxBottom)
            esp.Tracer.Size = .(, , , screenSize.Y - boxBottom)
            esp.Tracer.BackgroundColor3 = Palette.Tracer
            esp.Tracer.Visible = 
        
            esp.Tracer.Visible = 
        
    


 ESP.()
     myChar = LocalPlayer.Character
     myRoot = myChar  myChar:()
     myPos = myRoot  myRoot.Position  .zero
    
    ESP.posCache = {}
    
     _, model  (Workspace:()) 
         model:()  model.Name ==    (model) 
             root = model:()
             root 
                ESP.posCache[model] = {
                    pos = root.Position,
                    dist = (root.Position - myPos).Magnitude
                }
            
        
    


 ESP.()
     toRemove = {}
     model, esp  (ESP.cache) 
          model   model.Parent   model:() 
            ESP.(esp)
            ESP.(esp)
            toRemove[#toRemove + ] = model
        
    
     _, model  (toRemove) 
        ESP.cache[model] = 
        DeathTracker[model] = 
    
    ()


 ESP.(cam, screenSize)
     State.Unloaded   Config.ESP_Enabled 
         _, esp  (ESP.cache)  ESP.(esp) 
        
    
    
     now = ()
    
     now - ESP.lastCleanup > Tuning.CleanupRate 
        ESP.lastCleanup = now
        ESP.()
    
    
     now - ESP.lastPosUpdate > Tuning.CacheRate 
        ESP.lastPosUpdate = now
        ESP.()
    
    
     validModels = {}
    
     model, posData  (ESP.posCache) 
         model  model.Parent 
             Config.ESP_TeamCheck  model:() 
                 ESP.cache[model]  ESP.(ESP.cache[model]) 
            
                validModels[model] = 
                  ESP.cache[model] 
                    ESP.(model)
                
                ESP.(ESP.cache[model], model, posData, cam, screenSize)
            
        
    
    
     model, esp  (ESP.cache) 
          validModels[model]  ESP.(esp) 
    


 Chams = {}

 Chams.(model)
     chamsObjects[model]   
     h = .()
    h.Name = 
    h.Adornee = model
    h.DepthMode = .HighlightDepthMode.AlwaysOnTop
    h.FillColor = ()
    h.OutlineColor = .(, , )
    h.FillTransparency = 
    h.OutlineTransparency = 
    h.Parent = model
    chamsObjects[model] = h


 Chams.(model)
     h = chamsObjects[model]
      h   
     isDead = Config.ESP_DeadCheck  (model)  
    h.FillColor = isDead  Palette.Dead  ()
    h.OutlineColor = isDead  Palette.Dead  .(, , )
    h.Enabled = 


 Chams.(model)
     chamsObjects[model] 
        chamsObjects[model]:()
        chamsObjects[model] = 
    


 Chams.()
     model, _  (chamsObjects)  Chams.(model) 
    chamsObjects = {}


 Chams.()
     State.Unloaded   Config.ESP_Enabled   Config.ESP_Chams 
        Chams.()
        
    
    
     validModels = {}
     model, _  (ESP.posCache) 
         model  model.Parent  (model) 
            validModels[model] = 
              chamsObjects[model]  Chams.(model) 
            Chams.(model)
        
    
     model, _  (chamsObjects) 
          validModels[model]  Chams.(model) 
    


 radarDots = {}
 RadarFrame = .()
RadarFrame.Name = 
RadarFrame.BackgroundColor3 = Palette.RadarBg
RadarFrame.BackgroundTransparency = 
RadarFrame.BorderSizePixel = 
RadarFrame.AnchorPoint = .(, )
RadarFrame.Parent = UI.ScreenGui

 RadarStroke = .()
RadarStroke.Color = Palette.RadarBorder
RadarStroke.Thickness = 
RadarStroke.Parent = RadarFrame

 RadarCross1 = .()
RadarCross1.BackgroundColor3 = Palette.RadarGrid
RadarCross1.BorderSizePixel = 
RadarCross1.AnchorPoint = .(, )
RadarCross1.Parent = RadarFrame

 RadarCross2 = .()
RadarCross2.BackgroundColor3 = Palette.RadarGrid
RadarCross2.BorderSizePixel = 
RadarCross2.AnchorPoint = .(, )
RadarCross2.Parent = RadarFrame

 RadarCenter = .()
RadarCenter.BackgroundColor3 = Palette.RadarYou
RadarCenter.BorderSizePixel = 
RadarCenter.AnchorPoint = .(, )
RadarCenter.Size = .(, , , )
RadarCenter.Parent = RadarFrame
.(, RadarCenter).CornerRadius = .(, )

 i = ,  
     dot = .()
    dot.BackgroundColor3 = Palette.Enemy
    dot.BorderSizePixel = 
    dot.AnchorPoint = .(, )
    dot.Size = .(, Tuning.RadarDotSize, , Tuning.RadarDotSize)
    dot.Visible = 
    dot.Parent = RadarFrame
    .(, dot).CornerRadius = .(, )
    radarDots[i] = dot


  (cam)
      Config.RADAR_Enabled 
        RadarFrame.Visible = 
        
    
    
     myChar = LocalPlayer.Character
     myRoot = myChar  myChar:()
      myRoot 
        RadarFrame.Visible = 
        
    
    
     size = Config.RADAR_Size
    RadarFrame.Position = .(, -, , )
    RadarFrame.Size = .(, size, , size)
    RadarFrame.Visible = 
    
    RadarCross1.Position = .(, , , )
    RadarCross1.Size = .(, , , -)
    RadarCross2.Position = .(, , , )
    RadarCross2.Size = .(, -, , )
    RadarCenter.Position = .(, , , )
    
     myLook = cam.CFrame.LookVector
     myAngle = .(-myLook.X, -myLook.Z)
     cosA, sinA = .(myAngle), .(myAngle)
     scale = (size/ - ) / Config.RADAR_Range
    
     dotIdx = 
     model, posData  (ESP.posCache) 
         model  model.Parent  (model) 
             rx = posData.pos.X - myRoot.Position.X
             rz = posData.pos.Z - myRoot.Position.Z
             dist2D = .(rx^ + rz^)
            
             dist2D < Config.RADAR_Range  dotIdx <= #radarDots 
                 rotX = rx * cosA - rz * sinA
                 rotZ = rx * sinA + rz * cosA
                 radarX, radarY = rotX * scale, rotZ * scale
                 maxD = size/ - 
                 rDist = .(radarX^ + radarY^)
                 rDist > maxD 
                    radarX, radarY = radarX/rDist * maxD, radarY/rDist * maxD
                
                
                 dot = radarDots[dotIdx]
                dot.Position = .(, radarX, , radarY)
                dot.BackgroundColor3 = (Config.ESP_DeadCheck  (model))  Palette.Dead  ()
                dot.Visible = 
                dotIdx = dotIdx + 
            
        
    
     i = dotIdx, #radarDots  radarDots[i].Visible =  


 FOVCircle = .()
FOVCircle.BackgroundTransparency = 
FOVCircle.BorderSizePixel = 
FOVCircle.AnchorPoint = .(, )
FOVCircle.Parent = UI.ScreenGui
 FOVStroke = .()
FOVStroke.Color = Palette.FOV_Circle
FOVStroke.Thickness = 
FOVStroke.Parent = FOVCircle
.(, FOVCircle).CornerRadius = .(, )

 Aimbot = { currentTarget = , lastTargetTime =  }

 Aimbot.(cam)
     best, bestScore, bestModel = , .huge, 
     mousePos = .(Mouse.X, Mouse.Y)
     myChar = LocalPlayer.Character
     myRoot = myChar  myChar:()
     myPos = myRoot  myRoot.Position  cam.CFrame.Position
    
     model, posData  (ESP.posCache) 
          model   model.Parent   
         Config.AIM_TeamCheck  model:()   
         Config.ESP_DeadCheck  (model)   
        
         parts = {}
         Config.AIM_TargetPart ==  
            parts = {model:(), model:()}
         Config.AIM_TargetPart ==  
            parts = {model:(), model:()}
         Config.AIM_TargetPart ==  
            parts = {model:()}
        
            parts = {model:()}
        
        
         _, part  (parts) 
             part 
                 sp, onScreen = cam:(part.Position)
                 onScreen  sp.Z >  
                     screenDist = (.(sp.X, sp.Y) - mousePos).Magnitude
                     screenDist <= Config.AIM_FOV 
                         score = screenDist / Config.AIM_FOV
                         model == Aimbot.currentTarget  score = score *  
                         score < bestScore 
                            bestScore = score
                            best = part.Position
                            bestModel = model
                        
                    
                
                 Config.AIM_TargetPart ~=    
            
        
    
    
     bestModel 
        Aimbot.currentTarget = bestModel
        Aimbot.lastTargetTime = ()
     () - Aimbot.lastTargetTime >  
        Aimbot.currentTarget = 
    
     best


 Aimbot.(cam, screenCenter)
     guiInset = GuiService:()
     isAiming = State.Aiming
    (() isAiming = isAiming  UserInputService:(.UserInputType.MouseButton2) )
    
     Config.AIM_Enabled  Config.AIM_ShowFOV 
        FOVCircle.Position = .(, screenCenter.X, , screenCenter.Y + guiInset.Y)
        FOVCircle.Size = .(, Config.AIM_FOV * , , Config.AIM_FOV * )
        FOVStroke.Color = isAiming  Palette.FOV_Active  Palette.FOV_Circle
        FOVCircle.Visible = 
    
        FOVCircle.Visible = 
    
    
      Config.AIM_Enabled   isAiming   
    
     target = Aimbot.(cam)
      target   
    
     mousePos = .(Mouse.X, Mouse.Y)
     sp = cam:(target)
     delta = .(sp.X - mousePos.X, sp.Y - mousePos.Y)
     delta.Magnitude <    
    
     mousemoverel 
        (() (delta.X * Config.AIM_Smooth, delta.Y * Config.AIM_Smooth) )
    


 Noclip = { Initialized = , Connection =  }
 Noclip.(m)
     _, p  (m:()) 
         p:()  p.CanCollide =  
    

 Noclip.()
     Noclip.Initialized   
    Noclip.Initialized = 
     _, obj  (Workspace:()) 
         obj.Name:()  Noclip.(obj) 
    
    Noclip.Connection = Workspace.DescendantAdded:((obj)
          Config.MISC_Noclip   
        .()
         obj.Name:() 
             .()  obj:()
            Noclip.(obj)
        
    )

 Noclip.()
     Config.MISC_Noclip   Noclip.Initialized  Noclip.() 


  ()
     Config.MISC_FullBright 
        Lighting.Brightness = 
        Lighting.Ambient = .(, , )
    
        Lighting.Brightness = OriginalLighting.Brightness
        Lighting.Ambient = OriginalLighting.Ambient
    


 Tabs = {{name = }, {name = }, {name = }}
 MenuItems = {
    {tab = , name = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = , options = {, }},
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = , min = , max = , step = },
    {tab = , name = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = , min = , max = , step = },
    {tab = , name = , key = ,  = , min = , max = , step = },
    
    {tab = , name = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = , key = ,  = , min = , max = , step = },
    {tab = , name = , key = ,  = , min = , max = , step = },
    {tab = , name = , key = ,  = , options = {, , , }},
    {tab = , name = , key = ,  = },
    
    {tab = , name = ,  = },
    {tab = , name = , key = ,  = },
    {tab = , name = ,  = },
    {tab = , name = , key = ,  = }
}

 GUI = {
    Frame = ,
    Position = ,
    Dragging = ,
    DragOffset = .zero,
    ScrollOffset = ,
    MaxScroll = ,
    Items = {},
    SliderDragging = 
}

 GUI.()
     menuW, menuH = , 
     titleH, tabH, footerH = , , 
    
     main = .()
    main.Name = 
    main.BackgroundColor3 = Palette.MenuBg
    main.BackgroundTransparency = 
    main.BorderSizePixel = 
    main.Size = .(, menuW, , menuH)
    main.Position = .(, , , -menuH/)
    main.Active = 
    main.Parent = UI.ScreenGui
    GUI.Frame = main
    
     stroke = .()
    stroke.Color = Palette.MenuBorder
    stroke.Thickness = 
    stroke.Parent = main
    
     title = .()
    title.Name = 
    title.BackgroundColor3 = Palette.MenuTab
    title.BorderSizePixel = 
    title.Size = .(, , , titleH)
    title.Parent = main
    
     titleText = .()
    titleText.BackgroundTransparency = 
    titleText.Position = .(, , , )
    titleText.Size = .(, , , )
    titleText.Font = .Font.GothamBold
    titleText.TextSize = 
    titleText.TextColor3 = Palette.MenuAccent
    titleText.TextXAlignment = .TextXAlignment.Left
    titleText.Text = 
    titleText.Parent = title
    
     xenoTag = .()
    xenoTag.BackgroundTransparency = 
    xenoTag.Position = .(, , , )
    xenoTag.Size = .(, , , )
    xenoTag.Font = .Font.RobotoMono
    xenoTag.TextSize = 
    xenoTag.TextColor3 = .(, , )
    xenoTag.TextXAlignment = .TextXAlignment.Left
    xenoTag.Text = 
    xenoTag.Parent = title
    
     hotkeyText = .()
    hotkeyText.BackgroundTransparency = 
    hotkeyText.Position = .(, -, , )
    hotkeyText.Size = .(, , , )
    hotkeyText.Font = .Font.RobotoMono
    hotkeyText.TextSize = 
    hotkeyText.TextColor3 = Palette.MenuTextDim
    hotkeyText.TextXAlignment = .TextXAlignment.Right
    hotkeyText.Text = 
    hotkeyText.Parent = title
    
     tabFrame = .()
    tabFrame.Name = 
    tabFrame.BackgroundTransparency = 
    tabFrame.Position = .(, , , titleH)
    tabFrame.Size = .(, , , tabH)
    tabFrame.Parent = main
    
    GUI.TabButtons = {}
     tabW = menuW / #Tabs
     i, tab  (Tabs) 
         btn = .()
        btn.Name = tab.name
        btn.BackgroundColor3 = Palette.MenuTab
        btn.BackgroundTransparency = 
        btn.BorderSizePixel = 
        btn.Position = .(, (i-) * tabW, , )
        btn.Size = .(, tabW, , )
        btn.Font = .Font.GothamBold
        btn.TextSize = 
        btn.TextColor3 = Palette.MenuTextDim
        btn.Text = tab.name
        btn.AutoButtonColor = 
        btn.Parent = tabFrame
        
         indicator = .()
        indicator.Name = 
        indicator.BackgroundColor3 = Palette.MenuAccent
        indicator.BorderSizePixel = 
        indicator.Position = .(, , , -)
        indicator.Size = .(, , , )
        indicator.Visible = i == 
        indicator.Parent = btn
        
        btn.MouseButton1Click:(()
            Config.MENU_Tab = i
            GUI.ScrollOffset = 
            GUI.()
            GUI.()
        )
        
        GUI.TabButtons[i] = {Button = btn, Indicator = indicator}
    
    
     contentFrame = .()
    contentFrame.Name = 
    contentFrame.BackgroundTransparency = 
    contentFrame.Position = .(, , , titleH + tabH + )
    contentFrame.Size = .(, -, , -titleH - tabH - footerH - )
    contentFrame.CanvasSize = .(, , , )
    contentFrame.ScrollBarThickness = 
    contentFrame.ScrollBarImageColor3 = Palette.MenuAccent
    contentFrame.BorderSizePixel = 
    contentFrame.Parent = main
    GUI.ContentFrame = contentFrame
    
     layout = .()
    layout.SortOrder = .SortOrder.LayoutOrder
    layout.Padding = .(, )
    layout.Parent = contentFrame
    
     footer = .()
    footer.Name = 
    footer.BackgroundTransparency = 
    footer.Position = .(, , , -footerH)
    footer.Size = .(, , , footerH)
    footer.Parent = main
    
     credit = .()
    credit.BackgroundTransparency = 
    credit.Position = .(, , , )
    credit.Size = .(, -, , )
    credit.Font = .Font.RobotoMono
    credit.TextSize = 
    credit.TextColor3 = Palette.MenuTextDim
    credit.TextXAlignment = .TextXAlignment.Right
    credit.Text = 
    credit.Parent = footer
    
    title.InputBegan:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            GUI.Dragging = 
             mouse = UserInputService:()
            GUI.DragOffset = mouse - .(main.AbsolutePosition.X, main.AbsolutePosition.Y)
        
    )
    
    title.InputEnded:((input)
         input.UserInputType == .UserInputType.MouseButton1 
            GUI.Dragging = 
        
    )
    
    GUI.()


 GUI.()
     i, tab  (GUI.TabButtons) 
         isSelected = i == Config.MENU_Tab
        tab.Button.BackgroundTransparency = isSelected    
        tab.Button.TextColor3 = isSelected  .(, , )  Palette.MenuTextDim
        tab.Indicator.Visible = isSelected
    


 GUI.()
     _, child  (GUI.ContentFrame:()) 
         child:()  child:() 
    
    GUI.Items = {}
    
     order = 
     _, menuItem  (MenuItems) 
         menuItem.tab == Config.MENU_Tab 
            order = order + 
             itemH = menuItem.type ==     
            
             item = .()
            item.Name = menuItem.name
            item.BackgroundColor3 = menuItem.type ==   Palette.MenuBg  Palette.MenuPanel
            item.BackgroundTransparency = menuItem.type ==     
            item.BorderSizePixel = 
            item.Size = .(, , , itemH)
            item.LayoutOrder = order
            item.Parent = GUI.ContentFrame
            
             label = .()
            label.BackgroundTransparency = 
            label.Position = .(, , , )
            label.Size = .(, , , )
            label.Font = .Font.RobotoMono
            label.TextSize = menuItem.type ==     
            label.TextColor3 = menuItem.type ==   Palette.MenuAccent  Palette.MenuText
            label.TextXAlignment = .TextXAlignment.Left
            label.Text = menuItem.name
            label.Parent = item
            
             menuItem.type ==  
                 toggle = .()
                toggle.Name = 
                toggle.BackgroundColor3 = Config[menuItem.key]  Palette.MenuOn  Palette.MenuOff
                toggle.BorderSizePixel = 
                toggle.Position = .(, -, , -)
                toggle.Size = .(, , , )
                toggle.Parent = item
                .(, toggle).CornerRadius = .(, )
                
                 knob = .()
                knob.Name = 
                knob.BackgroundColor3 = .(, , )
                knob.BorderSizePixel = 
                knob.Position = Config[menuItem.key]  .(, -, , -)  .(, , , -)
                knob.Size = .(, , , )
                knob.Parent = toggle
                .(, knob).CornerRadius = .(, )
                
                 btn = .()
                btn.BackgroundTransparency = 
                btn.Size = .(, , , )
                btn.Text = 
                btn.Parent = item
                
                btn.MouseButton1Click:(()
                    Config[menuItem.key] =  Config[menuItem.key]
                    toggle.BackgroundColor3 = Config[menuItem.key]  Palette.MenuOn  Palette.MenuOff
                    knob.Position = Config[menuItem.key]  .(, -, , -)  .(, , , -)
                )
                
             menuItem.type ==  
                 val = Config[menuItem.key]
                 valText = menuItem.step <   .(, val)  (.(val))
                
                 valLabel = .()
                valLabel.Name = 
                valLabel.BackgroundTransparency = 
                valLabel.Position = .(, -, , )
                valLabel.Size = .(, , , )
                valLabel.Font = .Font.RobotoMono
                valLabel.TextSize = 
                valLabel.TextColor3 = Palette.MenuTextDim
                valLabel.TextXAlignment = .TextXAlignment.Right
                valLabel.Text = valText
                valLabel.Parent = item
                
                 track = .()
                track.Name = 
                track.BackgroundColor3 = Palette.MenuOff
                track.BorderSizePixel = 
                track.Position = .(, , , )
                track.Size = .(, -, , )
                track.Parent = item
                .(, track).CornerRadius = .(, )
                
                 pct = (val - menuItem.min) / (menuItem.max - menuItem.min)
                 fill = .()
                fill.Name = 
                fill.BackgroundColor3 = Palette.MenuAccent
                fill.BorderSizePixel = 
                fill.Size = .(pct, , , )
                fill.Parent = track
                .(, fill).CornerRadius = .(, )
                
                 dragging = 
                track.InputBegan:((input)
                     input.UserInputType == .UserInputType.MouseButton1 
                        dragging = 
                    
                )
                track.InputEnded:((input)
                     input.UserInputType == .UserInputType.MouseButton1 
                        dragging = 
                    
                )
                
                Connections[ .. menuItem.key] = RunService.RenderStepped:(()
                     dragging 
                         mx = UserInputService:().X
                         tx = track.AbsolutePosition.X
                         tw = track.AbsoluteSize.X
                         p = .((mx - tx) / tw, , )
                         v = menuItem.min + p * (menuItem.max - menuItem.min)
                        v = .(v / menuItem.step + ) * menuItem.step
                        Config[menuItem.key] = .(v, menuItem.min, menuItem.max)
                        fill.Size = .((Config[menuItem.key] - menuItem.min) / (menuItem.max - menuItem.min), , , )
                        valLabel.Text = menuItem.step <   .(, Config[menuItem.key])  (.(Config[menuItem.key]))
                    
                )
                
             menuItem.type ==  
                 valLabel = .()
                valLabel.Name = 
                valLabel.BackgroundTransparency = 
                valLabel.Position = .(, -, , )
                valLabel.Size = .(, , , )
                valLabel.Font = .Font.RobotoMono
                valLabel.TextSize = 
                valLabel.TextColor3 = Palette.MenuAccent
                valLabel.TextXAlignment = .TextXAlignment.Right
                valLabel.Text =  .. Config[menuItem.key] .. 
                valLabel.Parent = item
                
                 idx = 
                 i, opt  (menuItem.options) 
                     opt == Config[menuItem.key]  idx = i  
                
                
                 btn = .()
                btn.BackgroundTransparency = 
                btn.Size = .(, , , )
                btn.Text = 
                btn.Parent = item
                
                btn.MouseButton1Click:(()
                    idx = idx % #menuItem.options + 
                    Config[menuItem.key] = menuItem.options[idx]
                    valLabel.Text =  .. Config[menuItem.key] .. 
                )
            
            
            GUI.Items[#GUI.Items + ] = item
        
    
    
     totalH = 
     _, item  (GUI.Items) 
        totalH = totalH + item.AbsoluteSize.Y + 
    
    GUI.ContentFrame.CanvasSize = .(, , , totalH)


 GUI.()
     GUI.Dragging 
         mouse = UserInputService:()
         newPos = mouse - GUI.DragOffset
        GUI.Frame.Position = .(, newPos.X, , newPos.Y)
    


  ()
     State.Unloaded   
    State.Unloaded = 
    
     _, conn  (Connections) 
        (() conn:() )
    
    
     _, esp  (ESP.cache)  ESP.(esp) 
    Chams.()
    
     Noclip.Connection  (() Noclip.Connection:() ) 
    
    (() UI.ScreenGui:() )
    (()
        Lighting.Brightness = OriginalLighting.Brightness
        Lighting.Ambient = OriginalLighting.Ambient
    )


Connections.inputDown = UserInputService.InputBegan:((input, gp)
     input.KeyCode == .KeyCode.Home  ()  
     input.KeyCode == .KeyCode.Insert   gp 
        Config.MENU_Open =  Config.MENU_Open
         GUI.Frame  GUI.Frame.Visible = Config.MENU_Open 
        
    
     input.UserInputType == .UserInputType.MouseButton2  State.Aiming =  
)

Connections.inputUp = UserInputService.InputEnded:((input)
     input.UserInputType == .UserInputType.MouseButton2  State.Aiming =  
     input.UserInputType == .UserInputType.MouseButton1  GUI.Dragging =  
)

Connections.render = RunService.RenderStepped:(()
     State.Unloaded   
    
     Config.ESP_Rainbow  State.RainbowHue = (State.RainbowHue + ) %  
    
     cam = Workspace.CurrentCamera
      cam   
     screenSize = cam.ViewportSize
     screenCenter = .(screenSize.X / , screenSize.Y / )
    
    (ApplyMisc)
    (Noclip.Step)
    (() ESP.(cam, screenSize) )
    (Chams.Step)
    (() (cam) )
    (() Aimbot.(cam, screenCenter) )
    (GUI.Step)
)

GUI.()
GUI.()