Universal BunnyHop source

 Players      = :()
 UIS          = :()
 RunService   = :()
 TweenService = :()

 player = Players.LocalPlayer
 camera = .CurrentCamera

 conns = {}
  (signal, fn)
	 c = signal:(fn)
	.(conns, c)
	 c


 UPS = 

 S = {
	Enabled       = ,
	AutoHop       = ,
	ToggleKey     = .KeyCode.V,
	MenuKey       = .KeyCode.RightShift,

	GroundSpeed   = ,
	JumpPower     = ,
	Gravity       = ,
	SetGravity    = ,

	AirAccelerate = ,
	AirCap        =  / UPS,
	MinBhopSpeed  =  / UPS,
	MaxSpeed      =  / UPS,
	LandBoost     = ,

	BackwardsBhop = ,
	AutoStrafe    = ,

	Surf          = ,
	SurfMinAngle  = ,
	SurfMaxAngle  = ,
	SurfAccel     = ,
	SurfGravity   = ,
	SurfFriction  = ,
	SurfDetect    = ,

	FovBoost      = ,
	BaseFov       = ,
	FovIntensity  = ,
	FovMax        = ,

	ShowHud       = ,
}

 spaceHeld   = 
 simVel      = .zero
 wasInAir    = 
 surfing     = 
 surfNormal  = .zero
 defaultWalkSpeed, defaultFov = , 
 defaultGravity = .Gravity

  ()
	 char = player.Character
	  char    
	 hum  = char:()
	 root = char:()
	 hum  root  hum.Health >    char, hum, root 
	 


  (v)  .(v.X, , v.Z) 

  (vel, wishdir, wishspeed, accel, dt)
	 currentspeed = vel:(wishdir)
	 addspeed = wishspeed - currentspeed
	 addspeed <=    vel 
	 accelspeed = .(accel * wishspeed * dt, addspeed)
	 vel + wishdir * accelspeed


  ()
	 f, r = , 
	 UIS:(.KeyCode.W)  f +=  
	 UIS:(.KeyCode.S)  f -=  
	 UIS:(.KeyCode.D)  r +=  
	 UIS:(.KeyCode.A)  r -=  
	 f, r


  ()
	 f, r = ()
	 f ==   r ==    , ,  

	 look  = camera.CFrame.LookVector
	 right = camera.CFrame.RightVector
	 flatLook  = .(look.X, , look.Z)
	 flatRight = .(right.X, , right.Z)
	 flatLook.Magnitude <    , f, r 

	 wish = flatLook.Unit * f + flatRight.Unit * r
	 wish.Magnitude <    , f, r 
	 wish.Unit, f, r


 lastYaw = 
  (currentVel)
	 f, r = ()
	 yaw = .(camera.CFrame.LookVector.X, camera.CFrame.LookVector.Z)
	 dyaw = 
	 lastYaw 
		dyaw = yaw - lastYaw
		 dyaw > .pi  dyaw -=  * .pi 
		 dyaw < -.pi  dyaw +=  * .pi 
	
	lastYaw = yaw

	 currentVel.Magnitude <    () 
	 velDir = currentVel.Unit
	 sideSign = dyaw >=     -
	 r ~=   sideSign = r >     - 

	 perp = .(-velDir.Z, , velDir.X) * sideSign
	 wish = (velDir *  + perp).Unit
	 wish, , r


 rayParams = RaycastParams.()
