free and open source

 Rayfield = (:())()


 Window = Rayfield:({
    Name = ,
    Icon = ,
    LoadingTitle = ,
    LoadingSubtitle = ,
    ShowText = ,
    Theme = ,
    ToggleUIKeybind = .KeyCode.RightShift,
    DisableRayfieldPrompts = ,
    DisableBuildWarnings = ,
    ConfigurationSaving = {
        Enabled = ,
        FolderName = ,
        FileName = 
    }
})


 RS = :()
 RunService = :()
 TweenService = :()
 CAS = :()
 Players = :()
 Workspace = :()
 UserInputService = :()

 player = Players.LocalPlayer
 camera = Workspace.CurrentCamera
 CharactersFolder = Workspace:(, )




 Tab_Combat  = Window:(, )
 Tab_Skins   = Window:(, )
 Tab_Visuals = Window:(, )

Tab_Skins:(, , .(,,), )




  ()  CharactersFolder:() 
  ()  CharactersFolder:() 

  ()
     t, ct = (), ()
     (t  t:(player.Name))  (ct  ct:(player.Name))


  ()
      ()    
     t, ct = (), ()
     t  t:(player.Name)   ct 
     ct  ct:(player.Name)   t 
     





 AimbotEnabled = 
 ShowFOV = 
 FOV_Radius = 
 Smoothing = 
 AimKey = .UserInputType.MouseButton2
 isAiming = 

 FOVCircle = .()
FOVCircle.Position = .(camera.ViewportSize.X / , camera.ViewportSize.Y / )
FOVCircle.Radius = FOV_Radius
FOVCircle.Filled = 
FOVCircle.Color = .(, , )
FOVCircle.Visible = 
FOVCircle.Thickness = 

  ()
     closestEnemy = 
     shortestDistance = FOV_Radius
     enemyFolder = ()
    
      enemyFolder   AimbotEnabled    
    
     mousePos = UserInputService:()
    
     _, enemy  (enemyFolder:()) 
         hum = enemy:()
         head = enemy:()
        
         hum  hum.Health >   head 
             headPos, onScreen = camera:(head.Position)
             onScreen 
                 distance = (.(headPos.X, headPos.Y) - mousePos).Magnitude
                 distance < shortestDistance 
                    shortestDistance = distance
                    closestEnemy = head
                
            
        
    
     closestEnemy


UserInputService.InputBegan:((input)
     input.UserInputType == AimKey  isAiming =  
)

UserInputService.InputEnded:((input)
     input.UserInputType == AimKey  isAiming =  
)

RunService.RenderStepped:(()
     ShowFOV 
        FOVCircle.Position = UserInputService:()
        FOVCircle.Radius = FOV_Radius
        FOVCircle.Visible = 
    
        FOVCircle.Visible = 
    

      isAiming   ()   AimbotEnabled   
    
     targetHead = ()
     targetHead 
         headPos = camera:(targetHead.Position)
         mousePos = UserInputService:()
        
         moveX = (headPos.X - mousePos.X) / Smoothing
         moveY = (headPos.Y - mousePos.Y) / Smoothing
        
         mousemoverel 
            (moveX, moveY)
        
    
)

Tab_Combat:()
Tab_Combat:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value) AimbotEnabled = Value 
})

Tab_Combat:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value) ShowFOV = Value 
})

Tab_Combat:({
    Name = ,
    Range = {, },
    Increment = ,
    Suffix = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value) FOV_Radius = Value 
})

Tab_Combat:({
    Name = ,
    Range = {, },
    Increment = ,
    Suffix = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value) Smoothing = Value 
})




 TriggerBotEnabled = 
 TriggerBotDelay = 

Tab_Combat:()
Tab_Combat:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value) TriggerBotEnabled = Value 
})

Tab_Combat:({
    Name = ,
    Range = {, },
    Increment = ,
    Suffix = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value) TriggerBotDelay = Value 
})

