Log in
Login Sign up Blog Tools

Roblox PlayerCharacterDestroyBehavior Explained: What Changed on November 11 and How to Fix Your Data Saving

Since November 11, 2026, Roblox destroys player and character instances by default when someone leaves or respawns. If your data-saving script reads values after a yield, it now reads nothing. Here is what changed and how to fix it.

Roblox PlayerCharacterDestroyBehavior Explained: What Changed on November 11 and How to Fix Your Data Saving
In this guide What PlayerCharacterDestroyBehavior Does What Changed on November 11 Why Roblox Made the Change The Code That Breaks Now The Same Rule Applies to CharacterRemoving How to Test Your Game Now The Emergency Fallback — and When It Disappears The Habit That Prevents This Class of Bug Frequently Asked Questions What is PlayerCharacterDestroyBehavior? When did the default change? Will my game's data saving break? How do I fix a PlayerRemoving data-saving script? Can I turn PlayerCharacterDestroyBehavior off? Does this change anything on the client? Related Guides on RBXMods Sources

On Wednesday, November 11, 2026, a quiet default changed in every Roblox game. PlayerCharacterDestroyBehavior — the Players service setting that controls what happens to a player's instance when they leave, and to their character when they respawn — switched from doing nothing to destroying those instances. If your game was set to Default, it now behaves as if you had chosen Enabled. Most games will never notice, but if your data-saving script reads a player's values after a pause, it may now be reading an instance that no longer exists. This guide explains what the change does, which code it breaks, and the one-line habit that fixes it.

Key takeaways

  • Since Wednesday, November 11, 2026, Default behaves as Enabled: the engine destroys the Player instance 5 seconds after PlayerRemoving handlers finish, and the character model as soon as CharacterRemoving handlers finish.
  • The point is server memory. Old player and character instances were a common source of leaks; destroying them promptly frees that memory.
  • The breaking pattern is a PlayerRemoving or CharacterRemoving handler that yields — a task.wait or a DataStore call — before reading the values it needs.
  • The fix: capture everything you need into local variables at the top of the handler, before any yield. Keep persistent state on the Player or in a server table, never on the character.
  • You can still set the behavior to Disabled as an emergency measure, but only temporarily — Roblox plans to remove the disable option by the end of February 2027, when it becomes mandatory.

What PlayerCharacterDestroyBehavior Does

Every Roblox game has a Players service, and that service has a property called PlayerCharacterDestroyBehavior, with three values: Default, Disabled and Enabled. It answers one question: when a player leaves, or a character is removed, does the engine destroy the old instances, or leave them sitting in memory?

With the behavior enabled, two things happen. When a player leaves, the engine runs your PlayerRemoving handlers, waits 5 seconds, then destroys the Player instance. When a character is removed — on death, on respawn, on leaving — the engine runs your CharacterRemoving handlers and destroys the model immediately. The 5-second delay is deliberate: it gives data-saving scripts a short window to finish. The character side gets no delay, because a new character is about to replace the old one.

With the behavior disabled, none of that happens. Old Player and character instances linger until the engine cleans them up on its own schedule — how games accumulated memory leaks, as every leaver and respawn left objects behind and a busy server slowly filled with instances nobody was using. Developers could opt in to the destroying behavior for about three years before this change. Now it is the default.

What Changed on November 11

Before November 11, 2026, an experience set to Default behaved as if the setting were Disabled: nothing was destroyed. From November 11, Default behaves as Enabled. That is the whole change, and it is easy to miss, because nothing in Studio looks different — the property still says Default; the behavior behind it is what moved.

Three cases to know. If your game was already Enabled, nothing changed — you were already living with this behavior. If it was Default, which is most games, the new behavior switched on automatically on November 11. If it was Disabled, it stays disabled for now — but that case has an expiry date, covered below.

The practical effect is that code which assumed the Player or character instance would still be there a few seconds after leaving or respawning is now wrong — that window was always undocumented and unreliable, and now it is closed. If your game has run fine since November 11, your code was probably already safe. If players report lost coins, missing wins or leaderstats that reset, this change is the first place to look.