rayParams.FilterType = .RaycastFilterType.Exclude
  (root)
	 char = player.Character
	 char  rayParams.FilterDescendantsInstances = { char } 
	 origin = root.Position
	 dirs = { .(, -, ) }
	 vel = root.AssemblyLinearVelocity
	 vel.Magnitude >   .(dirs, vel.Unit) 
	 horiz = (vel)
	 horiz.Magnitude >   .(dirs, horiz.Unit) 

	 _, d  (dirs) 
		 res = :(origin, d * S.SurfDetect, rayParams)
		 res 
			 n = res.Normal
			 angle = .(.(.(n.Y, -, )))
			 angle >= S.SurfMinAngle  angle <= S.SurfMaxAngle 
				 n
			
		
	
	 


  (vel, normal, overbounce)
	 backoff = vel:(normal) * overbounce
	 vel - normal * backoff


  ()
	 _, hum = ()
	 S.Enabled 
		player.CameraMode = .CameraMode.LockFirstPerson
		 hum 
			hum.WalkSpeed = S.GroundSpeed
			hum.UseJumpPower = 
			hum.JumpPower = S.JumpPower
		
		 S.SetGravity  .Gravity = S.Gravity 
	
		player.CameraMode = .CameraMode.Classic
		 hum 
			hum.WalkSpeed = defaultWalkSpeed
			hum.JumpPower = 
		
		.Gravity = defaultGravity
		camera.FieldOfView = defaultFov
		simVel = .zero
		surfing = 
	


  (hum, root)
	 realH = (root.AssemblyLinearVelocity)
	 realH.Magnitude > simVel.Magnitude  simVel = realH 
	 simVel.Magnitude < S.MinBhopSpeed  simVel = realH 

	 S.LandBoost >   simVel.Magnitude > S.MinBhopSpeed 
		simVel = simVel + simVel.Unit * (S.LandBoost / UPS)
		 simVel.Magnitude > S.MaxSpeed  simVel = simVel.Unit * S.MaxSpeed 
	

	hum:(.HumanoidStateType.Jumping)
	root.AssemblyLinearVelocity = .(simVel.X, S.JumpPower, simVel.Z)


(RunService.Stepped, (_, dt)
	  S.Enabled   
	 _, hum, root = ()
	  hum   

	 inAir = hum.FloorMaterial == .Material.Air
	 vel = root.AssemblyLinearVelocity

	surfing = 
	surfNormal = .zero
	 S.Surf  inAir 
		 n = (root)
		 n 
			surfing = 
			surfNormal = n
		
	

	 surfing 
		 full = root.AssemblyLinearVelocity

		full = full + .(, -S.SurfGravity * dt, )

		 wishdir = ()
		 wishdir 
			 wishspeed = S.AirCap
			full = (full, wishdir, wishspeed, S.SurfAccel, dt)
		

		 full:(surfNormal) <  
			full = (full, surfNormal, )
		

		 S.SurfFriction >  
			 sp = full.Magnitude
			 sp >  
				 drop = sp * S.SurfFriction * dt
				full = full * (.(sp - drop, ) / sp)
			
		

		 full.Magnitude > S.MaxSpeed  full = full.Unit * S.MaxSpeed 
		root.AssemblyLinearVelocity = full
		simVel = (full)
	 inAir 
		  wasInAir 
			 realH = (vel)
			 realH.Magnitude > simVel.Magnitude  simVel = realH 
		

		 wishdir, f, r = ()
		 S.AutoStrafe  (f ~=   r ~= ) 
			wishdir = (simVel)
			f = 
		

		 wishdir 
			 allow = 
			  S.BackwardsBhop  f <   allow =  
			 allow 
				simVel = (simVel, wishdir, S.AirCap, S.AirAccelerate, dt)
				 simVel.Magnitude > S.MaxSpeed 
					simVel = simVel.Unit * S.MaxSpeed
				
			
		

		 realH = (vel)
		 wasInAir  realH.Magnitude < simVel.Magnitude *  
			simVel = realH
		

		root.AssemblyLinearVelocity = .(simVel.X, vel.Y, simVel.Z)
	
		 S.AutoHop  spaceHeld 
			(hum, root)
		
			simVel = (vel)
		
	

	wasInAir = inAir  surfing
)

(RunService.RenderStepped, (dt)
	  S.Enabled   S.FovBoost   
	 _, _, root = ()
	  root   
	 speed = (root.AssemblyLinearVelocity).Magnitude
	 target = S.BaseFov + .((speed - S.GroundSpeed) * (S.FovIntensity / ), , S.FovMax)
	camera.FieldOfView += (target - camera.FieldOfView) * .(dt * , )
)

 keybindCapturing = 
 toggleFromKeybind
 menuFromKeybind