.(()
     .() 
         TriggerBotEnabled  () 
             viewportSize = camera.ViewportSize
             ray = camera:(viewportSize.X / , viewportSize.Y / )
             raycastParams = RaycastParams.()
            raycastParams.FilterType = .RaycastFilterType.Exclude
            
             ignoreList = {camera}
             player.Character  .(ignoreList, player.Character) 
            raycastParams.FilterDescendantsInstances = ignoreList
            
             result = Workspace:(ray.Origin, ray.Direction * , raycastParams)
            
             result  result.Instance 
                 hitPart = result.Instance
                 model = hitPart:()
                 model  model:() 
                     enemyFolder = ()
                     enemyFolder  model.Parent == enemyFolder 
                         hum = model:()
                         hum  hum.Health >  
                             TriggerBotDelay >   .(TriggerBotDelay / ) 
                             mouse1click  () 
                            .()
                        
                    
                
            
        
    
)




 HitboxEnabled = 
 HitboxSize = 
 originalHeadSizes = {}

Tab_Combat:()
Tab_Combat:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value) 
        HitboxEnabled = Value 
    
})

Tab_Combat:({
    Name = ,
    Range = {, },
    Increment = ,
    Suffix = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value) 
        HitboxSize = Value 
    
})

.(()
     .() 
         enemyFolder = ()
         enemyFolder 
             _, enemy  (enemyFolder:()) 
                 head = enemy:()
                 hum = enemy:()
                
                 head  hum  hum.Health >  
                    
                      originalHeadSizes[head] 
                        originalHeadSizes[head] = head.Size
                    
                    
                     HitboxEnabled 
                        head.Size = .(HitboxSize, HitboxSize, HitboxSize)
                        head.CanCollide = 
                        head.Transparency = 
                    
                        
                         originalHeadSizes[head]  head.Size ~= originalHeadSizes[head] 
                            head.Size = originalHeadSizes[head]
                            head.Transparency = 
                        
                    
                
            
        
    
)




 BhopEnabled = 

Tab_Combat:()
Tab_Combat:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value) 
        BhopEnabled = Value 
    
})

RunService.RenderStepped:(()
     BhopEnabled  UserInputService:(.KeyCode.Space)  () 
         player.Character 
             hum = player.Character:()
             hum  hum:() ~= .HumanoidStateType.Jumping  hum:() ~= .HumanoidStateType.Freefall 
                hum.Jump = 
            
        
    
)




 scriptRunning = 
 selectedKnife = 
 spawned = 
 inspecting = 
 swinging = 
 lastAttackTime = 

 ATTACK_COOLDOWN = 
 ACTION_INSPECT = 
 ACTION_ATTACK  = 

