SkillAgentSearch skills...

roblox-datastores

Roblox DataStoreService persistence: load on join, save on leave and BindToClose, UpdateAsync vs SetAsync, session locking and OrderedDataStore leaderboards. Use for lost player data, items duplicating after teleport, or "too many requests" errors.

Install / Use

npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill roblox-datastores

Installs into whichever agent you are using.

About this skill
πŸ“„

SKILL.md

Installable skill definition

Quality Score

95/100

Supported Platforms

Universal

Tags

Our assessment of roblox-datastores

roblox-datastores scores 95/100 on our quality scale, 289th of 4,700 Development & Engineering skills we index (top 7%).

Its SKILL.md is 7.5 KB long, well organised into 13 sections with 6 code examples: a thorough specification that gives an agent plenty to work with.

With 8,904 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
29/30
Structure
20/20
Description
15/15
Adoption
17/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 4 days ago, so roblox-datastores is actively maintained.
  • Our last check on 2026-11-15 found the source still online.
  • It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit β€” read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk β€” read a skill before letting an agent act on it.

roblox-datastores compared with similar skills

All 4 of these similar skills score higher than roblox-datastores; compare them before choosing.

SkillScoreStarsUpdatedFormat
roblox-datastores (this skill)by gamedev-skills958.9k4d agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
ai-job-searchby ai-job-search-dev10072.1ktodayCLAUDE.md
claude-howtoby luongnv8910047.3k2d agoCLAUDE.md
lobehubby lobehub10085.6ktodayMCP Server

Frequently asked questions

How do I install roblox-datastores?
Run npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill roblox-datastores. The install tabs above show the steps for each supported agent.
Which AI agents does roblox-datastores work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is roblox-datastores safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is roblox-datastores still maintained?
The repository was last updated 4 days ago, so roblox-datastores is actively maintained.

name: roblox-datastores description: > Persist player data in Roblox with DataStoreService: GetDataStore, GetAsync/ SetAsync/UpdateAsync/IncrementAsync wrapped in pcall, load-on-join and save-on-leave plus BindToClose, retries, and OrderedDataStore leaderboards. Use when saving or loading persistent data in a Roblox experience β€” when the user mentions DataStore, DataStoreService, GetAsync, SetAsync, UpdateAsync, save player data, or leaderboards. For general Luau scripting use roblox-luau.

Roblox DataStores

Persist data across sessions in Roblox with DataStoreService: loading on join, saving on leave and shutdown, safe updates, retries, and ordered stores for leaderboards. Server-side only.

When to use

  • Use to save/load player progress (coins, inventory, levels), build persistent leaderboards, or fix data loss, overwrites, and throttling.
  • Use when server code calls DataStoreService, GetDataStore, GetAsync, SetAsync, UpdateAsync, or GetOrderedDataStore.

When not to use: general scripting, services, remotes, the client/server split β†’ roblox-luau. High-frequency temporary state (matchmaking, per-round) β†’ memory stores (a different service). Engine-agnostic persistence theory β†’ save-systems.

Core workflow

  1. Enable Studio access once. File β†’ Game Settings β†’ Security β†’ Enable Studio Access to API Services (use a test place; Studio hits live data). DataStores work only from server Scripts, never LocalScripts.
  2. Get a store, then read/write by key. DataStoreService:GetDataStore("Name"); key per player is usually "Player_" .. player.UserId.
  3. Wrap every call in pcall. GetAsync/SetAsync/UpdateAsync are network calls that can fail; an unguarded failure errors the thread and risks data loss.
  4. Load on PlayerAdded, save on PlayerRemoving, and also BindToClose. A leaving player and a shutting-down server both need a final save.
  5. Prefer UpdateAsync for read-modify-write (multi-server safe) over SetAsync (blind overwrite). On a failed load, do not overwrite with defaults β€” abort the save so you don't wipe good data.
  6. Use OrderedDataStore for ranked data (leaderboards) via GetSortedAsync. Test by joining, changing data, rejoining, and confirming it persisted.

Patterns

1. Load on join (pcall-guarded)

local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")
local store = DataStoreService:GetDataStore("PlayerData")

local DEFAULT = { Coins = 0, Level = 1 }

Players.PlayerAdded:Connect(function(player)
    local key = "Player_" .. player.UserId
    local ok, data = pcall(function()
        return store:GetAsync(key)
    end)

    if not ok then
        -- Load FAILED (network). Do not treat as a new player; flag so we never save
        -- over their real data with defaults.
        warn("Load failed for", player.Name, data)
        player:SetAttribute("DataLoaded", false)
        return
    end

    player:SetAttribute("DataLoaded", true)
    local profile = data or DEFAULT          -- nil == genuinely new player
    applyToLeaderstats(player, profile)
end)