Why Roblox Made the Change

The reason is server memory: the change targets a common source of server memory leaks, old character instances that were never destroyed. A game with hundreds of players joining, dying and leaving over hours accumulates a large pile of dead instances, each one costing memory, until the server slows down or crashes — the kind of bug that looks like lag or random disconnects rather than a scripting error.

Destroying the instances promptly is the engine doing cleanup your scripts used to be responsible for. It is a trade: you lose the ability to poke at a departed player's instance after the fact, and your servers stop leaking memory from every leaver. For most games that is a good trade. The cost lands on one specific script pattern — and it was already fragile.

Illustration of a game server clearing away old player character models while new ones spawn in, showing memory being freed up

The Code That Breaks Now

The pattern that breaks is a PlayerRemoving handler that pauses before it reads. Here is the classic version, the way thousands of data-saving scripts are written:

local Players = game:GetService("Players")

Players.PlayerRemoving:Connect(function(player)
	task.wait(2) -- give the save a moment
	local coins = player.leaderstats.Coins.Value
	-- save coins to the DataStore
end)

Before November 11, this usually worked: the Player instance was still there after the wait, so reading leaderstats succeeded. Now the engine destroys the Player instance 5 seconds after the PlayerRemoving handlers finish — and a handler that yields is still running when the clock runs out. Read the player's values after the wait and you can be reading an instance that no longer exists. The save fails, the coins are lost, and the error shows up in the Output window, not in the game.

The fix is to capture first and yield second. Read everything you need into local variables at the very top of the handler, before any pause, and then do the slow work with those locals:

local Players = game:GetService("Players")

Players.PlayerRemoving:Connect(function(player)
	-- capture FIRST, before any yield
	local userId = player.UserId
	local coins = player.leaderstats.Coins.Value
	task.wait(2)
	-- save coins for userId to the DataStore
end)

The values are now plain numbers in local variables, which do not get destroyed. The wait and the DataStore call can take as long as they need, because nothing they touch can disappear. That is the whole fix: move the reads above the first yield, in every PlayerRemoving handler that touches player data, leaderstats or a DataStore.

The Same Rule Applies to CharacterRemoving

The character side has no 5-second buffer at all. When a character is removed, the engine runs your CharacterRemoving handlers and destroys the model immediately after, so any code that waits inside CharacterRemoving before reading the character — a Humanoid's health, a tool it was holding, a value stored on the model — is reading a model that is already gone.

The fix is identical: capture what you need first, then yield — read the character's health into a local at the top of the handler, for example. The deeper fix is the same one that applies everywhere in Roblox scripting: do not store anything permanent on the character. Coins, wins and progress belong on the Player, or in a server-side table keyed by the Player — the character is destroyed and rebuilt on every respawn, while the Player persists for the whole session. Anything attached to the character dies with it, by design.

How to Test Your Game Now

Do not guess whether your game is affected — test it. The check takes a few minutes, and it is worth doing before your players find the bug for you.

Set the behavior to Enabled explicitly. In Studio, select the Players service in the Explorer and set PlayerCharacterDestroyBehavior to Enabled in the Properties window. If your game was on Default, this changes nothing — it has been Enabled in effect since November 11 — but it makes the setting explicit.

Playtest leaving and respawning. Join with a test player, earn some coins or progress, then leave and rejoin, and die and respawn a few times. Check that leaderstats, coins and saved data survive each round trip — and do the same for any admin or GUI code that references a player's character after a respawn.

Watch the Output window. Errors from PlayerRemoving and CharacterRemoving handlers show up there — look for attempts to index a destroyed instance, or values that read as nil after a leave. If a handler errors, the save it was doing probably did not happen.

Audit every PlayerRemoving handler. Search your scripts for PlayerRemoving and CharacterRemoving, and check whether any read happens after a yield. If it does, move the read to the top of the handler. That audit is the real work — the fix is a few lines moved, not a rewrite.