(() RS.Assets.Weapons.Karambit.Camera.ViewmodelLight.Transparency =  )

 knives = {
    []       = {Offset = .(, -, )},
    [] = {Offset = .(, -, )},
    []     = {Offset = .(, -, )},
    []     = {Offset = .(, -, )},
    []      = {Offset = .(, -, )},
}

 vm, animator
 equipAnim, idleAnim, inspectAnim, HeavySwingAnim, Swing1Anim, Swing2Anim

  ()  camera:()  camera:() 

  (part)
      part:()   
    part.CanCollide, part.Anchored, part.CastShadow, part.CanTouch, part.CanQuery = , , , , 


  (model)
     _, part  model:()  (part) 


  (knife)
     _, part  knife:() 
         part:()  part:()  part:()  part.Transparency =  
    


  (folder, name)
     weaponSounds = RS.Sounds:(selectedKnife)
      weaponSounds   
     sound = weaponSounds:(folder):(name):()
    sound.Parent = camera
    sound:()
    sound.Ended:(() sound:() )
     sound


  (folder, armPartName, assetModelName, finalName, offset)
     targetArm = vm:(armPartName)
      targetArm   
     assetMesh = folder:(assetModelName):()
    (assetMesh)
    assetMesh.Name = finalName
    assetMesh.Parent = targetArm
     motor = .()
    motor.Part0, motor.Part1, motor.C0, motor.Parent = targetArm, assetMesh, offset, targetArm


  (actionName, inputState, inputObject)
     inputState ~= .UserInputState.Begin   spawned   animator   ()   .ContextActionResult.Pass 

     actionName == ACTION_INSPECT 
         (equipAnim  equipAnim.IsPlaying)  inspecting  swinging   .ContextActionResult.Pass 
        inspecting = 
         idleAnim  idleAnim:() 
        inspectAnim:()
        inspectAnim.Stopped:(() inspecting =  )
     actionName == ACTION_ATTACK 
         currentTime = .()
         (equipAnim  equipAnim.IsPlaying)  (currentTime - lastAttackTime < ATTACK_COOLDOWN)   .ContextActionResult.Pass 
        lastAttackTime = currentTime
         inspecting  inspecting = ;  inspectAnim  inspectAnim:()  
        swinging = 
         idleAnim  idleAnim:() 
         anims = {HeavySwingAnim, Swing1Anim, Swing2Anim}
         chosenAnim = anims[.(, #anims)]
         soundFolder = (chosenAnim == HeavySwingAnim  )  (chosenAnim == Swing1Anim  )  
        chosenAnim:()
         s = (soundFolder, )
         s  s.Volume =  
        chosenAnim.Stopped:(() swinging =  )
    
     .ContextActionResult.Pass


  ()
    spawned = 
    CAS:(ACTION_INSPECT)
    CAS:(ACTION_ATTACK)
     vm  vm:() vm =  
    animator, inspecting, swinging = , , 


  (knife)
     spawned   scriptRunning   
     myModel = ()
      myModel   
    spawned = 

     knifeTemplate = RS.Assets.Weapons:(selectedKnife)
     knifeOffset = knives[selectedKnife].Offset
    vm = knifeTemplate:():()
    vm.Name, vm.Parent = selectedKnife, camera

    (vm)
    (knife)

     myModel.Parent.Name ==  
         tGloves = RS.Assets.Weapons:()
        (tGloves, , , , .(, , -))
        (tGloves, , , , .(, , -))
    
         sleeves = RS.Assets.Sleeves:()
         ctGloves = RS.Assets.Weapons:()
        (sleeves, , , , .(, , ))
        (ctGloves, , , , .(, , -))
        (sleeves, , , , .(, , ))
        (ctGloves, , , , .(, , -))
    

     animController = vm:()  vm:()
    animator = animController:()  animController
     animFolder = RS.Assets.WeaponAnimations:(selectedKnife):()

    equipAnim = animator:(animFolder:())
    idleAnim = animator:(animFolder:())
    inspectAnim = animator:(animFolder:())
    HeavySwingAnim = animator:(animFolder:())
    Swing1Anim = animator:(animFolder:())
    Swing2Anim = animator:(animFolder:())

    vm:(camera.CFrame * .(, -, ))
    TweenService:(vm.PrimaryPart, TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out), {
         = camera.CFrame * knifeOffset
    }):()

    equipAnim:()
    (, )

    CAS:(ACTION_INSPECT, handleAction, , .KeyCode.F)
    CAS:(ACTION_ATTACK, handleAction, , .UserInputType.MouseButton1)


RunService.RenderStepped:(()
      scriptRunning   vm   vm.PrimaryPart   
    vm.PrimaryPart.CFrame = camera.CFrame * knives[selectedKnife].Offset
      (equipAnim  equipAnim.IsPlaying)   inspecting   swinging 
         idleAnim   idleAnim.IsPlaying  idleAnim:() 
    
)

.(()
     .() 
         living = ()
         currentKnife = ()
         scriptRunning  living  currentKnife   spawned 
            (currentKnife)
         ( scriptRunning   currentKnife   living)  spawned 
            ()
        
    
)

 SkinChangerEnabled = 
 SelectedSkins = {}
 DropdownObjects = {}
 SkinOptions = {}
 COOLDOWN = 
 WEAR = 

 CT_ONLY = {[]=, []=, []=, []=, []=, []=, []=}
 SHARED = {[]=, []=, []=, []=, []=, []=, []=, []=, []=}
 KNIVES = {[]=, []=, []=, []=, []=, []=, []=}
 GLOVES = {[]=}
 SkinsFolder = RS:():()
 IgnoreFolders = {[]=, []=, []=, []=, []=, []=, []=, []=, []=}

  (model)
      model   SkinChangerEnabled   ()   
     skinName = SelectedSkins[model.Name]
      skinName   

    (()
         skinFolder = SkinsFolder:(model.Name)
          skinFolder   
         skinType = skinFolder:(skinName)
         sourceFolder = skinType  skinType:()  skinType.Camera:(WEAR)
          sourceFolder   

         _, obj  camera:() 
             left, right = obj:(), obj:()
             left  right 
                 gloveFolder = SkinsFolder:()
                 gloveSkin = gloveFolder  gloveFolder:(SelectedSkins[])
                 gloveSource = gloveSkin  gloveSkin:()  gloveSkin.Camera:(WEAR)
                 gloveSource 
                     _, side  {, } 
                         arm, src = obj:(side), gloveSource:(side)
                         arm  src 
                             gloveMesh = arm:()
                             gloveMesh 
                                 existing = gloveMesh:()
                                 existing  existing:() 
                                 clone = src:()
                                clone.Name, clone.Parent = , gloveMesh
                            
                        
                    
                
            
        

          GLOVES[model.Name] 
             weaponFolder = model:()
             weaponFolder 
                 _, part  weaponFolder:() 
                     part:() 
                         newSkin = sourceFolder:(part.Name)
                         newSkin 
                             existing = part:()
                             existing  existing:() 
                             clone = newSkin:()
                            clone.Name, clone.Parent = , part
                        
                    
                
            
        
        model:(, skinName)
    )


Tab_Skins:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        SkinChangerEnabled = Value
          Value   _, obj  camera:()  obj:(, )  
    
})