(UIS.InputBegan, (input, gpe)
	 input.KeyCode == .KeyCode.Space 
		spaceHeld = 
		 S.Enabled   S.AutoHop   gpe 
			 _, hum, root = ()
			 hum  hum.FloorMaterial ~= .Material.Air 
				(hum, root)
			
		
	
	 gpe  keybindCapturing   
	 input.KeyCode == S.ToggleKey 
		S.Enabled =  S.Enabled
		()
		 toggleFromKeybind  (S.Enabled) 
	 input.KeyCode == S.MenuKey 
		 menuFromKeybind  () 
	
)
(UIS.InputEnded, (input)
	 input.KeyCode == .KeyCode.Space  spaceHeld =  
)

(player.CharacterAdded, ()
	.()
	simVel = .zero
	wasInAir = 
	surfing = 
	()
)

 BG0     = .(, , )
 BG1     = .(, , )
 BG2     = .(, , )
 LINE    = .(, , )
 TXT     = .(, , )
 TXT_DIM = .(, , )
 ACCENT  = .(, , )
 ACCENT_D= .(, , )

 SPRING = TweenInfo.(, .EasingStyle.Quint, .EasingDirection.Out)
 FAST   = TweenInfo.(, .EasingStyle.Quint, .EasingDirection.Out)
 SNAP   = TweenInfo.(, .EasingStyle.Quad, .EasingDirection.Out)

  (obj, info, props)  t = TweenService:(obj, info, props) t:()  t 

 gui = .()
gui.Name = 
gui.ResetOnSpawn = 
gui.IgnoreGuiInset = 
gui.ZIndexBehavior = .ZIndexBehavior.Sibling
gui.DisplayOrder = 
gui.Parent = player:()

  (obj, r)
	 c = .()
	c.CornerRadius = .(, r)
	c.Parent = obj
	 c

  (obj, color, thick, tr)
	 s = .()
	s.Color = color
	s.Thickness = thick  
	s.Transparency = tr  
	s.ApplyStrokeMode = .ApplyStrokeMode.Border
	s.Parent = obj
	 s

  (obj, l, t, r, b)
	 p = .()
	p.PaddingLeft = .(, l)
	p.PaddingTop = .(, t)
	p.PaddingRight = .(, r  l)
	p.PaddingBottom = .(, b  t)
	p.Parent = obj
	 p


 MENU_W, MENU_H = , 

 main = .()
main.Size = .(MENU_W, MENU_H)
main.Position = .(, , , )
main.AnchorPoint = .(, )
main.BackgroundColor3 = BG0
main.BorderSizePixel = 
main.Active = 
main.ClipsDescendants = 
main.Parent = gui
(main, )
(main, LINE, , )

 header = .()
header.Size = .(, , , )
header.BackgroundTransparency = 
header.Parent = main

 dot = .()
dot.Size = .(, )
dot.Position = .(, )
dot.BackgroundColor3 = TXT_DIM
dot.BorderSizePixel = 
dot.Parent = header
(dot, )

 title = .()
title.Size = .(, -, , )
title.Position = .(, )
title.BackgroundTransparency = 
title.Font = .Font.GothamBold
title.TextSize = 
title.TextXAlignment = .TextXAlignment.Left
title.TextColor3 = TXT
title.Text = 
title.Parent = header

 subtitle = .()
subtitle.Size = .(, -, , )
subtitle.Position = .(, )
subtitle.BackgroundTransparency = 
subtitle.Font = .Font.GothamMedium
subtitle.TextSize = 
subtitle.TextXAlignment = .TextXAlignment.Left
subtitle.TextColor3 = TXT_DIM
subtitle.Text = 
subtitle.Parent = header

 closeBtn = .()
closeBtn.Size = .(, )
closeBtn.Position = .(, -, , )
closeBtn.BackgroundColor3 = BG2
closeBtn.Font = .Font.GothamBold
closeBtn.TextSize = 
closeBtn.Text = 
closeBtn.AutoButtonColor = 
closeBtn.TextColor3 = TXT_DIM
closeBtn.Parent = header
(closeBtn, )
closeBtn.MouseEnter:(()
	(closeBtn, SNAP, { BackgroundColor3 = .(, , ), TextColor3 = .(, , ) })
)
closeBtn.MouseLeave:(()
	(closeBtn, SNAP, { BackgroundColor3 = BG2, TextColor3 = TXT_DIM })
)

 divider = .()
