How to make a pet that follows you in Roblox Studio

How a following pet works

Two attachments mark two points: one inside the pet, and one on the player's root part, a few studs to the side. AlignPosition pushes the pet's attachment toward the player's, and AlignOrientation turns the pet to face the same way as the player. Because these are physics constraints, the pet accelerates and slows down smoothly, and it never needs a script running every frame.

The last piece is network ownership. By default the server simulates unanchored parts, and Roblox may hand a part to a nearby player's device. A player's own device always simulates their character. If the server simulated the pet, the owner would see it chase a character that is already a little ahead. Handing the pet to the same device as the character keeps them in step.

Step 1: Make the pet model

1. Build or insert a small pet: a few parts, or a mesh from the Creator Store. Keep it about 2 studs across.
2. Group it into a Model (select the parts, Ctrl+G) and name it Pet.
3. Weld the parts together: for each part other than the main one, insert a WeldConstraint into it and set its Part0 to the main part and Part1 to that part.
4. Select the Model and set its PrimaryPart to the main body part.
5. Drag the Model into ServerStorage.

Step 2: Add the follow script

Insert a Script named PetFollow in ServerScriptService:

-- Script in ServerScriptService named PetFollow.
-- Gives every player a copy of ServerStorage.Pet that floats beside them.
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

local OFFSET = Vector3.new(3, 1, 2) -- studs right, up and behind the player
local RESPONSIVENESS = 15 -- higher follows more tightly, lower drifts behind more

local petTemplate = ServerStorage:WaitForChild("Pet") :: Model

local function givePet(player: Player, character: Model)
	local root = character:WaitForChild("HumanoidRootPart") :: BasePart
	local pet = petTemplate:Clone()
	local petRoot = pet.PrimaryPart
	if not petRoot then
		warn("PetFollow: set the PrimaryPart of ServerStorage.Pet")
		return
	end

	-- The pet must not push the player around or weigh them down
	for _, part in pet:GetDescendants() do
		if part:IsA("BasePart") then
			part.Anchored = false
			part.CanCollide = false
			part.Massless = true
		end
	end

	-- Two attachments: one in the pet, one beside the player where the pet should be
	local petAttachment = Instance.new("Attachment")
	petAttachment.Parent = petRoot
	local target = Instance.new("Attachment")
	target.Name = "PetTarget"
	target.Position = OFFSET
	target.Parent = root

	local align = Instance.new("AlignPosition")
	align.Attachment0 = petAttachment
	align.Attachment1 = target
	align.Responsiveness = RESPONSIVENESS
	align.MaxForce = 100000
	align.Parent = petRoot

	local turn = Instance.new("AlignOrientation")
	turn.Attachment0 = petAttachment
	turn.Attachment1 = target
	turn.Responsiveness = RESPONSIVENESS
	turn.MaxTorque = 100000
	turn.Parent = petRoot

	pet.Name = player.Name .. "Pet"
	pet:PivotTo(root.CFrame * CFrame.new(OFFSET))
	pet.Parent = character -- destroyed with the character on respawn
	-- The player's device already simulates their character, so let it move the pet too
	petRoot:SetNetworkOwner(player)
end

Players.PlayerAdded:Connect(function(player: Player)
	player.CharacterAdded:Connect(function(character: Model)
		givePet(player, character)
	end)
end)

Each time a character spawns, the script clones the pet, makes every part unanchored, non-colliding and massless, and adds the two attachments and constraints. MaxForce and MaxTorque are high so the constraints can always win against gravity. The pet is placed at its spot with PivotTo before it is parented, so it does not fly in from the middle of the map.

SetNetworkOwner(player) has to be called from the server, after the pet is in the Workspace. Roblox's network ownership page describes it as the way to choose which device simulates a part.

Step 3: Make it bob

A pet that floats up and down looks alive. Since the owner's device simulates the pet, a LocalScript on that device can move the target attachment, and the constraint follows. Other players see the result. Add this LocalScript to StarterPlayerScripts:

-- LocalScript in StarterPlayerScripts named PetBob.
-- Makes the local player's pet bob up and down by moving the point it follows.
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local BOB_HEIGHT = 0.5 -- studs up and down
local BOB_SPEED = 3 -- higher bobs faster (3 is about one bob every 2 seconds)

local player = Players.LocalPlayer
local baseY: number? = nil

RunService.RenderStepped:Connect(function()
	local character = player.Character
	local root = character and character:FindFirstChild("HumanoidRootPart")
	local target = root and root:FindFirstChild("PetTarget")
	if not (target and target:IsA("Attachment")) then
		baseY = nil
		return
	end
	local y = baseY or target.Position.Y
	baseY = y
	local p = target.Position
	target.Position = Vector3.new(p.X, y + math.sin(os.clock() * BOB_SPEED) * BOB_HEIGHT, p.Z)
end)

The attachment's new position stays on the owner's device, but because that device runs the pet's physics, the pet's movement reaches everyone.

Equipping, several pets and pets from eggs

For several pets, give each its own target attachment with a different OFFSET, for example in a circle around the player. For pets the player owns, keep the owned pet names in a folder on the player and clone the matching model from a Pets folder in ServerStorage. The egg hatching guide fills that folder, and the inventory guide shows how to equip and save items.

Test it

1. Press Play. A pet appears beside you and follows as you walk, jump and turn.
2. Reset your character: a fresh pet appears with the new character.
3. Start a 2-player test and watch the other player's pet from your screen: it should move smoothly too.

Common errors and fixes

Watch the Output window for warnings from PetFollow.

Build it with RoCode

If you would rather not set this up by hand, RoCode can build it in the place you have open. RoCode is an independent AI agent for Roblox Studio, not made by Roblox: you describe the change in a web chat, and its Studio plugin creates the model and scripts in your Explorer.

For a pet game, RoCode can also insert a ready-made pet inventory and egg hatching screen from its premium UI kits in one step, in five themes (candy, neon, gold, blocky, pastel), with working server scripts. After a build its test robot can walk around in Studio and report PASS or FAIL, but it checks only what it chose to test. How RoCode connects to Studio.

Questions

Sources and further reading

• Roblox Creator Docs: AlignPosition. attachments, Responsiveness and MaxForce
• Roblox Creator Docs: AlignOrientation. matching the player's facing
• Roblox Creator Docs: Network ownership. who simulates a part and SetNetworkOwner
• Roblox Creator Docs: BasePart. Massless and CanCollide

How the code was checked: every script on this page passes Luau's strict type checker against Roblox's API definitions (luau-lsp, 23 October 2026). A type check catches misspelt APIs and wrong types, not game logic, so playtest in Studio before you publish.