Tab_Skins:({
    Name = ,
    Callback = ()
         weaponName, optionsList  (SkinOptions) 
             #optionsList >  
                 randomSkin = optionsList[.(, #optionsList)]
                 DropdownObjects[weaponName] 
                     _, dropdown  (DropdownObjects[weaponName])  dropdown:({randomSkin}) 
                
            
        
    ,
})

  (weaponName)
     folder = SkinsFolder:(weaponName)
      folder   
    
     options = {}
     _, skin  folder:()  .(options, skin.Name) 
    SkinOptions[weaponName] = options
    
      SelectedSkins[weaponName]  SelectedSkins[weaponName] = options[] 

     dp = Tab_Skins:({
        Name = weaponName,
        Options = options,
        CurrentOption = {SelectedSkins[weaponName]},
        Flag =  .. weaponName,
        Callback = (opt)
             newSkin = opt[]
            SelectedSkins[weaponName] = newSkin
             DropdownObjects[weaponName] 
                 _, other  DropdownObjects[weaponName] 
                     other.CurrentOption[] ~= newSkin  other:({newSkin}) 
                
            
             _, obj  camera:()  obj:(, ); (obj) 
        
    })
    DropdownObjects[weaponName] = DropdownObjects[weaponName]  {}
    .(DropdownObjects[weaponName], dp)


Tab_Skins:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        scriptRunning = Value;   Value  () 
    
})

Tab_Skins:({
    Name = ,
    Options = {, , , , },
    CurrentOption = {},
    MultipleOptions = ,
    Flag = ,
    Callback = (Options)
        selectedKnife = Options[];  spawned  () 
    
})

Tab_Skins:()
 name  (KNIVES)  (name) 
Tab_Skins:()
 name  (GLOVES)  (name) 
Tab_Skins:()
 name  (CT_ONLY)  (name) 
Tab_Skins:()
 name  (SHARED)  (name) 

 _, folder  SkinsFolder:() 
     n = folder.Name
      IgnoreFolders[n]   KNIVES[n]   GLOVES[n]   CT_ONLY[n]   SHARED[n]  (n) 


camera.ChildAdded:((obj)
      SkinChangerEnabled   ()   
    .(COOLDOWN); (obj)
)

.(()
     .() 
         SkinChangerEnabled  () 
             _, obj  camera:() 
                 SelectedSkins[obj.Name]  obj:() ~= SelectedSkins[obj.Name]  (obj) 
            
        
    
)




 EspEnabled, EspBox, EspName, EspHealth, EspDistance = , , , , 
 espCache = {}

  ()
     esp = {
        boxOutline = .(), box = .(),
        name = .(), distance = .(),
        healthOutline = .(), healthBar = .()
    }
    esp.boxOutline.Thickness = ; esp.boxOutline.Filled = ; esp.boxOutline.Color = .(, , )
    esp.box.Thickness = ; esp.box.Filled = ; esp.box.Color = .(, , )
    esp.name.Center = ; esp.name.Outline = ; esp.name.Color = .(, , ); esp.name.Size = 
    esp.distance.Center = ; esp.distance.Outline = ; esp.distance.Color = .(, , ); esp.distance.Size = 
    esp.healthOutline.Thickness = ; esp.healthOutline.Color = .(, , )
    esp.healthBar.Thickness = ; esp.healthBar.Color = .(, , )
     esp