divider.Size = .(, -, , )
divider.Position = .(, )
divider.BackgroundColor3 = LINE
divider.BorderSizePixel = 
divider.Parent = main

 tabBar = .()
tabBar.Size = .(, -, , )
tabBar.Position = .(, )
tabBar.BackgroundColor3 = BG1
tabBar.BorderSizePixel = 
tabBar.Parent = main
(tabBar, )

 pill = .()
pill.Size = .(, )
pill.Position = .(, )
pill.BackgroundColor3 = BG2
pill.BorderSizePixel = 
pill.Parent = tabBar
(pill, )
(pill, LINE, , )

 pages = .()
pages.Size = .(, -, , -)
pages.Position = .(, )
pages.BackgroundTransparency = 
pages.ClipsDescendants = 
pages.Parent = main

 TAB_NAMES = { , ,  }
 tabButtons = {}
 pageFrames = {}
 currentTab = 

  (name)
	 scroll = .()
	scroll.Size = .(, , , )
	scroll.BackgroundTransparency = 
	scroll.BorderSizePixel = 
	scroll.ScrollBarThickness = 
	scroll.ScrollBarImageColor3 = LINE
	scroll.CanvasSize = .(, , , )
	scroll.AutomaticCanvasSize = .AutomaticSize.Y
	scroll.ScrollingDirection = .ScrollingDirection.Y
	scroll.Visible = 
	scroll.Parent = pages
	 list = .()
	list.Padding = .(, )
	list.SortOrder = .SortOrder.LayoutOrder
	list.Parent = scroll
	(scroll, , , , )
	 scroll


 i, n  (TAB_NAMES) 
	pageFrames[i] = (n)


  (i, animate)
	 w = tabBar.AbsoluteSize.X - 
	 seg = w / #TAB_NAMES
	 info = animate  TweenInfo.(, .EasingStyle.Quint, .EasingDirection.Out)  TweenInfo.()
	(pill, info, {
		Position = .( + seg * (i - ), ),
		Size = .(seg, ),
	})


  (i, animate)
	currentTab = i
	(i, animate)
	 idx, btn  (tabButtons) 
		(btn, FAST, { TextColor3 = idx == i  TXT  TXT_DIM })
	
	 idx, pg  (pageFrames) 
		 idx == i 
			pg.Visible = 
			pg.Position = .(animate    , )
			(pg, SPRING, { Position = .(, ) })
		
			pg.Visible = 
		
	


 i, n  (TAB_NAMES) 
	 btn = .()
	btn.Size = .( / #TAB_NAMES, , , )
	btn.Position = .((i - ) / #TAB_NAMES, , , )
	btn.BackgroundTransparency = 
	btn.Font = .Font.GothamBold
	btn.TextSize = 
	btn.TextColor3 = i ==   TXT  TXT_DIM
	btn.Text = n
	btn.AutoButtonColor = 
	btn.ZIndex = 
	btn.Parent = tabBar
	tabButtons[i] = btn
	btn.MouseButton1Click:(() (i, ) )


  (page, text, order)
	 lbl = .()
	lbl.Size = .(, , , )
	lbl.BackgroundTransparency = 
	lbl.Font = .Font.GothamBold
	lbl.TextSize = 
	lbl.TextXAlignment = .TextXAlignment.Left
	lbl.TextYAlignment = .TextYAlignment.Bottom
	lbl.TextColor3 = TXT_DIM
	lbl.Text = .(text)
	lbl.LayoutOrder = order
	lbl.Parent = page


  (page, text, initial, order, callback)
	 row = .()
	row.Size = .(, , , )
	row.BackgroundColor3 = BG1
	row.BorderSizePixel = 
	row.LayoutOrder = order
	row.Parent = page
	(row, )

	 lbl = .()
	lbl.Size = .(, -, , )
	lbl.Position = .(, )
	lbl.BackgroundTransparency = 
	lbl.Font = .Font.GothamMedium
	lbl.TextSize = 
	lbl.TextXAlignment = .TextXAlignment.Left
	lbl.TextColor3 = TXT
	lbl.Text = text
	lbl.Parent = row

	 track = .()
	track.Size = .(, )
	track.Position = .(, -, , -)
	track.BackgroundColor3 = initial  ACCENT  LINE
	track.Text = 
	track.AutoButtonColor = 
	track.Parent = row
	(track, )

	 knob = .()
	knob.Size = .(, )
	knob.Position = initial  .(, -, , -)  .(, , , -)
	knob.BackgroundColor3 = .(, , )
	knob.BorderSizePixel = 
	knob.Parent = track
	(knob, )

	 state = initial
	  (v, fire)
		state = v
		(knob, TweenInfo.(, .EasingStyle.Back, .EasingDirection.Out), {
			Position = v  .(, -, , -)  .(, , , -)
		})
		(track, FAST, { BackgroundColor3 = v  ACCENT  LINE })
		 fire  (v) 
	
	track.MouseButton1Click:(() ( state, ) )
	row.MouseEnter:(() (row, SNAP, { BackgroundColor3 = BG2 }) )
	row.MouseLeave:(() (row, SNAP, { BackgroundColor3 = BG1 }) )
	 setState


  (page, text, minV, maxV, initial, step, suffix, order, callback)
	step = step  
	 row = .()
	row.Size = .(, , , )
	row.BackgroundColor3 = BG1
	row.BorderSizePixel = 
	row.LayoutOrder = order
	row.Parent = page
	(row, )

	 lbl = .()
	lbl.Size = .(, -, , )
	lbl.Position = .(, )
	lbl.BackgroundTransparency = 
	lbl.Font = .Font.GothamMedium
	lbl.TextSize = 
	lbl.TextXAlignment = .TextXAlignment.Left
	lbl.TextColor3 = TXT
	lbl.Text = text
	lbl.Parent = row

	 value = initial

	  (v)
		 step <    .(, v)   (.(v + )) 
	

	 valBox = .()
	valBox.Size = .(, , , )
	valBox.Position = .(, -, , )
	valBox.BackgroundColor3 = BG2
	valBox.BackgroundTransparency = 
	valBox.Font = .Font.GothamBold
	valBox.TextSize = 
	valBox.TextXAlignment = .TextXAlignment.Right
	valBox.TextColor3 = ACCENT
	valBox.ClearTextOnFocus = 
	valBox.Text = (initial) .. (suffix  )
	valBox.Parent = row
	(valBox, )
	(valBox, , , , )

	 bar = .()
	bar.Size = .(, -, , )
	bar.Position = .(, , , -)
	bar.BackgroundColor3 = LINE
	bar.BorderSizePixel = 
	bar.Parent = row
	(bar, )

	 fill = .()
	fill.Size = .(.((initial - minV) / (maxV - minV), , ), , , )
	fill.BackgroundColor3 = ACCENT
	fill.BorderSizePixel = 
	fill.Parent = bar
	(fill, )

	 grip = .()
	grip.Size = .(, )
	grip.AnchorPoint = .(, )
	grip.Position = .(, , , )
	grip.BackgroundColor3 = .(, , )
	grip.BorderSizePixel = 
	grip.Parent = fill
	(grip, )
	(grip, ACCENT_D, , )

	  (v, instant, updateText)
		value = v
		 shownRel = .((v - minV) / (maxV - minV), , )
		(fill, TweenInfo.(instant    , .EasingStyle.Quad), { Size = .(shownRel, , , ) })
		 updateText  valBox.Text = (v) .. (suffix  ) 
		(v)
	

	 dragging = 
	  (x, instant)
		 rel = .((x - bar.AbsolutePosition.X) / bar.AbsoluteSize.X, , )
		 raw = minV + rel * (maxV - minV)
		 v = .(raw / step + ) * step
		v = .(v, minV, maxV)
		(v, instant, )
	

	bar.InputBegan:((input)
		 input.UserInputType == .UserInputType.MouseButton1 
			dragging = 
			(input.Position.X)
			(grip, SNAP, { Size = .(, ) })
		
	)
	UIS.InputChanged:((input)
		 dragging  input.UserInputType == .UserInputType.MouseMovement 
			(input.Position.X, )
		
	)
	UIS.InputEnded:((input)
		 input.UserInputType == .UserInputType.MouseButton1  dragging 
			dragging = 
			(grip, SNAP, { Size = .(, ) })
		
	)

	valBox.Focused:(()
		(valBox, SNAP, { BackgroundTransparency =  })
		valBox.Text = (value)
	)
	valBox.FocusLost:(()
		(valBox, SNAP, { BackgroundTransparency =  })
		 n = (valBox.Text)
		 n 
			 n < minV  n = minV 
			(n, , )
		
		valBox.Text = (value) .. (suffix  )
	)

	row.MouseEnter:(() (row, SNAP, { BackgroundColor3 = BG2 }) )
	row.MouseLeave:(() (row, SNAP, { BackgroundColor3 = BG1 }) )
	 valBox


  (page, text, getKey, order, callback)
	 row = .()
	row.Size = .(, , , )
	row.BackgroundColor3 = BG1
	row.BorderSizePixel = 
	row.LayoutOrder = order
	row.Parent = page
	(row, )

	 lbl = .()
	lbl.Size = .(, -, , )
	lbl.Position = .(, )
	lbl.BackgroundTransparency = 
	lbl.Font = .Font.GothamMedium
	lbl.TextSize = 
	lbl.TextXAlignment = .TextXAlignment.Left
	lbl.TextColor3 = TXT
	lbl.Text = text
	lbl.Parent = row

	 btn = .()
	btn.Size = .(, )
	btn.Position = .(, -, , -)
	btn.BackgroundColor3 = BG2
	btn.Font = .Font.GothamBold
	btn.TextSize = 
	btn.TextColor3 = ACCENT
	btn.AutoButtonColor = 
	btn.Text = ().Name
	btn.Parent = row
	(btn, )
	(btn, LINE, , )

	btn.MouseButton1Click:(()
		 keybindCapturing   
		keybindCapturing = 
		btn.Text = 
		(btn, SNAP, { BackgroundColor3 = ACCENT, TextColor3 = BG0 })
		 conn
		conn = UIS.InputBegan:((input)
			 input.UserInputType ~= .UserInputType.Keyboard   
			conn:()
			 input.KeyCode ~= .KeyCode.Escape  input.KeyCode ~= .KeyCode.Space 
				(input.KeyCode)
			
			btn.Text = ().Name
			(btn, SNAP, { BackgroundColor3 = BG2, TextColor3 = ACCENT })
			.()
			keybindCapturing = 
		)
	)
	row.MouseEnter:(() (row, SNAP, { BackgroundColor3 = BG2 }) )
	row.MouseLeave:(() (row, SNAP, { BackgroundColor3 = BG1 }) )


 dotPulse
  (on)
	 dotPulse  dotPulse:() 
	 on 
		dot.BackgroundColor3 = ACCENT
		dotPulse = TweenService:(dot,
			TweenInfo.(, .EasingStyle.Sine, .EasingDirection.InOut, -, ),
			{ BackgroundTransparency =  })
		dotPulse:()
	
		dot.BackgroundTransparency = 
		dot.BackgroundColor3 = TXT_DIM
	


 p1 = pageFrames[]
(p1, , )
 setBhopToggle = (p1, , , , (v)
	S.Enabled = v
	()
	(v)
)
(p1, , S.AutoHop, , (v) S.AutoHop = v )
(p1, , ()  S.ToggleKey , , (k) S.ToggleKey = k )
(p1, , ()  S.MenuKey , , (k) S.MenuKey = k )

(p1, , )
(p1, , S.FovBoost, , (v)
	S.FovBoost = v
	  v  camera.FieldOfView = S.Enabled  S.BaseFov  defaultFov 
)
(p1, , , , S.BaseFov, , , , (v) S.BaseFov = v )
(p1, , , , S.FovIntensity, , , , (v) S.FovIntensity = v )
(p1, , , , S.FovMax, , , , (v) S.FovMax = v )
(p1, , S.ShowHud, , (v) S.ShowHud = v )

 p2 = pageFrames[]
(p2, , )
(p2, , , , S.GroundSpeed, , , , (v)
	S.GroundSpeed = v
	 S.Enabled   _, hum = ()  hum  hum.WalkSpeed = v  
)
(p2, , , , S.JumpPower, , , , (v)
	S.JumpPower = v
	 S.Enabled   _, hum = ()  hum  hum.JumpPower = v  
)
(p2, , S.SetGravity, , (v)
	S.SetGravity = v
	 S.Enabled  .Gravity = v  S.Gravity  defaultGravity 
)
(p2, , , , S.Gravity, , , , (v)
	S.Gravity = v
	 S.Enabled  S.SetGravity  .Gravity = v 
)

(p2, , )
(p2, , , , S.AirAccelerate, , , , (v) S.AirAccelerate = v )
(p2, , , , .(S.AirCap * UPS), , , , (v) S.AirCap = v / UPS )
(p2, , , , .(S.MinBhopSpeed * UPS), , , , (v) S.MinBhopSpeed = v / UPS )
(p2, , , , .(S.MaxSpeed * UPS), , , , (v) S.MaxSpeed = v / UPS )
(p2, , , , S.LandBoost, , , , (v) S.LandBoost = v )
(p2, , S.BackwardsBhop, , (v) S.BackwardsBhop = v )
(p2, , S.AutoStrafe, , (v) S.AutoStrafe = v )

 p3 = pageFrames[]
(p3, , )
(p3, , S.Surf, , (v) S.Surf = v )
(p3, , , , S.SurfMinAngle, , , , (v) S.SurfMinAngle = v )
(p3, , , , S.SurfMaxAngle, , , , (v) S.SurfMaxAngle = v )
(p3, , , , S.SurfDetect, , , , (v) S.SurfDetect = v )

(p3, , )
(p3, , , , S.SurfAccel, , , , (v) S.SurfAccel = v )
(p3, , , , S.SurfGravity, , , , (v) S.SurfGravity = v )
(p3, , , , S.SurfFriction, , , , (v) S.SurfFriction = v )

 hintRow = .()
hintRow.Size = .(, , , )
hintRow.BackgroundTransparency = 
hintRow.Font = .Font.Gotham
hintRow.TextSize = 
hintRow.TextWrapped = 
hintRow.TextColor3 = TXT_DIM
hintRow.TextXAlignment = .TextXAlignment.Left
hintRow.Text = 
hintRow.LayoutOrder = 
hintRow.Parent = p3

toggleFromKeybind = (v) (v, ); (v) 

 hud = .()
hud.Size = .(, )
hud.Position = .(, , , -)
hud.AnchorPoint = .(, )
hud.BackgroundColor3 = BG0
hud.BackgroundTransparency = 
hud.BorderSizePixel = 
hud.Visible = 
hud.Parent = gui
(hud, )
 hudStroke = (hud, LINE, , )

 speedLbl = .()
speedLbl.Size = .(, , , )
speedLbl.Position = .(, )
speedLbl.BackgroundTransparency = 
speedLbl.Font = .Font.GothamBold
speedLbl.TextSize = 
speedLbl.TextColor3 = TXT
speedLbl.TextTransparency = 
speedLbl.Text = 
speedLbl.Parent = hud

 unitLbl = .()
unitLbl.Size = .(, , , )
unitLbl.Position = .(, )
unitLbl.BackgroundTransparency = 
unitLbl.Font = .Font.GothamMedium
unitLbl.TextSize = 
unitLbl.TextColor3 = TXT_DIM
unitLbl.TextTransparency = 
unitLbl.Text = 
unitLbl.Parent = hud

 speedBarBg = .()
speedBarBg.Size = .(, -, , )
speedBarBg.Position = .(, , , -)
speedBarBg.BackgroundColor3 = LINE
speedBarBg.BackgroundTransparency = 
speedBarBg.BorderSizePixel = 
speedBarBg.Parent = hud
(speedBarBg, )

 speedBar = .()
speedBar.Size = .(, , , )
speedBar.BackgroundColor3 = ACCENT
speedBar.BorderSizePixel = 
speedBar.Parent = speedBarBg
(speedBar, )

 hudShown = 
(RunService.RenderStepped, ()
	 wantHud = S.Enabled  S.ShowHud
	 wantHud ~= hudShown 
		hudShown = wantHud
		 wantHud  hud.Visible =  
		 tt = wantHud    
		(hud, FAST, { BackgroundTransparency = wantHud     })
		(hudStroke, FAST, { Transparency = wantHud     })
		(speedLbl, FAST, { TextTransparency = tt })
		(unitLbl, FAST, { TextTransparency = tt })
		(speedBarBg, FAST, { BackgroundTransparency = wantHud     })
		 tb = (speedBar, FAST, { BackgroundTransparency = tt })
		  wantHud  tb.Completed:(()   hudShown  hud.Visible =   ) 
	
	  S.Enabled   S.ShowHud   
	 _, hum, root = ()
	  root   
	 speed = (root.AssemblyLinearVelocity).Magnitude
	 ups = .(speed * UPS)
	speedLbl.Text = (ups)
	 t = .((ups - ) / , , )
	speedLbl.TextColor3 = TXT:(ACCENT, t)
	 barRel = .(ups / , , )
	(speedBar, TweenInfo.(, .EasingStyle.Linear), { Size = .(barRel, , , ) })
	speedBar.BackgroundColor3 = surfing  .(, , )  (ups >=   ACCENT  TXT_DIM)
	 surfing 
		unitLbl.Text = 
	 hum  hum.FloorMaterial == .Material.Air 
		unitLbl.Text = 
	
		unitLbl.Text = 
	
)


	 dragging = 
	 dragStart, startPos = , 
	 targetPos = main.Position

	(header.InputBegan, (input)
		 input.UserInputType == .UserInputType.MouseButton1 
			dragging = 
			dragStart = input.Position
			startPos = main.Position
			targetPos = main.Position
		
	)
	(UIS.InputChanged, (input)
		 dragging  input.UserInputType == .UserInputType.MouseMovement 
			 d = input.Position - dragStart
			targetPos = .(startPos.X.Scale, startPos.X.Offset + d.X, startPos.Y.Scale, startPos.Y.Offset + d.Y)
		
	)
	(UIS.InputEnded, (input)
		 input.UserInputType == .UserInputType.MouseButton1  dragging =  
	)

	
	(RunService.RenderStepped, (dt)
		 cur = main.Position
		 a =  - .(-dt * )
		main.Position = .(
			targetPos.X.Scale,
			cur.X.Offset + (targetPos.X.Offset - cur.X.Offset) * a,
			targetPos.Y.Scale,
			cur.Y.Offset + (targetPos.Y.Offset - cur.Y.Offset) * a
		)
	)


 closed = 
  ()
	 closed   
	closed = 
	S.Enabled = 
	()
	 _, c  (conns) 
		(() c:() )
	
	.(conns)
	 tw = (main, TweenInfo.(, .EasingStyle.Quint, .EasingDirection.In), {
		Size = .(MENU_W * , MENU_H * ),
		BackgroundTransparency = ,
	})
	tw.Completed:(() gui:() )


 menuVisible = 
  (v)
	 closed   
	menuVisible = v
	 v 
		main.Visible = 
		main.Size = .(MENU_W * , MENU_H * )
		main.BackgroundTransparency = 
		(main, TweenInfo.(, .EasingStyle.Quint, .EasingDirection.Out), { Size = .(MENU_W, MENU_H) })
		(main, FAST, { BackgroundTransparency =  })
	
		 tw = (main, TweenInfo.(, .EasingStyle.Quint, .EasingDirection.In), {
			Size = .(MENU_W * , MENU_H * ),
			BackgroundTransparency = ,
		})
		tw.Completed:(()   menuVisible  main.Visible =   )
	


menuFromKeybind = () ( menuVisible) 
closeBtn.MouseButton1Click:(() () )

.(()
	(, )
	(, )
)

()
( .. S.ToggleKey.Name ..  .. S.MenuKey.Name .. )