The Emergency Fallback — and When It Disappears

If you find a critical problem you cannot fix right away, Roblox gives you an escape hatch: set PlayerCharacterDestroyBehavior to Disabled. That restores the old behavior while you update your code — but treat it as a short-term emergency measure, not a setting to leave on. Roblox plans to start Phase 3 by the end of February 2027, when the disable option is removed entirely and the behavior becomes mandatory for all experiences.

That deadline is the real reason to fix the code now rather than flipping the switch. Disabling buys you weeks, not a permanent opt-out, and a game that still depends on Disabled in February will have the behavior forced on with no warning. Fix the handlers, test the game, and leave the setting on Default or Enabled.

Illustration of a checklist with a calendar marking the end of February 2027, next to a script being fixed line by line

The Habit That Prevents This Class of Bug

This change is one instance of a general rule in Roblox scripting: instances disappear, and your code has to be ready for that. The habit that prevents this whole class of bug has two parts, both worth building into every new script you write.

First, state goes on the Player, behavior goes on the Character. Anything that must survive respawns — coins, wins, progress, settings — belongs on the Player object or in a server-side table keyed by the Player. Anything that only matters for one life — a Humanoid hook, a spawn effect, a per-life setup — belongs in a CharacterAdded handler, rebuilt fresh for every new character. Follow that split and a destroyed character costs you nothing, because nothing permanent was ever on it.

Second, connect first, then sweep. A PlayerAdded handler connected after a player has already joined will never fire for them, and a CharacterAdded handler connected after the character spawned will never fire for that character. Connect the event first, then run the same handler for everyone already here, using Players:GetPlayers() with task.defer — and handle player.Character if it already exists before you connect CharacterAdded. That pattern, plus capturing values before any yield, covers almost every join, leave and respawn bug you will meet.

Frequently Asked Questions

What is PlayerCharacterDestroyBehavior?

It is a property on the Players service with three values: Default, Disabled and Enabled. It controls whether the engine destroys the Player instance after a player leaves, and the character model after it is removed. Since November 11, 2026, Default behaves as Enabled.

When did the default change?

Wednesday, November 11, 2026. From that date, experiences set to Default behave as if they were set to Enabled. Experiences already set to Enabled were unchanged, and experiences set to Disabled stay disabled until Phase 3.

Will my game's data saving break?

Only if a PlayerRemoving handler reads player values after a yield, such as a task.wait or a DataStore call. If your handler captures its values into locals before any yield, it is safe. Audit every PlayerRemoving and CharacterRemoving handler to be sure.

How do I fix a PlayerRemoving data-saving script?

Move the reads to the top of the handler. Capture the UserId and every value you need into local variables before the first yield, then do the slow work — waits and DataStore calls — using those locals.

Can I turn PlayerCharacterDestroyBehavior off?

Yes, temporarily: set it to Disabled in Studio. Roblox intends that only as a short-term emergency measure while you fix your code. Phase 3, planned by the end of February 2027, removes the disable option entirely.

Does this change anything on the client?

The setting is a server-side Players property, so what changes is when the server destroys the instances. On the client, CharacterAdded and CharacterRemoving still fire as before, and StarterGui scripts still reset on respawn by default. Client code should still follow the same rule: capture what you need before any yield.

Related Guides on RBXMods

RBXMods is not affiliated with or endorsed by Roblox Corporation. Roblox and the Roblox logo are trademarks of Roblox Corporation.

Sources

Last checked against Roblox docs: November 19, 2026.

Pawan Nagare
Written by

Pawan Nagare

I'm Pawan Nagare, and I run RBXMods. I write practical Roblox guides about how games are actually made — Roblox Studio, scripting, publishing and growing a game — along with clear fixes for the errors and confusing changes players run into.

Every guide here is researched against official Roblox documentation and checked against the current version of Roblox before it is published — and I update posts when Roblox changes the rules.

My aim is simple: honest, up-to-date help that respects your time — no recycled lists, and no shortcuts that put your account at risk.