RunService.RenderStepped:(()
      EspEnabled   () 
         _, e  (espCache)   _, d  (e)  d.Visible =   
        
    
    
     enemyFolder = ()
      enemyFolder   

     currentAlive = {}
     _, enemy  (enemyFolder:()) 
         hum, root, head = enemy:(), enemy:(), enemy:()

         hum  hum.Health >   root  head 
            currentAlive[enemy] = 
              espCache[enemy]  espCache[enemy] = () 
            
             esp = espCache[enemy]
             rootPos, onScreen = camera:(root.Position)
             headPos = camera:(head.Position + .(, , ))
             legPos = camera:(root.Position - .(, , ))

             onScreen 
                 boxH, boxW = .(headPos.Y - legPos.Y), .(headPos.Y - legPos.Y) / 
                 dist = .((camera.CFrame.Position - root.Position).Magnitude)

                 EspBox 
                    esp.boxOutline.Size = .(boxW, boxH); esp.boxOutline.Position = .(rootPos.X - boxW / , headPos.Y); esp.boxOutline.Visible = 
                    esp.box.Size = .(boxW, boxH); esp.box.Position = .(rootPos.X - boxW / , headPos.Y); esp.box.Visible = 
                 esp.boxOutline.Visible, esp.box.Visible = ,  
                
                 EspHealth 
                     hpPct, barX = hum.Health / hum.MaxHealth, rootPos.X - boxW /  - 
                    esp.healthOutline.From = .(barX, headPos.Y - ); esp.healthOutline.To = .(barX, headPos.Y + boxH + ); esp.healthOutline.Visible = 
                    esp.healthBar.From = .(barX, headPos.Y + boxH); esp.healthBar.To = .(barX, headPos.Y + boxH - (boxH * hpPct)); esp.healthBar.Color = .( - hpPct, hpPct, ); esp.healthBar.Visible = 
                 esp.healthOutline.Visible, esp.healthBar.Visible = ,  
                
                 EspName  esp.name.Text = enemy.Name; esp.name.Position = .(rootPos.X, headPos.Y - ); esp.name.Visible =  
                 esp.name.Visible =  

                 EspDistance  esp.distance.Text =  .. dist .. ; esp.distance.Position = .(rootPos.X, headPos.Y + boxH + ); esp.distance.Visible = 
                 esp.distance.Visible =  
              _, d  (esp)  d.Visible =   
        
    
     cEnemy, e  (espCache) 
          currentAlive[cEnemy]   _, d  (e)  d:() ; espCache[cEnemy] =  
    
)

Tab_Visuals:()
Tab_Visuals:({Name = , CurrentValue = , Flag = , Callback = (Value) EspEnabled = Value })

Tab_Visuals:()
Tab_Visuals:({Name = , CurrentValue = , Flag = , Callback = (Value) EspBox = Value })
Tab_Visuals:({Name = , CurrentValue = , Flag = , Callback = (Value) EspHealth = Value })
Tab_Visuals:({Name = , CurrentValue = , Flag = , Callback = (Value) EspName = Value })
Tab_Visuals:({Name = , CurrentValue = , Flag = , Callback = (Value) EspDistance = Value })

 AntiFlashEnabled, AntiSmokeEnabled = , 
Tab_Visuals:()
Tab_Visuals:({Name = , CurrentValue = , Flag = , Callback = (Value) AntiFlashEnabled = Value })
Tab_Visuals:({Name = , CurrentValue = , Flag = , Callback = (Value) AntiSmokeEnabled = Value })

.(()
     .() 
         AntiFlashEnabled 
             gui, effect = player.PlayerGui:(), :():()
             gui  gui:() ;  effect  effect:() 
        
    
)

.(()
     .() 
         AntiSmokeEnabled 
             debris = Workspace:()
             debris 
                 _, folder  (debris:()) 
                     .(folder.Name, )  folder:(); folder:() 
                
            
        
    
)

Rayfield:()