How to add sprinting on Shift in Roblox Studio

Sprinting is one property — Humanoid.WalkSpeed — and everything that makes it feel good is what you do around it: how fast it ramps, whether the camera reacts, and whether it costs anything. The bare version is fifteen lines and takes a minute. The rest of this page is the difference between that and something that feels like a game.

-- StarterPlayer > StarterPlayerScripts > SprintClient  (a LocalScript)

local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
local ContextActionService = game:GetService("ContextActionService")
local TweenService = game:GetService("TweenService")

local WALK_SPEED = 16     -- Roblox's default
local SPRINT_SPEED = 26
local RAMP_TIME = 0.25    -- seconds to reach full speed. 0 = instant, and worse.

local player = Players.LocalPlayer

local humanoid
local speedTween

local function setSpeed(target)
	if not humanoid or humanoid.Health <= 0 then return end
	if speedTween then speedTween:Cancel() end
	speedTween = TweenService:Create(
		humanoid,
		TweenInfo.new(RAMP_TIME, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
		{ WalkSpeed = target }
	)
	speedTween:Play()
end

local function handleSprint(_actionName, inputState)
	if inputState == Enum.UserInputState.Begin then
		setSpeed(SPRINT_SPEED)
	elseif inputState == Enum.UserInputState.End or inputState == Enum.UserInputState.Cancel then
		setSpeed(WALK_SPEED)
	end
	return Enum.ContextActionResult.Pass
end

local function onCharacter(character)
	humanoid = character:WaitForChild("Humanoid")
	humanoid.WalkSpeed = WALK_SPEED
end

if player.Character then onCharacter(player.Character) end
player.CharacterAdded:Connect(onCharacter)

-- ContextActionService rather than UserInputService.InputBegan, on purpose.
-- It gives you the mobile button for free (the last argument), it handles the
-- case where the player alt-tabs mid-sprint by firing Cancel, and unbinding is
-- one call instead of tracking two connections.
ContextActionService:BindAction("Sprint", handleSprint, true, Enum.KeyCode.LeftShift, Enum.KeyCode.RightShift)
ContextActionService:SetTitle("Sprint", "Run")

Nearly every sprint tutorial uses UserInputService.InputBegan. It works. It also leaves you writing three things by hand that you get free here.

• Mobile. The true in the BindAction call creates a touch button on phones. Without it, no phone player can sprint, and phones are most of Roblox.
• Alt-tab. If the window loses focus mid-sprint, ContextActionService fires Cancel. With raw input events the key-up never arrives and the player comes back permanently sprinting.
• Turning it off. A cutscene, a menu, a no-sprint zone: UnbindAction("Sprint") and it is gone, mobile button included.

Returning Enum.ContextActionResult.Pass matters too — it lets Shift keep doing whatever else it does, notably shift-lock, instead of swallowing the key.

Setting WalkSpeed = 26 directly is instant, and instant is the tell. Real acceleration is what your eye reads as weight. A quarter-second Quad-out tween is barely perceptible as a tween and completely changes how the character feels to control.

Widening the field of view while sprinting is the oldest trick in first-person games and it costs eight lines. Speed is relative and the player has nothing to compare against; pulling the FOV out makes the edges of the screen move faster, which reads as acceleration even though the number barely moved.

-- Optional but it is most of the effect. Add near the top:
local camera = workspace.CurrentCamera
local FOV_WALK = 70       -- Roblox's default
local FOV_SPRINT = 78

local fovTween

local function setFov(target)
	if fovTween then fovTween:Cancel() end
	fovTween = TweenService:Create(
		camera,
		TweenInfo.new(RAMP_TIME, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
		{ FieldOfView = target }
	)
	fovTween:Play()
end

-- then call setFov(FOV_SPRINT) / setFov(FOV_WALK) alongside each setSpeed call.

Keep it subtle. 70 to 78 is a nudge. Going to 90 induces motion sickness in a fraction of players and is one of the more common reasons people quietly stop playing a game.

Unlimited sprint means nobody ever walks, which means you built one movement speed with extra steps. Stamina is what makes the choice mean something.

-- Stamina: sprinting becomes a resource instead of a toggle.

local RunService = game:GetService("RunService")

local MAX_STAMINA = 5        -- seconds of sprint
local DRAIN_RATE = 1         -- per second while sprinting
local REGEN_RATE = 0.6       -- per second while not
local REGEN_DELAY = 1        -- seconds after you stop before it refills
local MIN_TO_START = 0.5     -- stops the 0.05-second stutter sprint

local stamina = MAX_STAMINA
local sprintHeld = false
local sprinting = false
local lastDrain = 0

local function stopSprint()
	sprinting = false
	setSpeed(WALK_SPEED)
	setFov(FOV_WALK)
end

local function startSprint()
	if stamina < MIN_TO_START then return end
	sprinting = true
	setSpeed(SPRINT_SPEED)
	setFov(FOV_SPRINT)
end

RunService.Heartbeat:Connect(function(deltaTime)
	if sprinting then
		-- Only drain while actually moving. Holding Shift standing still
		-- costing stamina is the single most common complaint about this
		-- mechanic, and the fix is one condition.
		local moving = humanoid and humanoid.MoveDirection.Magnitude > 0
		if moving then
			stamina -= DRAIN_RATE * deltaTime
			lastDrain = os.clock()
			if stamina <= 0 then
				stamina = 0
				stopSprint()
			end
		end
	elseif os.clock() - lastDrain > REGEN_DELAY then
		stamina = math.min(MAX_STAMINA, stamina + REGEN_RATE * deltaTime)
		-- Resume automatically if the key is still down and you have recovered.
		if sprintHeld and stamina >= MIN_TO_START then
			startSprint()
		end
	end
end)

-- and handleSprint becomes:
--   Begin -> sprintHeld = true;  startSprint()
--   End   -> sprintHeld = false; stopSprint()

Three details in there are the difference between stamina people tolerate and stamina people hate. Only draining while actually moving, so holding Shift while standing still is free. A regen delay, so the bar does not visibly yo-yo. And MIN_TO_START, which stops the player re-triggering sprint with 0.05 seconds of stamina and stuttering in and out of it every frame.

-- StarterGui > StaminaGui  (ScreenGui) > Bar (Frame) > Fill (Frame)
-- Fill.Size = UDim2.fromScale(1, 1), AnchorPoint (0, 0.5), Position (0, 0.5)

local fill = script.Parent.Bar.Fill

-- In the Heartbeat loop above:
fill.Size = UDim2.fromScale(stamina / MAX_STAMINA, 1)
fill.BackgroundColor3 = stamina < MIN_TO_START
	and Color3.fromRGB(220, 90, 90)
	or Color3.fromRGB(120, 200, 140)

-- Hide it when it is full and nothing is happening, so the HUD is not
-- permanently occupied by a bar that is permanently at 100%.
script.Parent.Bar.Visible = stamina < MAX_STAMINA

Hiding the bar at full is worth the one line. A HUD element that is permanently at 100% is permanently ignored, and it makes the moment it starts dropping much more legible.

Yes, and it always was. The client owns its own character’s physics — Humanoid.WalkSpeedset on the client replicates because Roblox is designed for that. Someone running a modified client can set it to 200 whether or not you wrote this script. Adding a RemoteEvent so “the server sets the speed” does not change this: the server sets a property the client can immediately overwrite.

So do not build a defence you cannot hold. What you can do, if speed is worth something in your game, is validate the outcome on the server — positions per second between samples, checkpoint times, the actual thing being cheated for — and act on a sustained pattern rather than a single frame. For an obby, a hangout, a showcase, or anything without a competitive reward, this is not worth writing.

Worth knowing before you rely on any tool that says it verified a sprint for you. A Roblox Studio plugin is not permitted to synthesise keyboard input — VirtualInputManagerthrows for anything that is not Roblox’s own code. So a sprint that only misbehaves when you actually hold Shift passes every automated check that can exist, including ours.

Hold the key yourself. That is the test.