2. Save with UpdateAsync (multi-server safe)

-- UpdateAsync reads the latest value, then writes what the callback returns.
-- The callback MUST NOT yield (no task.wait, no further Async calls inside it).
local function savePlayer(player)
    if player:GetAttribute("DataLoaded") == false then return end  -- never overwrite on a bad load
    local key = "Player_" .. player.UserId
    local newData = gatherDataFor(player)    -- a plain table of serializable values

    local ok, err = pcall(function()
        store:UpdateAsync(key, function(old)
            -- merge/decide here; return nil to cancel the write
            return newData
        end)
    end)
    if not ok then warn("Save failed for", player.Name, err) end
end

3. Save on leave AND on shutdown

Players.PlayerRemoving:Connect(savePlayer)

-- BindToClose runs when the server shuts down; save everyone still in.
-- It has a limited time budget, so save in parallel and yield until done.
game:BindToClose(function()
    local players = Players:GetPlayers()
    local remaining = #players
    if remaining == 0 then return end
    for _, player in players do
        task.spawn(function()
            savePlayer(player)
            remaining -= 1
        end)
    end
    while remaining > 0 do task.wait() end
end)

4. Retry with backoff (transient failures)

local function withRetry(fn, attempts)
    attempts = attempts or 3
    for i = 1, attempts do
        local ok, result = pcall(fn)
        if ok then return true, result end
        if i < attempts then task.wait(2 ^ i) end   -- 2s, 4s, ... backoff
    end
    return false
end

local ok, data = withRetry(function() return store:GetAsync(key) end)

5. Increment a counter

-- IncrementAsync is a convenience for integer read-modify-write (still wrap it).
local ok, newTotal = pcall(function()
    return store:IncrementAsync("Visits_" .. player.UserId, 1)
end)

6. Leaderboard with OrderedDataStore

local boards = DataStoreService:GetOrderedDataStore("Coins")

-- Write a player's score (call when it changes, not every frame).
pcall(function() boards:SetAsync("Player_" .. player.UserId, coins) end)

-- Read the top 10, descending.
local ok, pages = pcall(function()
    return boards:GetSortedAsync(false, 10)   -- ascending=false β†’ highest first
end)
if ok then
    for rank, entry in ipairs(pages:GetCurrentPage()) do
        print(rank, entry.key, entry.value)   -- entry.value is the number
    end
end

Pitfalls

  • Unhandled failure wipes progress β†’ always pcall Async calls; on a failed load, mark the session and refuse to save so defaults never overwrite real data.
  • SetAsync race between servers β†’ two servers writing the same key can clobber each other. Use UpdateAsync for read-modify-write so each write sees the latest.
  • Yielding inside the UpdateAsync callback β†’ the callback can't call task.wait or other Async functions; compute the new value beforehand and return it.
  • No BindToClose save β†’ players in the server at shutdown lose unsaved progress; add game:BindToClose and wait for saves to finish within its budget.
  • Throttling / "too many requests" β†’ respect per-key and per-minute limits; don't save on every value change. Batch and save on a timer / on leave. GetAsync is cached briefly, so immediate re-reads may be stale.
  • Storing non-serializable values β†’ only JSON-serializable data persists: numbers, strings, booleans, and tables with string/number keys. Instances, Vector3, CFrame, and functions do not β€” serialize them to plain tables first.
  • Testing without API access β†’ DataStores silently can't be used in Studio until Enable Studio Access to API Services is on (and they don't work from a LocalScript).
  • DataStoreKeyInfo is nil for ordered stores β†’ OrderedDataStore doesn't support versioning/metadata; use a regular DataStore when you need those.

References

  • For session locking (preventing duplicate data across servers), versioning/ metadata with DataStoreSetOptions, ordered-store pagination (AdvanceToNextPageAsync), the key error codes and request limits, and Right-to-be-Forgotten compliance, read references/sessions-and-limits.md.

Related skills

  • roblox-luau β€” services, instances, events, and the server/client model.
  • save-systems β€” engine-agnostic serialization, slots, and migration.

Related Skills

View on GitHub
GitHub Stars8.9k
CategoryDevelopment
Updated4d ago
Forks905

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit β€” see the Safety scan above for what the skill file itself contains.

No cautions
roblox-datastores β€” Universal Skill: Install & Safety Check | SkillAgent