RBLX Essentials Documentation

Overview

RBLX Essentials is one ecosystem of Roblox packs your AI already knows how to install, set up and connect. You install the packs from the free Studio plugin, tell your AI what you want, and press Play. Prefer to click? The free Studio plugin has every setting.

From packs installed from the plugin card to a working game: one request, then Play.

Every pack plugs into one shared core and one save system, so a code can grant spins and pets, a daily reward can give a pet, and every pack pays into the same player data with nothing wired between them.

Every pack plugs into one shared core and one save system.
Every pack plugs into one shared core and one save system.

What changed in 3.0

  • Built to be driven by an AI. The free plugin puts Tools in your place: one library of operations (install, configure, check, migrate) that an AI agent calls through the Studio MCP, and a guide written for the AI, AI-START-HERE.md.
  • Your configuration is your game's code. Each pack with options keeps them in small modules your game owns. Updates never touch them.
  • Your interface is yours. A menu you change is copied into your own Interface folder first, so an update can never undo your design.
  • The same plugin you know. Each pack opens the same settings panel as 2.x, with its previews, now saving to the new configuration.
  • Move to 3.0 keeps your game. A 2.x place moves over in a guided check-and-approve flow and keeps your settings, your edited menus and your player data.

Pack Catalogue

PackPackIdVersionPriceDescription
Easy Pet System EasyPetSystem 3.3.5 $9.99 Eggs, hatch animations, a collection menu, merging and pets that follow the player. 28 pets in 5 rarities.
Sound System & Music Player SoundSystem 3.2.2 Free A music player on the HUD and sound effects by name, with separate Music and SFX volume. Every pack with sounds plays them through it.
General UI Kit GeneralUIKit 3.5.2 $14.99 All 14 menus, from Shop and Settings to Pets, Spin, Rebirth and Trade, with 11 HUD buttons plus Changelogs. Installed packs run the kit's menus.
Classic UI Kit ClassicUIKit 3.5.2 $14.99 The same menus and HUD as General UI Kit in a chunky Stud look, Studded or Plain. Needs no other kit.
Studded Glass UI Kit StuddedGlassUIKit 3.5.4 $14.99 The same 17 menus and HUD with studded colour pieces over dark glass, Studded or Plain. Needs no other kit.
Datastore & Purchase System DatastorePurchaseSystem 3.4.1 Free Saves player data on a timer, on leave and on shutdown, and handles game passes, developer products and gifts to other players. Every pack saves through it.
Leaderboards System EasyLeaderstatsSystem 3.2.1 $5.99 Tab-menu leaderstats and in-world global leaderboards, with the top three standing on avatar podiums.
Roulette System RouletteSystem 3.3.4 $5.99 A weighted prize wheel with real drop chances, free spins on a cooldown, paid spins and your own reward modules.
Time Rewards System TimeRewardsSystem 3.3.3 $5.99 A 7-day daily reward streak that survives a rejoin, plus timed in-session gifts on their own intervals.
Codes System CodesSystem 3.3.2 Free Redeemable codes for cash, diamonds, any stat, spins, pets or your own reward modules, with expiry dates and one redemption per player.
Notifications System NotificationsSystem 3.3.3 Free Stacking toasts, a centre banner and chat messages, which any pack can fire.

Dependency Matrix

The shared core ships inside every pack: nothing to install separately. The table below shows which packs need another one installed and which work well together. A pack you only pair with is looked up at runtime: without it, that feature goes quiet instead of breaking.

PackRequiresPairs with
Datastore & Purchase
Free
nothingEvery pack that saves player data needs it.
Sound System
Free
nothingEvery pack with sounds: General UI Kit, Notifications, Easy Pet, Codes, Roulette, Time Rewards.
Notifications System
Free
nothingDatastore & Purchase (purchase announcements), Sound System, and the packs that announce things: Easy Pet, Codes, Roulette, Time Rewards.
Codes System
Free
Datastore & PurchaseRoulette (Spins codes), Easy Pet (pet codes), Notifications, Sound System.
General UI Kit
$14.99
nothingSound System (button sounds), Datastore & Purchase (labels that show saved values), Easy Pet.
Classic UI Kit
$14.99
nothingThe same packs as General UI Kit. With both installed, the Style tab picks one.
Studded Glass UI Kit
$14.99
nothingThe same packs as General UI Kit. With more than one kit installed, the Style tab picks one.
Easy Pet System
$9.99
Datastore & PurchaseGeneral UI Kit, Notifications (new pets, refusals, rare drops), Sound System.
Leaderboards System
$5.99
Datastore & Purchasenothing else
Roulette System
$5.99
Datastore & PurchaseEasy Pet (pet slots), Notifications, Sound System.
Time Rewards System
$5.99
Datastore & PurchaseRoulette (Spins days), Easy Pet (pet days), Notifications, Sound System.

Architecture Philosophy

Built for an AI to drive. Every operation is in one library, Tools, with a guide written for the AI. The plugin calls the same library, so a person and an AI always do the same thing the same way.

The product and your game, apart. Updates replace the packs' own folders whole and never touch your configuration, your menus or your scripts, which live in zones of their own.

Configuration in code, checked. Each pack declares every option with its type, default and rules. A wrong value names the option and the pack does not start, instead of half-working in a live game.

One shared core. One Kernel boots every pack in dependency order and hands each one the others' APIs. A pack declares only the packs it cannot run without; an optional companion is looked up at runtime instead, so it never becomes mandatory.

Getting Started

Install the free plugin once, install the packs from it, then let your AI set them up, or set them up yourself in the plugin. Both paths write the same configuration, so you can switch between them at any time.

Requirements: Roblox Studio (any recent version) and the free RBLX Essentials plugin, also when an AI does the work, because the plugin is what puts Tools in your place. To work with an AI: an agent connected to Studio through the Studio MCP server, such as Claude Code, Codex or any other agent. To install the packs you bought from the plugin, the itch.io account you bought with. To test saving, a published place with Enable Studio Access to API Services turned on.

Step 1: Install the plugin

Drag the plugin file into your Plugins folder and restart Studio once.

Download the RBLX Essentials plugin (free, no sign-in). In Studio, open Plugins > Plugins Folder, drag the .rbxm file into that folder and restart Studio once. It appears as RBLX Essentials in the Plugins toolbar, and its button opens the plugin's card over the viewport.

Sign in once: enter the code at rblxessentials.com/link.
Sign in once: enter the code at rblxessentials.com/link.

The card opens on Sign in with a code. Go to rblxessentials.com/link (a plugin cannot open a browser, so the card gives you the address to copy), sign in with the itch.io account you bought with and enter the code: the card shows your packs a few seconds later. You sign in once per computer. Not now skips it for this Studio session; free packs install without signing in.


Step 2: Install the packs

My packs: press Install on any free pack or any pack you own.
My packs: press Install on any free pack or any pack you own.
  1. Open the card with the RBLX Essentials button and go to My packs. Free packs and the packs you own show Install; the others show Buy on itch.
  2. Press Install. The card shows each step (Downloading, Building, Installing, Done), and a pack that needs another one installs it first, Datastore & Purchase included.
  3. Or let your AI do it: press Copy on the card's AI tab and Tools, what your AI works with, is in the place, even with no pack yet. With the plugin signed in, your AI sees what your account owns with T.owned() and installs it through the signed-in plugin, dependencies first: T.install({ website = "CodesSystem" }).

There is no separate core to download: the shared core travels inside every pack. Dragging a pack's .rbxm from My library into your place still works too: the plugin's docked panel shows Install on it.


Step 3: Tell your AI what you want

Tell your AI what you want in plain words.

Give your agent the guide, AI-START-HERE.md (or the address rblxessentials.com/AI-START-HERE.md; the plugin has it too, with a prompt to copy, in the card's AI tab and under the docked panel's ⋯ > For your AI), and ask in plain words, for example:

Add codes, a pet shop and daily rewards. Make SUMMER25 give 250 Cash.

The agent reads what is in your place with T.describe(), installs each pack with T.install() (from the website through the signed-in plugin, or from a file you dragged in; Datastore & Purchase first, because every pack that saves needs it; T.owned() tells it what your account owns), writes the options into your configuration modules, checks everything with T.validate(), then starts Play to prove it works. Each change it makes is one Studio undo step, so Ctrl+Z takes back any of them.

Prefer to do it by hand? Press Install on each pack in the card's My packs, then change its settings in the docked panel (the card's Settings tab opens it). The plugin and your AI edit the same modules.


Step 4: Press Play

Press Play: it works straight away.

Every pack starts on its own: no bootstrap code and no wiring. Codes, pets and rewards work straight away. The Output prints one [RBLXE] boot line per side, and anything a pack needs from you is a plain warning that says what to do.


Before you publish

  • The plugin's Diagnostics (in the ⋯ menu of its docked panel) warns that Codes System's example codes are live: change or delete them. They are WELCOME2027, plus PETDAY2027 when Easy Pet System was installed before Codes System. Installing from the plugin writes them; when your AI installs with T.install, the codes arrive as an edit it still has to apply, and until it does the game has no codes. Demo product ids and game pass ids are marked on their rows in each pack's settings, and the Output names each one when you press Play.
  • FreeMode (Free mode in the plugin) in Datastore & Purchase ships off, but a game moved from 2.x keeps it on if it was on: turn it off if you do not want free purchases in Studio tests either. In 3.0 it only ever works in Studio, and a live server warns at start while it is on.
  • Test saving with a real leave and rejoin in a published test place.

Updating a pack

When a pack has a newer version, the card's My packs shows Update on it (the Updates filter lists them all) and the docked panel says Update available. Press Update, or ask your AI to run T.update({ website = PackId }). A newer file dragged in still updates too. The pack's own code and default menus are replaced; your configuration modules, your Interface copies and your extensions are never touched, and anything it replaces is copied to Backups first.


Coming from 2.x

3.0 is a free update for everyone who owns a 2.x pack: download the current 3.x file of every pack your place has from My library, drag them all in, and press Move to 3.0 in the plugin (or ask your AI to run T.migrate()). See Plugin: Move to 3.0.


Uninstalling a pack

Choose Uninstall in the More menu of the pack's page in the plugin, or ask your AI to run T.uninstall(). The pack's code leaves every service and a backup is made first; your configuration modules stay, so installing it again picks up where you left off. A pack other installed packs need cannot be uninstalled until they are.

Plugin

The plugin is the by-hand way to do everything your AI does: install packs, change every setting, check the place and move a 2.x game to 3.0. It is free, and it works the same with or without an AI agent.

It has two parts. The card, opened by the RBLX Essentials button (its only button in the Plugins toolbar), installs and updates packs and themes. The docked panel holds the settings of every pack in your place. In a place that still runs 2.x packs, the docked panel adds a Migration tab until the place moves to 3.0.

The card

Install shows each step: Downloading, Building, Installing, Done.
Install shows each step: Downloading, Building, Installing, Done.

The card floats over the viewport in Edit (it hides while the game runs) at about 85% of its height, so it reads the same on any screen; drag it by its header, minimize it or close it. It has five tabs:

  • My packs: every pack, filtered by All, Installed or Updates, each with Install, Update, Buy on itch or Get it from your library. Install shows each step (Downloading, Building, Installing, Done), or why it stopped and what to do. A pack that needs another one installs it first, and an update keeps your settings and configuration modules.
  • Style: one style for your whole game, a GUI kit and one of its styles, each a finish and a font (General UI Kit: Plain (Fredoka) or Studded (Fredoka); Classic UI Kit and Studded Glass UI Kit also Plain (Montserrat) and Studded (Montserrat)). The font comes with the style, never on its own. Each finish shows a picture, the one in use outlined; one click switches every menu at once, the packs' menus included, and Studio shows it. A GUI kit you don't have yet is shown with Install or Get it. With no GUI kit, each pack uses its own default menus.
  • AI: the guide and a prompt to paste into Claude Code, Codex or any AI agent connected to Studio. Copy selects it, then press Ctrl+C. It works signed out too.
  • Account: the itch.io and Roblox accounts this Studio is linked to, and Sign out.
  • Settings: the packs in your place, each opening its settings in the docked panel, and Pack manager on top, which opens the docked panel itself. It works signed out too.
Style: one style for the whole game, a GUI kit and its finish, one click.
Style: one style for the whole game, a GUI kit and its finish, one click.

Until this Studio is signed in, the card opens on Sign in with a code to enter at rblxessentials.com/link. Not now skips it for this Studio session, and free packs install without signing in. The sign-in key stays in the plugin's settings on this computer and is never put in your place.

The docked panel

The docked panel lists the installed packs; its header menu holds Diagnostics, Backups and For your AI.
The docked panel lists the installed packs; its header menu holds Diagnostics, Backups and For your AI.

The docked panel lists the packs installed in your place, each with its version and Up to date or Update available, and the shared core while it is in the place. Press a pack to open its settings. The quiet ⋯ in its header opens Diagnostics, Backups and For your AI (the guide and a prompt to copy, as in the card's AI tab). A pack file you dragged in shows Install or Update here.

A pack's page: the panels you know from 2.x

A pack's settings in plain words, with durations and previews.
A pack's settings in plain words, with durations and previews.

Open a pack and its Settings are the panel you know from 2.x: the same sections, editors and live previews, with every row in plain words. Times show and take durations (15 min, typed as 10 min, 1h 30m or a plain number), colours show a swatch and image ids their picture. Roulette's wheel is redrawn as you change a slot (from 2 to 12 slots), Time Rewards previews the streak rail, Codes previews its messages, Datastore shows the save a new player receives, Easy Pet spins each pet in 3D and checks that an egg's drop chances add up to 100%, and Sound measures every sound's real loudness.

Previews show what you edit: open a pet and its model turns in 3D.
The Roulette rewards with a live wheel preview above its seven slots

What is new is where the values go. Your edits collect in a Save bar at the bottom: Save writes them into your game's configuration modules, Discard drops them. A few 3.0 ideas appear as small marks, the way 2.x would draw them:

  • Locked rows with an Unlock link guard values that would change your players' saved data, such as the datastore version.
  • Server only marks an option clients never receive, such as the list of codes.
  • A note marks the demo ids you must replace with your own before you publish.

A pack's Interface lists its menus and HUD buttons; General UI Kit's is split into MENUS, BUTTONS and OTHER HUD PARTS. The eye shows one on screen, the pencil makes your own copy to edit, and Revert changes takes your copy back to the pack's version; a theme's parts go back from the card's Themes tab. The pack header's More menu has Where its files are (its data folders and your own scripts) and Uninstall.

A pet previewed in 3D inside the plugin, above its name, multiplier and rarity

Everything the plugin does is an ordinary Studio edit, so Ctrl+Z works on all of it, except Wipe Studio Data, which deletes saved Studio profiles for good.

Diagnostics

Diagnostics shows what needs attention, with the fix.
Diagnostics shows what needs attention, with the fix.

Open it from the ⋯ menu of the docked panel. It is the same check your AI runs with T.validate(): every problem in the place, each with the line that fixes it. It also lists menus no pack uses any more and what was kept from your 2.x game.

Move to 3.0

Move to 3.0 keeps your settings and your edited menus.

A 2.x place moves to 3.0 in a guided check-and-approve flow and keeps your settings, your edited menus and your player data. Nothing changes until you approve each step.

  1. Download the current 3.x file of every RBLX Essentials pack your place has (they are free for 2.x owners on My library) and drag them all in.
  2. Open the Migration tab and press Move to 3.0: it backs up your RBLX Essentials folders and converts your settings. Press Create all to write your configuration modules, then Run step 2 to move the packs. Or ask your AI: it runs T.migrate().
  3. It checks everything first and changes nothing if something is wrong, listing every problem at once.
  4. It copies your RBLX Essentials folders to a protected backup, converts every setting you had changed into your new configuration modules, keeps every menu you edited as your own copy in Interface, and carries your own scripts (custom rewards, button handlers, notification triggers) to Extensions.
  5. It ends with a short report of what it did and anything that still needs you.

A migration never touches player data. Saves keep their datastore and their keys, so players keep everything they earned.

Backups

Before anything is replaced (an update, a migration, a piece you stop using) Tools copies it to ServerStorage > RBLXEssentials > Backups. Backups, in the docked panel's ⋯ menu, lists them; each copy has a small red cross to delete it, and a protected copy asks twice. Nothing is ever deleted on its own.

Updates and the shared core

The plugin checks for newer packs when it opens, without blocking: your local packs show at once, and a pack with a newer version says Update available in the docked panel and shows Update in the card's My packs. Every pack carries the shared core, and the core only ever moves forward, so updating any one pack brings the newest core to all of them.

Guides

Short answers to the things people actually want to do. Each one works two ways: ask your AI in plain words, or do it yourself in the plugin or the Explorer.

Working with your AI

Your AI works in Studio through the Studio MCP server and does everything through Tools, one library the plugin puts in your place. Give it the guide AI-START-HERE.md once; it covers the rules, every option and every check.

OperationWhat it does
T.describe()What is installed, what waits to be installed, and what is wrong.
T.owned()The packs your signed-in account owns, which are installed, and which to install, dependencies first.
T.install(ref), T.update(ref), T.uninstall(packId)Install or update a pack from the website through the signed-in plugin ({ website = PackId }) or from a file you dragged in (by the reference T.describe() prints), or remove one.
T.config.where(packId), T.config.create(packId)Where a pack's configuration modules live, and the text to create the missing ones.
T.config.reference(packId)Every option of a pack, with its type, default and rules.
T.config.check(packId)Whether a pack's configuration is valid, naming the option that is not.
T.validate()The whole place checked before Play.
T.migrate()A 2.x place moved to 3.0.

Good requests say what the player does and what should happen: "add a code SUMMER25 that gives 250 Cash and expires at the end of August", "make day 7 of the daily rewards give a pet", "put a top-10 Cash board next to the spawn". The agent changes one thing per step, so each change is one undo step, and it reports what it changed and what still needs you (such as your own product ids).

Ask your AI for a reward the pack does not offer: it writes its own reward module.

Where everything lives

3.0 splits the place into the product, which updates replace whole, and your game's zones, which updates never touch.

ReplicatedStorage.RBLXEssentials
├── Kernel                     -- product: the shared core
├── Packs.<PackId>             -- product: manifest, Schema, Pieces, Client
├── Config.<PackId>            -- yours: options clients may read
└── Extensions.GeneralUIKit    -- yours: your button handlers

ServerScriptService.RBLXEssentials
├── Kernel, Packs.<PackId>     -- product
├── Config.<PackId>            -- yours: server-only options
└── Extensions.<PackId>        -- yours: custom rewards, triggers

StarterGui.RBLXEssentials
├── <PackId>                   -- product: each pack's default menus
├── Interface                  -- yours: the menus you changed
└── Interface.Custom           -- yours: kept, not managed

ServerStorage.RBLXEssentials
├── Tools                      -- product: the operations library
├── Content.<ContentId>        -- yours: installed themes
└── Backups                    -- yours: copies made before anything is replaced

SoundService.RBLXEssentials.SoundSystem
└── SFX, Music                 -- yours: the sound library

To change how a pack behaves, change its configuration. To change how it looks, make your own copy of its menu. Never edit the product folders: the next update replaces them.

How do I change a pack's settings?

In the plugin, open the pack, change the values and press Save. Or ask your AI. Either way the values land in two modules your game owns: ReplicatedStorage.RBLXEssentials.Config.<PackId> for options clients may read, and ServerScriptService.RBLXEssentials.Config.<PackId> for server-only ones. Each module holds only what you changed; everything else keeps its default, and a commented template lists every option. An invalid value names the option, and the pack does not start until it is fixed, so a typo can never half-work in a live game.

How do I edit a pack's interface?

Edit a pack interface like any other GUI in your place.

In the pack's Interface tab, press the pencil beside a menu. The plugin copies the pack's version into StarterGui > RBLXEssentials > Interface, shows it on screen and selects it in the Explorer. Edit that copy like any other GUI: colours, fonts, corners, images, sizes, layout. The game uses your copy from then on, and updates never touch it. Revert changes goes back to the pack's version, keeping yours in Backups.

Three rules keep a redesign working:

  1. Do not rename what the pack drives. Each pack's page lists the handful of names it fills in, like a Codes panel's TextBox or a day tile's Amount. If your copy breaks that contract, the pack's own version is used instead and Diagnostics says why.
  2. Size and position in scale, not offset. The whole kit is built that way, so an element is the same fraction of the screen on a phone as on a 4K monitor.
  3. Outlines are ScaledSize. A UIStroke with StrokeSizingMode = ScaledSize takes its Thickness as a fraction of the element's height, so a resized card keeps its border weight.

When two packs ship the same menu, only one copy is used, so you never get two. General UI Kit's Codes, Spin, Rewards, Daily Rewards and Pets menus are demos: install the pack that owns one and the pack's menu replaces the demo, keeping the changes you made to it. Settings and Shop are General UI Kit's own, so they are used over the copies Sound System and Easy Pet System ship. Diagnostics' notes say which.

How do I make a button do something of my own?

Set the button's Action attribute to a name, then add a function under that name in your game's handlers module, ReplicatedStorage > RBLXEssentials > Extensions > GeneralUIKit > CustomHandlers (in ReplicatedStorage because buttons run on the client):

-- Extensions.GeneralUIKit.CustomHandlers (yours: updates never touch it)
return {
    OpenCodes = function(button)
        -- runs when a button whose Action says "OpenCodes" is clicked
        print(button.Name, "was pressed")
    end,
}

Opening and closing panels, prompting a game pass or a developer product, and inviting friends are already handled. If the module errors, the kit says so in the Output and carries on with its own actions.

How do I add a new currency, and show it?

Gems or a premium currency are already there: the packs' second currency is Diamonds (Stats.Diamonds), which Time Rewards, Roulette and Codes give out. To call it Gems, change only the name players see. The steps below use Diamonds; a third currency of your own follows them with its own name.

  1. Save it. Diamonds is saved from the first time something grants it. To have it from a player's first join, in the Datastore panel, under Default Data, open Stats and press + Variable: name it Diamonds, pick a number. Its path, Stats.Diamonds, is what everything else asks for. (Your AI writes it into DefaultData and keeps Cash and Wins, because a list you write replaces the default whole.)
  2. Show it on the HUD. Add a TextLabel, tag it UI_DataBind and give it a DataPath attribute of Stats.Diamonds. Add Prefix, Suffix or Format (Default, Short, Full or Commas) if you like. It follows the value with no script (this needs General UI Kit).
  3. Rank it. In Leaderboards System, add a leaderstat or a board whose data key is Stats.Diamonds.
  4. Give it out. Any reward in Roulette, Time Rewards or Codes takes Type = Diamonds. A currency of your own takes Type = Stat and its path as Target.

A key you add reaches players who already exist, on their next load. A key you remove stays in their saved data, so removing one can never lose what someone earned.

How do I give a reward the pack doesn't offer?

Roulette System, Time Rewards System and Codes System take a Custom reward: put a ModuleScript of your own in ServerScriptService > RBLXEssentials > Extensions > <PackId>, with a Grant function like the pack's own custom rewards (GrantPet is one), then set the reward's Type to Custom and its Target to your module's name. Your module is looked up first, then the pack's own. A reward pointing at a module that is not there is switched off at startup with a warning, rather than failing the first time a player earns it (in Time Rewards, a slot with a Fallback gives that instead). Codes System and Time Rewards System call Grant(player, d, amount) once; Roulette System calls Grant(player, d) once per unit of Amount.

The easiest way is to ask your AI: "make day 7 give 3 Diamonds and a Golden Sword". It writes the module and checks it in Play.

How do I add a sound, or a music track?

Sounds live in SoundService > RBLXEssentials > SoundSystem, under SFX and Music. In the Sound panel, + Add sound (+ Add song under Music) takes an asset id or an rbxassetid:// string, plus an optional name; or drop a Sound into either group in the Explorer. Then play it from anywhere on the client:

local SFX = require(game.ReplicatedStorage.RBLXEssentials.Kernel.SFX)
SFX:Play("Press")
SFX:PlayOverlap("Gold_Pickup")  -- for things that fire fast

Measure all reads every sound's real loudness and Match all pulls the outliers to your target.

How do I react to something happening?

When a player's numbers change

The save is mirrored onto the player as ordinary Value objects, so a LocalScript can watch one with no remotes:

local player = game.Players.LocalPlayer
local data = player:WaitForChild("PlayerData")
local cash = data:WaitForChild("Stats"):WaitForChild("Cash")

cash.Changed:Connect(function(value)
    print("cash is now", value)
end)

A DataReady BoolValue in the same folder turns true once the save has arrived.

When somebody buys something

local hook = game:GetService("ServerScriptService").RBLXEssentials
    .Packs.DatastorePurchaseSystem:FindFirstChild("PurchaseCompleted")
if hook then
    hook.Event:Connect(function(player, kind, id, currencySpent)
        print(player.Name, "bought", kind, id)
    end)
end

It fires once a product purchase is saved or a game pass is bought, and also for FreeMode product grants in Studio, so you can test a product's whole path without spending Robux.

When you want to say something

local Notify = require(game.ReplicatedStorage
    .RBLXEssentials.Packs.NotificationsSystem.Notify)

Notify.Toast(player, "TitleSubtitle", { Title = "Level up!", Subtitle = "You reached level 10" })
Notify.BannerAll({ Title = "Boss event", Subtitle = "The arena opens in 30 seconds" })

How do I update a pack without losing my settings?

Update from My packs: one click, and your settings stay.

Press Update on the pack in the card's My packs, or ask your AI. Dragging the new file in still works too. In 3.0 there is nothing to carry over: your settings are your own configuration modules, your menus are your own copies in Interface and your scripts are in Extensions, and an update never touches any of them. If you edited a pack's own scripts anyway, the update tells you, keeps your version in Backups and asks before replacing them. A default menu you edited in place is replaced without asking, and your edited copy stays in a protected backup, so make your own copy instead.

How do I remove a pack?

Uninstall, in the More menu of its page, removes its code from every service after making a backup. Your configuration modules and your menus stay, so installing it again picks up where you left off. A pack that other installed packs need, such as Datastore & Purchase, is refused until those are uninstalled. Optional companions just go quiet: without Sound System packs play no sound, without Notifications System they show no toasts.

Something isn't showing up

What you seeUsually
A pack did not startIts configuration is invalid. The Output line [RBLXE] <PackId> failed: and the plugin's Diagnostics name the option.
No HUD button for a pack you installedGeneral UI Kit's Settings and Shop are used over Sound System's and Easy Pet System's, by design, so their buttons do not appear twice. For Codes, Spin, Rewards, Daily Rewards and Pets the pack's menu wins: it replaces the kit's demo. Diagnostics lists it among its notes.
Your edited menu is not usedSomething the pack fills by name was renamed in your copy, so the pack's own version is used. Diagnostics says what is missing.
No sound anywhereSound System is not installed. Every pack asks for sound whether or not it is there and gets silence if it is not.
No notifications from any packSame shape: Notifications System is not installed.
A reward does nothingIt points at a module or a pack that is missing. Codes and Time Rewards switch it off at startup; Roulette skips it when that slot lands. The Output names it.
Data does not save in StudioThe place is not published, or Studio API access is off. Every Play session then starts fresh, and the Output says so once.

Almost everything above prints a warning in the Output when it happens, with what to do. Nothing in the ecosystem fails silently on purpose.

Datastore & Purchase System

PackId: DatastorePurchaseSystem  ·  Version: 3.4.1  ·  Requires: nothing

Your AI adds a stat to the save data, and the player list shows it.
The Datastore & Purchase settings in the plugin.
The Datastore & Purchase settings in the plugin.
Cash saved across a rejoin: the Add Cash pad takes it from $0 to $1K, and after leaving and rejoining it is still $1K.

In 3.0 the options 2.x kept in this pack's Settings folder live in your game's configuration module, ReplicatedStorage.RBLXEssentials.Config.DatastorePurchaseSystem. Every option of this pack is shared, so it has no server-only module. The plugin's panel shown on this page edits them, and your AI lists every option with T.config.reference("DatastorePurchaseSystem").

What It Does

This is where your players' progress lives, and the backbone every other pack saves through. There is one datastore for your whole game, so a code, a spin and an egg all pay into the same numbers with nothing wired between them.

  • Loads on join, saves on a timer, on leave and on shutdown.
  • An in-memory cache, so every read mid-session is instant.
  • Live replication to the client as Value objects, so showing a stat needs no remotes.
  • Game pass checks, cached and remembered in the save.
  • Developer product receipts handled safely: a receipt Roblox retries is confirmed rather than granted twice.
  • Retries with backoff, request-budget awareness and save smoothing, so a full server does not spend its budget in one burst.
  • Studio safety: a separate datastore version for testing, synthetic user ids for test clients, and one calm warning instead of error spam on an unpublished place.

Plugin Configuration

Default Data

The Default Data tree in the plugin

This is what a new player starts with. Groups hold variables, and a variable is a number, a string or a true/false. + Variable and + Group add them; the red cross removes them.

Adding a variable, with its type picker

The path you build here, Stats.Cash or Inventory.Slots, is the exact string every other pack asks for: a reward slot's Target, a leaderstat's data key, a label's DataPath. Add a key here and it appears in those pickers immediately.

A new key reaches players who already exist, on their next load: each saved profile is merged with the current defaults and anything missing is filled in. A changed default only affects new players. A removed key stays in profiles that already have it, so deleting one here can never lose what someone earned.

See exactly what a new player gets

The preview of a new player's finished save

The panel prints the finished save before you press Play, your own keys merged with the ones the packs add. It is selectable text, so it is also the fastest way to check a key is spelled the way your code spells it.

Datastore Settings

Datastore settings: Auto-save every 1 min 30 s, the save versions for the live game and Studio tests, and Wipe Studio Data
SettingShips asWhat it does
DataStoreVersion"v1"Names the live datastore, PlayerData_<this>. Changing it starts every player on a fresh slate; their old saves stay in the old store. Never change it in a live game unless that is what you want.
StudioDataStoreVersion"v4"The suffix used while testing in Studio, kept separate so a playtest can never touch live player data.
AutoSaveInterval90Seconds between periodic saves per player, smoothed and jittered to respect the datastore budget.
Wipe Studio DatabuttonDeletes every saved profile in the Studio datastore, a clean slate for testing. Only you press it: click it once, then click Confirm? to go ahead. It refuses, and deletes nothing, while StudioDataStoreVersion matches DataStoreVersion, so it can never reach live data. It needs a published place with Studio API access on. Your AI never wipes saved data unless you ask it to.

Purchase Settings

The Free mode switch

FreeMode makes every pass read as owned and lets a product grant itself, with no Robux and no prompt. It is how you test a purchase path fifty times in an afternoon.

It ships off, and it only works in Studio. A live server always checks real purchases and warns at start while it is on. It also stays off in Studio while StudioDataStoreVersion matches DataStoreVersion (ignoring spaces and letter case), and the server says so at start, so a test can never grant into real players' saves.

Gifts

Since 3.4.0 a player can buy a Shop item for another player in the server. Each item you want giftable gets a line in Gifts, in the pack's configuration: the item (a game pass, or a developer product with a reward handler) and its gift product, a developer product you create for the gift, priced as you like. The gift button appears only on those items' tiles.

The buyer picks a player in the Gift menu and confirms; the server checks everything again (not themselves, the player is here, does not own the pass yet, not too fast) before Roblox asks for the Robux. The recipient gets the item and a popup saying who sent it, the buyer a toast. If the recipient left before the payment went through, the gift waits and arrives when they join; if it cannot land, the buyer keeps it as a gift to send later, for free.

Test it with FreeMode in Studio's Clients and Servers test: gifts complete with no Robux, like any other purchase there.

Uninstalling

Uninstall, in the More menu of the pack's page, removes the pack's code from every service. Your configuration module stays, and saved player data is untouched: it lives in Roblox's datastore, not in your place. While another installed pack needs it, Uninstall stops and names those packs; uninstall them first.


That's everything from the plugin.

Below: reading and writing a save from code, showing values on the client, and handling purchases.

Getting the API

Every pack boots through the kernel and receives the others' APIs through ctx.require. Declare the dependency in your own pack's manifest and ask for it in init:

-- ReplicatedStorage.RBLXEssentials.Packs.MyPack.manifest
return { id = "MyPack", version = "1.0.0", deps = { "DatastorePurchaseSystem" } }

-- ServerScriptService.RBLXEssentials.Packs.MyPack
return function(ctx)
    local ds = ctx.require("DatastorePurchaseSystem")
end

The kernel guarantees this pack has finished booting before your init runs, so ctx.require never waits. Making a pack of your own is one folder and a manifest; the walkthrough is in the kernel reference that ships with the source.

Data API

ds.Get(player)

The player's whole save. The first call loads and caches; every call after that returns the cache instantly. Concurrent first calls are deduplicated, so everyone gets the same table.

local data = ds.Get(player)
print(data.Stats.Cash)

ds.Update(player, mutator)

Applies a change and pushes it to the client replica. The mutator gets the table directly.

ds.Update(player, function(data)
    data.Stats.Cash += 100
end)

It persists on the next save and when the player leaves. Change the table only through Update, or through the helpers below which call it, so the replica stays in step.

ds.GetValue · ds.SetValue · ds.Increment

Path-addressed shortcuts for the common cases. The path is the same text the plugin shows.

local cash = ds.GetValue(player, "Stats.Cash")   -- nil if the key is not there
ds.SetValue(player, "Nickname", "Ana")          -- creates missing groups on the way
ds.Increment(player, "Stats.Cash", 250)         -- returns the new value
ds.Increment(player, "Stats.Cash", -500, 0)     -- the last argument is a floor

Increment treats a missing key as 0 and refuses a key holding something other than a number. Both it and SetValue return (result, err) and warn on failure.

ds.Save(player)

Queues an early save ahead of the schedule, for the moments that matter. It returns immediately; the write happens in the background, respecting the budget.

ds.SaveAndWait(player, timeout?)

Saves now and waits for the write. It returns true only once the save is confirmed, and false if it could not be written (including in Studio without API access). Pause your own changes to that player's data until it returns.

ds.GetSafeUserId(player)

The id the pack keys data by. A Studio test client, which has no real UserId, gets a made-up id that lasts while it stays in that server. Use it whenever you key your own stores by player.

ds.SaveAllImmediate(maxWaitPerWrite?) · ds.IsFreeMode()

The first writes every cached profile now and stops the save schedule, so it is for shutdown only, which the pack already handles for you. During a session use ds.Save or ds.SaveAndWait. The second is true while FreeMode is on and in effect, which only happens in Studio.

Reading data on the client

Every player's save is mirrored under their Player as Folders and Value objects, updated on every write. No remotes.

-- LocalScript
local player = game.Players.LocalPlayer
local playerData = player:WaitForChild("PlayerData")
playerData:WaitForChild("DataReady")  -- true once the first replication landed

local cash = playerData.Stats.Cash
cashLabel.Text = tostring(cash.Value)
cash:GetPropertyChangedSignal("Value"):Connect(function()
    cashLabel.Text = tostring(cash.Value)
end)

Numbers, strings and booleans arrive as NumberValue, StringValue and BoolValue; arrays arrive as children named [1], [2] and so on. The replica is read-only by convention: writing to these Values does not write back to the server.

If all you want is a label that shows a number, you do not need any of this. Tag it UI_DataBind and give it a DataPath, and General UI Kit does it for you.

Purchases

ds.HasPass(player, passId)

Checks the in-memory cache, then the player's save, then Roblox, persisting a confirmed ownership back to the save. Returns true for everyone while FreeMode is on in Studio, and the cache clears itself when someone buys a pass mid-session. ds.HasPassStrict(player, passId) does the same check but ignores FreeMode, and returns owns, ready.

if ds.HasPass(player, 123456789) then
    -- give them the perk
end

ds.registerProfileHandler(productId, grant, afterCommit?)

This is how you grant a developer product in 3.0. One handler per product. It receives (player, draft, receipt): change only draft, a copy of the player's save, and return true. The reward and the receipt are saved together, and the purchase is confirmed to Roblox only once that save succeeds. Returning false or erroring makes Roblox retry later, so nothing is lost. The handler must not yield. It may return true, payload: the optional afterCommit(player, payload) then runs once the save is confirmed, for effects such as a message.

ds.registerProfileHandler(987654321, function(player, draft, receipt)
    draft.Stats.Cash += 1000
    return true
end)

Legacy: the 2.x ds.registerHandler(productId, function(player, receipt)) still runs, but it is legacy: its reward is not saved together with the receipt, and the server warns once per product. Use registerProfileHandler instead. Every granted receipt is remembered in the player's save, so a receipt Roblox re-delivers is confirmed without running your handler a second time. Product and pass ids are not stored by this pack: keep them where your own code needs them.

ds.GrantProduct(player, productId) · ds.InvalidatePass(player, passId)

The first runs a registered product handler with no real purchase, and only while FreeMode is on in Studio, which is how you test a reward flow there. Your handler receives nil for receipt on that path. The second clears a cached pass result; mid-session purchases already do it for you.

Knowing when somebody bought something

The pack publishes a BindableEvent anyone can listen to, without declaring a dependency:

local hook = game:GetService("ServerScriptService").RBLXEssentials
    .Packs.DatastorePurchaseSystem:FindFirstChild("PurchaseCompleted")
if hook then
    hook.Event:Connect(function(player, kind, id, currencySpent)
        print(player.Name, "bought", kind, id)
    end)
end

kind is "product" or "gamepass". For a product it fires once the reward and the receipt are saved. For a game pass it fires when Roblox reports the purchase, with currencySpent as nil. A FreeMode GrantProduct in Studio fires it too, as a product with currencySpent 0, so a product's whole path is testable there. Notifications System uses this exact hook, which is why neither pack declares the other.

What a save looks like

{
    Meta = {
        SchemaVersion = 1
        -- plus, at runtime: FirstJoinDate, SessionStart,
        -- SessionId, LastSaveDate, SaveCount
    },
    Stats = {
        Cash = 0,
        Wins = 0
    },
    Pets = {
        Equipped = {},
        Owned    = {}
    },
    Purchases = {
        Gamepasses     = {},
        ReceiptHistory = {}   -- appears with the first product purchase
    }
}

Stats, and anything else you add, comes from Default Data above. This pack adds Pets and Purchases when you leave them out, and always adds Meta, its own record, which Default Data cannot set.

When a save cannot be read

A player whose data fails to load is not dropped into the game with an empty one. They are told to rejoin, and their real save is still there when they do. This is the one case where doing nothing would quietly cost someone their progress. The same happens if another server takes over their profile: they are asked to rejoin rather than let two servers write one save.

Easy Pet System

PackId: EasyPetSystem  ·  Version: 3.3.5  ·  Dependencies: Datastore & Purchase Sound System (optional) Notifications System (optional) General UI Kit (optional)

Your AI changes how pets follow you: here, floating around you.
Opening the Tier 1 egg in Play: each hatch shows the pet you got and takes its price.
How pets follow, pet data, rarities, pets and eggs in the plugin.
How pets follow, pet data, rarities, pets and eggs in the plugin.

In 3.0 the options 2.x kept in this pack's Settings folder live in your game's configuration module, Config.EasyPetSystem in ReplicatedStorage (every option of this pack is shared, so there is no server-only module). The pet catalog, Assets.PetData, is your game's content rather than configuration: you edit it in place, and updates keep a catalog you changed. The plugin's panel shown on this page edits both, and your AI lists every option with T.config.reference("EasyPetSystem").

What It Does

Easy Pet System is a complete, production-ready pet system for Roblox. Players hatch pets from eggs, collect them across rarity tiers, merge duplicates into rarer versions, equip pets that follow them around the map, and earn multiplier bonuses.

  • Weighted drop chances per egg, for single and triple hatch.
  • Auto-hatch gamepass support.
  • Triple-hatch gamepass support.
  • Extra Pet Space gamepass support.
  • Three pet movement modes (Ground, Float (orbit), and Follow), switchable at runtime.
  • Merge 3 pets of the same type into the next rarity tier.
  • Merge All: auto-merges all eligible sets in one call.
  • Equip Best: automatically equips the highest-multiplier combination.
  • Multiplier API: sum or product of all equipped pet multipliers, accessible from any server script.
  • 28 included pet models across 5 rarities (fully replaceable).
  • BillboardGui egg boards with buy, x3 and auto-hatch buttons and the drop odds, plus a full-screen reveal for every hatch.
  • The board buttons work on every device: E, R and T on a keyboard, X, Y and RB on a gamepad, round buttons next to the jump button on phones.

Plugin Configuration

Required: this pack uses Roblox DataStore. Go to Game Settings → Security → Enable Studio Access to API Services before testing, otherwise player data will not save.

All settings are managed directly from the plugin, no script editing needed.

General and Gamepasses

The General and Gamepasses settings: Cash pad gives, Auto-hatch, One more pet and Open 3 eggs at once

Lists the game passes used by the pack. Each id starts at 0, which turns that pass off, until you paste your own from the Roblox Creator Dashboard. A player owns a pass by its id, so once you sell one, never change its id.

  • BaseCash: cash the Add Cash demo pad gives per use, times the player's total pet multiplier (500 by default). Since 3.0.2 the pad works only in Studio tests: on a live server its prompt is off. Delete it (Workspace > RBLXEssentials > EasyPetSystem > AddCashPart) before you publish unless your game wants it.
  • ExtraPetSpace: lets a player equip one more pet than MaxEquipped.
  • AutoHatch: allows players to auto-hatch eggs continuously.
  • TripleHatch: allows players to hatch 3 eggs at once.

Before testing: create these Game Passes in the Roblox Creator Dashboard for your experience and paste each ID into the corresponding field. While an id is 0, that pass is off.

Pet Data

Pet data settings: Most pets owned, Pets equipped at once, Copies per merge, Egg reach and Follow mode
  • MaxOwned: maximum number of pets a player can have in their inventory.
  • MaxEquipped: maximum number of pets a player can have equipped at once (one more with the ExtraPetSpace pass).
  • MergeCount: number of pets of the same type required to perform a merge.
  • ProximityDistance: how close, in studs, a player must be to an egg for its board and buttons to turn on. Walking out of range also stops auto-hatch.
  • FollowMode: the mode each player starts with. Options: Ground, Orbit, Follow. Orbit carries the label "Float" for your own menus.

Rarities

Rarities configuration

Rarities are defined in ReplicatedStorage > RBLXEssentials > Packs > EasyPetSystem > Assets > PetData > Rarities. The pet catalog is your game's content, so updates keep a catalog you changed. You can add, remove, and rename rarities freely. Pets reference rarities by name.

ValueTypeControls
ordernumberTier rank used for pet sorting in the Pets menu and for determining the merge target (next rarity up). Lower = weaker.
MainColorColor3Stroke of each card and egg-board slot, the probability text, the first gradient stop, and the new-pet reveal's background.
SecondaryColorColor3Second gradient stop.
EggBoardTextColorColor3Pet name text colour on the egg boards.
NewPetTextColorColor3Pet name and rarity text on the new-pet reveal.
MenuTextColorColor3Pet name colour in the Pets menu.

These values are the ones that render. Each card's stroke takes the rarity's MainColor, its gradient runs MainColor to SecondaryColor, and the pet's name takes MenuTextColor, applied when the menu is built. The colours baked into the shipped templates match these, so the editor shows you what a player will see, but the data is what wins.

Pet Card Templates

The pet cards in the Pets menu are cloned from one template per rarity, kept inside the Pets menu itself. In the pack's own copy of the menu they are in:

StarterGui > RBLXEssentials > EasyPetSystem > EasyPetSystemGUI
  > Pets > Container > PetContainer > Container

Each template is a Frame named [Rarity]PetTemplate (e.g. CommonPetTemplate, EpicPetTemplate) and tagged in CollectionService with the same name. When a pet card is rendered, the system resolves the correct template by tag:

CollectionService:GetTagged(petDef.rarity .. "PetTemplate")

The matching template is cloned and filled with that pet's data, then recoloured from the rarity's own values. Restyle a template freely in your own copy of the Pets menu: make it from the plugin's Interface tab (the pencil) or ask your AI. Copies live in StarterGui > RBLXEssentials > Interface, where updates never touch them. Shape, corners, layout and fonts are yours, and the three colour slots are overwritten from the rarity so the card always matches the rest of the pack.

The Pets menu in game, with a card per rarity colour

To add a new rarity, in your copy of the Pets menu create a new Frame in the container, name it [NewRarity]PetTemplate, and apply the CollectionService tag [NewRarity]PetTemplate to it. A rarity without its own template uses the template of the lowest rarity.

Pets

Pets configuration

The full list of pets in the game. Each pet has a preview image (the 3D model), a name, a rarity, and a multiplier value. You can add new pets, delete existing ones, or change any of their properties here.

Eggs

Eggs configuration

Defines all eggs available in the game. Each egg has a name, a price, a currency (Cash or Robux), and a drop percentage table listing which pets can be hatched from it and at what probability. The total must add up to 100%.

At the bottom you can create a new Cash Egg or a Robux Egg.

Robux Eggs

Robux egg configuration

Robux eggs use robuxPrice (the display price in Robux) and a productId (the Developer Product ID from the Roblox Creator Dashboard) instead of a cash price.

The Robux egg that ships, Tier6Egg, sells an RBLX Essentials demo product. Before you publish, put your own developer product's id in its productId. 0 or a negative id is not an off switch: the egg still shows, its Open button only says "This egg isn't for sale yet", and Diagnostics keeps pointing it out. To have no Robux egg, delete both its entry, ReplicatedStorage > RBLXEssentials > Packs > EasyPetSystem > Assets > PetData > Eggs > Tier6Egg, and its stand in Workspace > RBLXEssentials > EasyPetSystem > Eggs. Its four Dominus pets stay in your pet list, but with no egg the Index no longer lists them and they cannot be merged, so in a live game whose players may own them, set a real id instead.

Uninstalling

The pack's More menu in the plugin: Where its files are and Uninstall

Choose Uninstall in the More menu of the pack's page. It removes the pack from every service it was installed into, demo eggs included, and keeps a backup in ServerStorage > RBLXEssentials > Backups, your pet catalog with it. Your Config.EasyPetSystem module stays. Saved pets are untouched: they live in the player's data, not in your place.


That's everything from the plugin.

If you're not planning to modify the pack's code or call its APIs from your own scripts, you can stop here. The sections below are for developers who want to integrate the system directly into their own code.

API

Declare "EasyPetSystem" in your own pack's manifest.deps and ask the kernel for it:

local pets = ctx.require("EasyPetSystem")

pets.GetTotalMultiplier(player, multiply?)

Returns the combined multiplier of all equipped pets.

-- Sum all equipped multipliers (e.g. 1 + 1.5 + 2 = 4.5)
local total = pets.GetTotalMultiplier(player)

-- Multiply all equipped multipliers (e.g. 1 * 1.5 * 2 = 3.0)
local product = pets.GetTotalMultiplier(player, true)

-- Apply to a reward (the sum is 0 with no pet equipped, so pay the base amount then)
local mult = pets.GetTotalMultiplier(player)
local reward = if mult > 0 then baseCash * mult else baseCash

pets.HatchEgg(player, eggId, count, isAuto?)

Hatches one or three pets from the specified egg. Returns a result table.

local result = pets.HatchEgg(player, "Tier1Egg", 1)
if result.ok then
    for _, pet in result.pets do
        print(pet.id, pet.rarity, pet.multiplier)
    end
end

Parameters:

  • eggId (string): a Cash egg's key in PetData's Eggs. A Robux egg is sold only through its developer product and returns "invalid_egg" here.
  • count (number): 1 to 3; 3 needs the TripleHatch pass.
  • isAuto (bool, optional): true for auto-hatch (requires AutoHatch pass).

Failure reasons: "invalid_egg", "insufficient_funds", "inventory_full", "need_triple_pass", "need_auto_pass", "cooldown", "busy" (another action for this player is still running).

Each pet in result.pets has: uid, id, rarity, multiplier, createdAt.

pets.EquipPet(player, uid)

Equips a pet by its unique ID. Players can have up to MaxEquipped pets equipped (3 by default), one more with the ExtraPetSpace pass.

pets.UnequipPet(player, uid)

Unequips a pet by its unique ID.

pets.DeletePet(player, uid)

Deletes a pet from the player's inventory. The pet must be unequipped first.

pets.MergePets(player, petId)

Consumes MergeCount copies (3 by default) of the same pet and gives one pet from the next rarity up in the same egg, picked by that egg's drop chances. Unequipped copies are used first; if there aren't enough, equipped copies fill the rest and are unequipped before being consumed.

local result = pets.MergePets(player, "Cat")
if result.ok then
    print("Merged into:", result.pet.rarity)
end

Failure reasons: "no_next_tier", "not_enough", "invalid_pet", "busy".

pets.MergeAll(player)

Merges unequipped pets, MergeCount at a time, again and again until no set is left. Equipped pets are never used.

local result = pets.MergeAll(player)
print("Merges performed:", result.mergeCount)

pets.EquipBest(player)

Unequips all current pets and re-equips the combination with the highest total multiplier, up to the equip limit.

Configuration

Pets, eggs, rarities, and core limits are all data-driven: edit them in the Explorer or through the plugin's settings panel without touching code. Pet movement behaviour (radius, speed, bobbing) is the PetVisuals option in Config.EasyPetSystem (see below).

Key Settings

These five limits are values in the pet catalog, Assets.PetData, which is your game's content: edit them there or in the plugin. They are not options in Config.EasyPetSystem.

SettingDefaultDescription
MaxOwned50Maximum pets a player can hold in their inventory.
MaxEquipped3Base number of pets a player can equip simultaneously.
MergeCount3Number of pets required to perform a merge.
FollowMode"Ground"The mode each player starts with. Options: "Ground", "Orbit", "Follow". Orbit carries the label "Float" for your own menus.
ProximityDistance7How close, in studs, a player must be to an egg for its board to turn on.

Switching Follow Mode at Runtime

The active movement mode is controlled by a PetFollowMode attribute on the local player. Set it from any LocalScript, for example from a button in your own settings menu:

local Players = game:GetService("Players")

Players.LocalPlayer:SetAttribute("PetFollowMode", "Orbit") -- "Ground", "Orbit", or "Follow"

Pets react immediately; no rejoin or respawn required. Each player starts on PetData's FollowMode; if the attribute names no mode in Modes, pets use PetVisuals.DefaultMode.

Tuning Pet Movement: PetVisuals

The PetVisuals option, in Config.EasyPetSystem (the plugin's Pet Visuals section edits it), defines every movement mode and its parameters. These are its defaults; your values merge over them, mode by mode:

PetVisuals = {
    DefaultMode = "Ground",
    Modes = {
        Orbit = {
            label       = "Float", -- display name for your own menus
            Radius      = 4,       -- studs from character center
            Speed       = 45,      -- degrees per second
            FloatHeight = 2.5,     -- studs above HumanoidRootPart
            BobAmount   = 0.25,    -- vertical bob amplitude (studs)
            BobSpeed    = 1.2,     -- bob frequency (Hz)
            LerpAlpha   = 0.15,
        },
        Ground = {
            label       = "Ground",
            Radius      = 4,
            Speed       = 35,
            FloatHeight = -2,      -- floor level relative to HumanoidRootPart
            BobAmount   = 0,
            BobSpeed    = 0,
            LerpAlpha   = 0.15,
        },
        Follow = {
            label       = "Follow",
            Spacing     = 2.5,     -- studs between each pet in the trail
            FloatHeight = -2,
            LerpAlpha   = 0.1,
        },
    },
}

Adjust radius, orbit speed, float height, bobbing, or trail spacing here to change how equipped pets move.

Announcing rare pets: RareAnnounce

Also in Config.EasyPetSystem: when a player hatches or merges a pet whose rarity order is at least MinOrder (3, Rare and up in the shipped ladder), the whole server gets a chat line, Message ("{rarity} drop! {player} just hatched {pet}!"). It needs Notifications System; without it nothing is said.

Reading Configuration in Code: PetConfig

ReplicatedStorage > RBLXEssentials > Packs > EasyPetSystem > PetConfig loads the full PetData tree into a plain Lua table with PetConfig.load, usable from both client and server:

local pack = ReplicatedStorage.RBLXEssentials.Packs.EasyPetSystem
local PetConfig = require(pack.PetConfig)
local config = PetConfig.load(pack.Assets.PetData)

print(config.MaxOwned, config.MaxEquipped, config.MergeCount)
print(config.ProximityDistance, config.FollowMode)

local catDef = config.Pets["Cat"]        -- { name, rarity, multiplier }
local eggDef = config.Eggs["Tier1Egg"]   -- { name, price, currency, pets, robuxPrice?, productId? }
local rarity = config.Rarities["Epic"]   -- { order, MainColor, SecondaryColor, EggBoardTextColor, NewPetTextColor, MenuTextColor }

PetConfig.getNextRarityPets(config, petId) returns the merge candidates for a pet (the { id, percent } entries from the same egg at the next rarity tier) or nil if the pet is already the highest rarity in its egg:

local candidates = PetConfig.getNextRarityPets(config, "Cat")
if candidates then
    for _, entry in candidates do
        print(entry.id, entry.percent)
    end
end

Gamepasses

Configure these pass IDs in the plugin settings to enable the corresponding features:

GamepassEffect
TripleHatchAllows hatching 3 eggs at once.
AutoHatchAllows continuous auto-hatching.
ExtraPetSpaceRaises the equip limit by one (from 3 to 4 with the default MaxEquipped).

A pass left at 0 is off: its Shop button says "Not for sale" and the egg boards hide its "Open x3" or "Auto" button.

Client Integration: Remotes

On startup, the pack's server creates its remotes through the Kernel, under ReplicatedStorage > RBLXEssentials > Kernel > Remotes > EasyPetSystem:

RemoteTypeInvoked with
BuyAndHatchEggRemoteFunction{ eggId = "Tier1Egg", count = 1, isAuto = false }
GrantFreeProductRemoteFunctiona developer product id (FreeMode in Studio only: grants a Robux egg without a purchase)
EquipPetRemoteFunctionpet uid
UnequipPetRemoteFunctionpet uid
DeletePetRemoteFunctionpet uid
MergePetsRemoteFunctionpetId
EquipBestRemoteFunctionnone
MergeAllRemoteFunctionnone
OpenStoredEggRemoteFunction{ eggId = "Tier1Egg" } (opens one egg the player already owns)
PremiumHatchResultRemoteEventfired server → client with Robux hatch results

The pass ids the built-in UI gates on are the Gamepasses option in Config.EasyPetSystem. The pack also stamps a FreeMode attribute on ReplicatedStorage > RBLXEssentials > Packs > EasyPetSystem: when true (Datastore's FreeMode, in Studio only), pass checks are bypassed.

Use these remotes to trigger pet actions from your own UI:

local Remotes = ReplicatedStorage:WaitForChild("RBLXEssentials"):WaitForChild("Kernel")
    :WaitForChild("Remotes"):WaitForChild("EasyPetSystem")

local result = Remotes.BuyAndHatchEgg:InvokeServer({
    eggId = "Tier1Egg",
    count = 1,
    isAuto = false,
})
if result.ok then
    print("Hatched:", result.pets[1].id)
end

Adding Egg Models to the Map

Egg models in Workspace are discovered by tag, so you can place as many as you like. Each egg Model must:

  1. Be tagged Egg in CollectionService.
  2. Have an EggId string attribute matching a key in the Eggs configuration (e.g. "Tier2Egg").
  3. Contain a part named Gui holding a BillboardGui tagged EggBoard: this is the hatch interface players interact with.

The simplest workflow: duplicate one of the included egg models, change its EggId attribute, and swap the mesh. The billboard, proximity detection, and hatch buttons wire themselves up automatically.

Hatch Toast

The hatch reveal (the full-screen pet reveal after hatching) is two interface pieces, HatchReveal for one pet and HatchRevealTriple for three. The pack shows them on its own after every hatch, Robux hatches included. To restyle them, make your own copy from the plugin's Interface tab (the pencil) or ask your AI; copies live in StarterGui > RBLXEssentials > Interface, where updates never touch them.

From a client pack module that declares "EasyPetSystem" in manifest.deps, ctx.require("EasyPetSystem").OpenStoredEgg(eggId) opens one egg the player already owns and plays the same reveal:

local pets = ctx.require("EasyPetSystem")
local result = pets.OpenStoredEgg("Tier1Egg")
-- result.ok, or result.reason: "busy" while a reveal is playing, "not_ready" before the reveal has loaded

Included Pets

28 pets across 5 rarities, our own designs made for RBLX Essentials. All pet models are fully replaceable, you can add, remove, or swap them at any time without code changes.

RarityMultiplier Range
Commonx1 to x500
Uncommonx2 to x750
Rarex4 to x80,000
Epicx25 to x200,000
Legendaryx400 to x1,500,000

Sound System & Music Player

PackId: SoundSystem  ·  Version: 3.2.2  ·  Requires: nothing

Your AI turns the music down and keeps the sound effects on.
Volumes and the whole playlist in the plugin.
Volumes and the whole playlist in the plugin.
The music player in Play: open it and skip to the next track.

In 3.0 the options 2.x kept in this pack's Settings folder live in your game's configuration module, Config.SoundSystem in ReplicatedStorage (every option of this pack is shared, so there is no server-only module). The plugin's panel shown on this page edits them, and your AI lists every option with T.config.reference("SoundSystem").

What It Does

Sound System ships 42 sound effects, fifteen music tracks and seven music-player templates, including Studded. Pick one with Player design in the pack's settings: the preview shows it closed and opened, and picking one makes it your version in Interface. Every player has open and hide controls that preserve playback. Music and SFX use separate volume groups, so muting one leaves the other alone.

It is also what gives every other pack its sound. Every pack in the ecosystem asks for a sound whether or not this one is installed, and gets silence if it is not, so adding it later turns audio on across all of them at once, with nothing to wire.

Plugin Configuration

General and Music Player

SettingDefaultWhat it does
SFXEnabledonGlobal kill switch. With it off, every sound effect in the game is silent, for every player. It is the value at server start; while the game runs, the pack's SetSFXEnabled switches it.
MusicPlayerEnabledonThe MusicPlayer.Enabled option. With it off, the music player is hidden and no music plays. For games that do not want one.
TemplateMusicPlayer_Template_1Read only: names the music player your game uses and previews it. The pencil in the plugin's Interface tab makes or edits your version, and the eye shows it on screen.
Start VolumesunsetSFX and Music volumes, 0 to 10, set when the server starts. Left unset, each group keeps the Volume it has in SoundService.

Seven skins ship: the six originals, now with open and hide controls, and a seventh, Studded. The music player is an interface piece, SoundSystem.MusicPlayer. To restyle it, make your own copy from the plugin's Interface tab (the pencil) or ask your AI; copies live in StarterGui > RBLXEssentials > Interface, where updates never touch them. To use another skin, pick it in Player design in the pack's settings (Design 1 to 7): the plugin makes your copy with that skin, in one undo step. The skins live in ReplicatedStorage > RBLXEssentials > Packs > SoundSystem > Assets > Templates. For music with no player on screen, set Visible to false on your copy's frame. The image below shows the original six designs.

All six music player skins

Music

The fifteen music tracks with per-song volume

Fifteen songs ship. Each carries its own volume, so a track mastered louder than the rest can be pulled down on its own instead of turning the whole playlist down. The group volume above them moves all of them together.

SFX

The eighteen sound effects, measured, with outliers flagged

42 effects ship, covering money, purchases, hovers, presses, level ups, pickups, impacts, movement and water. The 24 additions are optional sounds; they are not assigned to gameplay automatically. The plugin measures each one's loudness in decibels and flags the ones that miss your target with a Match button; Match all pulls every outlier into line at once.

WindLoop, UI_Confirm_01, Water_Splash_10 and Movement_Swish_04 are not included because their Roblox audio IDs could not be distributed. Use PlayLoop or PlayOneShot with your own sounds for those.

+ Add sound (+ Add song in Music) takes an asset id or an rbxassetid:// string, plus an optional name. That name is what you pass to SFX:Play, and what every sound dropdown elsewhere in the plugin will then offer you.

Uninstalling

The pack's More menu in the plugin: Where its files are and Uninstall

Choose Uninstall in the More menu of the pack's page. It removes the pack from every service it was installed into. Every other pack goes silent rather than breaking.


That's everything from the plugin.

Below: playing sounds from your own code, the music player's structure, and the volume controls.

Where the sounds live

SoundService > RBLXEssentials > SoundSystem > SFX     -- sound effects
SoundService > RBLXEssentials > SoundSystem > Music   -- music tracks

They are edit-time content, not something built at runtime, so you can browse and replace them in the Explorer. Sounds are looked up by name: drop a Sound into the right group and it is available immediately, including one added while the game is running. Each sound's SoundGroup is assigned for you, so it obeys the player's volume without being told.

Playing a sound

From any LocalScript of your own:

local SFX = require(game.ReplicatedStorage.RBLXEssentials.Kernel.SFX)

-- Plays by name. Restarts if it is already playing.
SFX:Play("Press")

-- Clones it, so several can overlap. Each clone cleans
-- itself up when it finishes. Use this for anything that
-- can fire in quick succession.
SFX:PlayOverlap("Gold_Pickup")

This is the kernel's own sound facade, which every pack calls too. It is a silent no-op when Sound System is not installed, so code written against it never errors on a place that does not have the pack.

Pitch variation and owned loops

Inside a client pack module initialized by the Kernel, declare SoundSystem in manifest.deps, then obtain it with ctx.require("SoundSystem"). Your pack then only starts when Sound System is installed; for sounds that must never block your pack, use the Kernel's SFX facade above. PlayOneShot(name, {volume = 0.7, pitch = 1.05}) plays a 2D copy without changing the template. PlayLoop(name, options) returns an owned loop: update its volume or PlaybackSpeed and call Destroy() when finished. Supply your own loop asset.

Both APIs may return nil while loading, muted or at their voice limits. Volume multiplies the template volume (0–2); pitch is absolute PlaybackSpeed (0.5–2). One-shots allow eight voices and expire after eight seconds; loops have a separate limit of two and no automatic eight-second expiry.

At a place in the world

Positional playback is on the pack's server API, reached through the kernel after declaring "SoundSystem" in your own pack's manifest.deps:

local sound = ctx.require("SoundSystem")

-- Everyone hears it, wherever they are.
sound.PlayAt("Money_1", part.Position)

-- With a range, it falls off with distance instead.
sound.PlayAt("Money_1", part.Position, 30)

-- Or for one player only.
sound.PlayAtForPlayer(player, "Gem_Pickup", part.Position, 30)

A ranged sound gets an invisible host part at that spot, rolls off with LinearSquare, and the part is destroyed when the sound ends. Without a range it plays globally, cloned straight into the SFX group. Either way it stays in that group, so the player's own volume and mute still apply.

Hearing all three before you write anything

Five parts ship in Workspace > RBLXEssentials > SoundSystem > Demo, each with a prompt on it and no code in it at all. Between them they cover every way of playing a sound: straight into your ear, out of a point in the world, and out of a point for one player only, the last two with and without a falloff range. Walk up, press the prompt, hear the difference, then delete the folder.

The music player

Drop your tracks into the Music group and the client does the rest: it builds the playlist, starts on a random track, advances when one ends, and keeps up if tracks are added or removed while the game runs.

The UI is tag-based. Tag any Frame with MusicPlayerFrame and give it this structure:

Frame  (tagged MusicPlayerFrame)
└── Container
    ├── SongName   (TextLabel)
    ├── Duration   (TextLabel)
    └── Buttons
        ├── Mute   (ImageButton with an "Icon" child)
        └── Next   (ImageButton)

Everything is wired for you: the song's name, the elapsed and total time updated live, a mute that swaps its icon, and a skip. You can tag more than one frame, for example one on the HUD and one inside a settings panel. They share a single playback state, so muting in one updates every other instantly, and frames added or removed at runtime are picked up.

Volume controls

The pack registers six actions you can put on any button inside a menu or HUD element the kit manages, by setting its Action attribute. No code.

ActionWhat it does
ToggleMusicMuteMutes and unmutes music, restoring the previous volume.
ToggleSFXMuteThe same for sound effects.
MusicVolumeUp / MusicVolumeDownSteps music volume.
SFXVolumeUp / SFXVolumeDownSteps SFX volume.

Volume moves along a nine step ladder from 0.04 to 1.0, so each press is a change you can hear rather than a linear crawl. The handlers also drive optional feedback: a mute button with a Status label shows ON or OFF, and a frame with a VolumeGroup attribute of "Music" or "SFX", whose VolumeFrame child holds Volume1 to Volume9, renders as a live volume bar.

Everything stays in step across surfaces, because the music player's mute and the settings menu's mute are moving the same SoundGroup.

The pack ships its own Settings panel and the button that opens it, so the volume controls exist even with no other pack installed. With General UI Kit present, its Settings panel wins and these controls appear there instead. One menu, whichever pack provided it.

General UI Kit

PackId: GeneralUIKit  ·  Version: 3.5.2  ·  Requires: nothing

Your AI changes a menu through its own copy of the piece.
Menus opening from the HUD in Play: Shop, then Settings, in the Studded finish.
The kit's page in the plugin: its Style (Plain or Studded) and every menu.
The kit's page in the plugin: its Style (Plain or Studded) and every menu.

In 3.0 General UI Kit's look is the game's style, Plain or Studded (below). You change its menus by making your own copy in StarterGui > RBLXEssentials > Interface, and your own button actions live in ReplicatedStorage.RBLXEssentials.Extensions.GeneralUIKit.CustomHandlers. Updates never touch either.

What It Does

General UI Kit is the menu system your game was going to need anyway, and the framework the rest of the ecosystem plugs into. Behaviour is declared with CollectionService tags and Instance attributes, so adding a panel or a button means tagging something, not editing a script.

It ships with fourteen menus already built (Shop, Settings, Teleport, Changelogs, Pets, Codes, Daily Rewards, Rewards, Spin, Rebirth, Upgrades, Trade, Trade Inventory and Trade Request), with 11 HUD buttons in the grid plus the Changelogs button, an invite button, an effects bar and the tooltips. A game with only the kit has every menu. It also provides:

  • Panel management: open, close, exclusive mode, animated transitions.
  • Button sounds, hover scaling and cursor-following tooltips.
  • Decorative animations: rotation, hover bob, idle bob, colour cycling.
  • An effect icon system with tooltip descriptions.
  • Live data binding, so a label shows and follows a saved value with no script.
  • Typing sounds on text boxes.
  • A place for your own button actions that pack updates never overwrite.

Demo menus. Pets, Codes, Rewards, Daily Rewards and Spin are complete demo menus with the content 2.x showed. They open, animate and play their sounds, and do nothing else until the game wires them. When the pack that owns one is installed (Easy Pet System, Codes System, Time Rewards System, Roulette System), the pack's menu replaces the kit's demo, so only one copy is shown, and the changes you made to the demo carry over to the pack's menu.

Templates. Rebirth, Upgrades and Trade (with Trade Inventory and Trade Request) have no pack behind them. Give their buttons an Action and wire it in ReplicatedStorage.RBLXEssentials.Extensions.GeneralUIKit.CustomHandlers.

How It Works

The kernel discovers tagged elements anywhere in the local PlayerGui, both at startup and as they arrive. Tags say what an element is; attributes say how it behaves. Tag a Frame UI_Panel, set PanelId = "Shop", and it is a panel.

Because discovery is by tag rather than by path, every pack's menus land in the same system. When two packs ship the same menu (Easy Pet System also has a Shop), the kernel uses one and hides the other, so you get one Shop rather than two. For the kit's demo menus (Codes, Spin, Rewards, Daily Rewards and Pets) the pack's menu wins: once that pack is installed, its menu is used and the demo is not. When you make your own copy of a menu in StarterGui > RBLXEssentials > Interface, your copy is the one used and the pack's is left alone.

Button clicks are dispatched by action name. The built-in actions are handled for you; anything else goes to your own CustomHandlers module.

Plugin Configuration

Interface

The pack's page in the plugin lists every part the kit ships, in Menus, Buttons and other HUD parts: all 14 menus, each with what opens it (11 HUD buttons plus the Changelogs button), the invite button, the effects bar and the two tooltips. A demo menu says which pack it stands in for, and once that pack is installed, that it is replaced by it.

The pencil beside a part makes your own copy in StarterGui > RBLXEssentials > Interface, shows it on screen and selects it in the Explorer, so you can design it in place instead of hunting for it. Updates never touch your copy. Click the pencil again when you are done. Revert changes, under a copy, goes back to the kit's version.

Hiding a menu or a button

Make your own copy of it and set Visible to false on the copy. For a menu, hide the button that opens it. The two tooltips are the exception: the kit keeps using them whatever their Visible.

Style: Plain or Studded

General UI Kit's menus come in two styles, both in its own font, Fredoka. Plain (Fredoka) keeps the flat colours; Studded (Fredoka) gives the same menus the stud texture on their headers, buttons, panels, cards and rows. The studs are square and the same size on every button and panel, on any screen. Pick one on the card's Style tab: it is one style for the whole game, so Studio shows it at once on every menu, and your edits, your own copies and your settings stay.

Since 3.3.2 the packs use the kit's menus: with General UI Kit installed, Codes, Spin, Rewards, Daily Rewards and Pets are the kit's own menus run by their packs, so they have the same look and finish as the Shop. Each pack keeps its own menu for games without the kit. The style is saved in the game's configuration (Config.Game: Kit = "GeneralUIKit", Style = "studded-fredoka"; a game set before 3.5.0 has Finish = "Studded", which still works), so updates keep it, and a pack you install later follows it. To give a menu of your own the same studs, your AI can copy a Studs layer from a kit menu (the themes map explains how).

Themes

Themes are no longer offered: the Studded look is the kit's own Studded finish. A place that still has the older Studded UI theme keeps it working; the Style tab shows it as the style in use, and picking a style stops using it (its copies are kept in a backup).

The free Studded UI: Design Only (no scripts) is a ZIP with the design file alone: no scripts, so its buttons do nothing. Drag its .rbxm into StarterGui; the plugin does not install it, and plugin 3.2.2 or newer says it is the design only when it finds it in a place. To make the same menus work, with animations and sound effects, use General UI Kit with Studded.

Left, the free Studded UI: Design Only: its buttons do nothing. Right, General UI Kit with Studded: they open their menus, with animations and sound effects.

For your AI: T.style() says the game's style and the ones it can pick; T.style({ kit = "GeneralUIKit", style = "studded-fredoka" }) sets it.

Uninstalling

The pack's More menu in the plugin: Where its files are and Uninstall

Choose Uninstall in the More menu of the pack's page. It removes the pack from every service it was installed into.


That's everything from the plugin.

If you're not planning to modify the pack's code or call its APIs from your own scripts, you can stop here. The sections below are for developers who want to integrate the system directly into their own code.

Tag Reference

UI_Panel

A toggleable menu panel (a Frame or other GuiObject).

AttributeTypeRequiredDescription
PanelIdstringYesUnique identifier for this panel.
ExclusiveboolNoDefault: true. When an exclusive panel opens, it closes every other open panel that is also exclusive. Set to false to let the panel stay open alongside others: non-exclusive panels are never auto-closed.
AnimationstringNoPanel open animation. Default: "Bounce". See below for available animations.

Panel animations. Three ship:

  • "SpinReveal" and "MaskedBounce": ship with General UI Kit.
  • "Bounce" (the default): ships with the Kernel, so it is always available.

A ModuleScript that returns function(menu: GuiObject) in General UI Kit's Client/PanelAnimations folder becomes another value, named after the module. That folder is the pack's own, so an update replaces it.

UI_Button

A clickable button (TextButton or ImageButton) that dispatches an action. The tag itself is a label: what makes a button work is being inside a menu or HUD element the kit manages. A button in a ScreenGui of your own is not wired.

AttributeTypeRequiredDescription
ActionstringYesAction name. The built-in ones below are handled for you; anything else is dispatched to your CustomHandlers module on click.
TargetPanelstringNoThe PanelId to act on. Only read when Action is TogglePanel or ClosePanel: it has no effect with other actions.
ShowTooltipboolNoIf true, shows the shared Button tooltip on hover (see UI_Tooltip).
TooltipTextstringNoText shown in the Button tooltip. Defaults to the button's Name.
BuySoundboolNoIf true, plays the purchase sound instead of the standard click sound.

Linking a button to a panel:

To open or close a panel from a button, set Action = "TogglePanel" and TargetPanel = "<PanelId>" on the button. No handler is needed; it is one of the built-in actions.

Example: a button that toggles the Shop panel.

  • Panel frame: tag UI_Panel, attributes PanelId = "Shop", Exclusive = true
  • Button: tag UI_Button, attributes Action = "TogglePanel", TargetPanel = "Shop"

Use Action = "ClosePanel" (with the same TargetPanel) for a dedicated close button inside the panel. If you omit TargetPanel on a ClosePanel button, it closes the nearest ancestor panel: handy for a generic X button.

Icon hover effect: a direct child of the button named Icon scales up slightly on hover and back on leave. Nothing to tag.

Every GuiButton inside the kit's menus and HUD is wired, tagged or not, so a button you add there gets the click and hover sounds for free. Two tags opt out: UI_Toggle, which is handled separately, and UI_Blocker, for the invisible full-screen sheet a modal panel puts behind itself. A blocker is a button only so that it swallows clicks, so it gets no sound, no tooltip and no icon tween.

UI_Animated

A decorative UI element with a looping animation.

AttributeTypeRequiredDescription
AnimationstringYes"Rotate" (a continuous spin), "HoverBob" (a float on hover), "SineBob" (a constant bob and rock) or "RainbowCycle" (cycles the background colour).
SpeednumberNoDuration in seconds of one full rotation: larger values spin slower. Default: 15. Only used by Rotate; the other three run at a fixed speed.

UI_Tooltip

A shared tooltip frame. There is one tooltip per type, the kit's GeneralUIKit.ButtonDetails and GeneralUIKit.EffectDetails pieces: every button with ShowTooltip uses the single Button tooltip, and every UI_EffectIcon uses the single Effect tooltip. You do not create a tooltip per button. ButtonDetails only lends its look (background, size, corners, outline and the ButtonName text style) to the Kernel's live button tooltip; anything else you add to it is not shown.

AttributeTypeRequiredDescription
TooltipTypestringYes"Button" (follows the cursor near a hovered button) or "Effect" (anchors beside a hovered effect icon, with screen-edge bounds checking).

Tooltip content contract. The labels a tooltip fills in are found either by name or by tag, anywhere inside the tooltip frame:

TagWherePurpose
ButtonName, by nameInside the Button tooltipTextLabel that receives the button's TooltipText, or its Name when none is set.
GeneralUIKit_EffectNameLabelInside the Effect tooltipTextLabel that receives the effect icon's Name.
GeneralUIKit_EffectDescriptionLabelInside the Effect tooltipTextLabel that receives the effect icon's Description.
Icon, by nameA direct child of any buttonScales up on hover.

UI_EffectIcon

An icon representing a buff or game effect. Hovering it shows the shared Effect tooltip with the icon's Name as the title and Description as the body.

AttributeTypeRequiredDescription
DescriptionstringYesText displayed in the Effect tooltip on hover.

UI_TypeSound

Apply to a TextBox to play a typing sound as the player types. The sound plays only when the text gets longer: backspace and deletions are silent. No attributes required.

UI_DataBind

Apply to a TextLabel or TextButton to live-bind its text to player data. The label updates automatically whenever the bound value changes: no polling, no manual refresh.

AttributeTypeRequiredDescription
DataPathstringYesDot-path into the replicated PlayerData folder, e.g. Stats.Cash.
PrefixstringNoText prepended to the value, e.g. "$".
SuffixstringNoText appended to the value, e.g. " pts".
FormatstringNoNumber formatting: Default (raw), Short (12.5K, 3.2M, 1.1B…), Full (floored integer), Commas (1,250,000). Non-numeric values are shown as-is.

Example: a cash counter in your HUD.

  • TextLabel: tag UI_DataBind, attributes DataPath = "Stats.Cash", Prefix = "$", Format = "Short"

Your own button actions

Set a button's Action attribute to a name, then add a function under that name in your own CustomHandlers module, a ModuleScript in ReplicatedStorage.RBLXEssentials.Extensions.GeneralUIKit. Updates never touch the Extensions folder.

-- ReplicatedStorage.RBLXEssentials.Extensions.GeneralUIKit.CustomHandlers
return {
    OpenShop = function(button)
        print(button.Name, "was pressed")
    end,

    BuyItem = function(button)
        local productId = button:GetAttribute("ProductId")
        game:GetService("MarketplaceService"):PromptProductPurchase(
            game.Players.LocalPlayer, productId
        )
    end,
}

The button itself is passed in, so you can read your own attributes off it and drive several buttons from one handler. An entry named InviteFriends, promptGamePass or promptDevProduct replaces the built-in one; TogglePanel and ClosePanel cannot be replaced.

Built-in Actions

These are handled for you. You do not need a handler for any of them.

ActionEffect
TogglePanelToggles the panel named in TargetPanel.
ClosePanelCloses the panel named in TargetPanel, or the button's nearest ancestor panel if TargetPanel is unset.
InviteFriendsPrompts the SocialService friend-invite dialog (permission-checked; fails silently if invites aren't available).
promptGamePassPrompts the purchase of the game pass in the button's GamePassId attribute.
promptDevProductPrompts the purchase of the developer product in the button's ProductId attribute.

Notes

  • Sound System is optional. Every sound this pack asks for goes through the kernel, which is silent until Sound System registers itself. Install it and the whole kit gains its clicks, hovers and typing sounds at once; leave it out and nothing errors.
  • Every GuiButton inside the kit's menus and HUD is wired for click and hover sounds with no tag needed. To exclude one, such as an invisible click blocker, tag it UI_Blocker.
  • Tooltips are throttled at 16ms intervals to avoid layout thrashing.
  • Every connection is cleaned up when the GUI is destroyed, so respawns and reloads leave nothing behind.

Classic UI Kit

PackId: ClassicUIKit  ·  Version: 3.5.2  ·  Requires: nothing

The Shop in Play, in the Studded finish: studs on every colour surface.
The Shop in Play, in the Studded finish: studs on every colour surface.

Sold apart from General UI Kit, and it needs no other kit. It works like General UI Kit; only the look changes.

What It Does

Classic UI Kit gives your game its whole menu interface in a chunky, outlined Stud look: 16 menus, General UI Kit's 14 plus Datastore & Purchase's two gift menus (Shop, Settings, Teleport, Changelogs, Pets, Codes, Daily Rewards, Rewards, Spin, Rebirth, Upgrades, Trade, Trade Inventory, Trade Request, Gift and Gift Received), the 11 HUD buttons, the Changelogs and invite buttons, the effects bar and the tooltips. It also brings its own look for Easy Pet System's hatches, Notifications System's cards and Sound System's music player.

Its menus and buttons behave exactly like General UI Kit's: the same actions, the same pack menus slotting in, the same CustomHandlers (yours go in ReplicatedStorage.RBLXEssentials.Extensions.ClassicUIKit.CustomHandlers; a game that came from General UI Kit keeps using its Extensions.GeneralUIKit.CustomHandlers too). Since 3.5.0 both kits run one shared engine in the Kernel.

Style: four styles, each a finish and a font

The font is part of the style, so you never pick a font on its own: Classic UI Kit comes in four styles. Studded puts the stud tile on every colour surface, square and the same size everywhere; Plain is the same look without studs. Fredoka is the kit's own rounded font; Montserrat is Montserrat Black, wider and sharper, with the same thick outline. Pick one on the card's Style tab: Plain (Fredoka), Plain (Montserrat), Studded (Fredoka) (the default) or Studded (Montserrat). Every text keeps a margin inside its button, so both fonts fit. If you don't own the kit, those entries are locked, with a link to its store page.

The same Shop in the Plain finish: the same look without studs.
The same Shop in the Plain finish: the same look without studs.

With General UI Kit too

Only the style's kit is used: the Style tab chooses between them, and the other kit's menus step aside. Each kit keeps its own copies of the menus you edited, so switching back finds them as you left them. The style is saved in Config.Game (Kit = "ClassicUIKit", Style = "studded-montserrat"); for your AI, T.style({ kit = "ClassicUIKit", style = "plain-montserrat" }) sets it.

Editing a menu

As in General UI Kit: the pencil beside a part on the kit's page in the plugin makes your own copy in StarterGui > RBLXEssentials > Interface, and updates never touch it. Your AI has the kit's map at /ai/ClassicUIKit.md.

Studded Glass UI Kit

PackId: StuddedGlassUIKit  ·  Version: 3.5.4  ·  Requires: nothing

The Shop in Play, in the Studded style: studded colour pieces over a dark glass body.
The Shop in Play, in the Studded style: studded colour pieces over a dark glass body.

Sold apart from the other GUI kits, and it needs no other kit. It works like General UI Kit; only the look changes.

What It Does

Studded Glass UI Kit gives your game its whole menu interface with bright colour pieces (headers, buttons, cards) that carry toy-brick studs and a thick dark outline, over dark see-through glass menu bodies the game world shows through. It has the same 17 menus as the other kits (Shop, Settings, Teleport, Changelogs, Pets, Index, Codes, Daily Rewards, Rewards, Spin, Rebirth, Upgrades, Trade, Trade Inventory, Trade Request, Gift and Gift Received) and the HUD: the menu buttons, the cash counter, the boosts, and the invite and updates buttons. It also brings its own look for the hatch reveals, the notifications and the music player.

Menus slide up from the bottom when they open and slide down when they close; buttons grow and darken on hover. Everything else behaves exactly like General UI Kit: the same actions, the same pack menus slotting in (pets, roulette, time rewards, codes, notifications, datastore gifts, sound), the same CustomHandlers (yours go in ReplicatedStorage.RBLXEssentials.Extensions.StuddedGlassUIKit.CustomHandlers; a game that came from General UI Kit keeps using its Extensions.GeneralUIKit.CustomHandlers too).

Style: four styles, each a finish and a font

Studded puts the studs on every colour piece; Plain is the same look without studs. Each comes with Fredoka or Montserrat. Pick one on the card's Style tab: Plain (Fredoka), Plain (Montserrat), Studded (Fredoka) (the default) or Studded (Montserrat). If you don't own the kit, those entries are locked, with a link to its store page.

The same Shop in the Plain style with Montserrat: the same look without studs.
The same Shop in the Plain style with Montserrat: the same look without studs.

With another GUI kit too

Only the style's kit is used: the Style tab chooses between them, and the other kits' menus step aside. Each kit keeps its own copies of the menus you edited, so switching back finds them as you left them. The style is saved in Config.Game (Kit = "StuddedGlassUIKit", Style = "studded-fredoka"); for your AI, T.style({ kit = "StuddedGlassUIKit", style = "plain-montserrat" }) sets it.

Editing a menu

As in General UI Kit: the pencil beside a part on the kit's page in the plugin makes your own copy in StarterGui > RBLXEssentials > Interface, and updates never touch it. Your AI has the kit's map at /ai/StuddedGlassUIKit.md.

Leaderboards System

PackId: EasyLeaderstatsSystem  ·  Version: 3.2.1  ·  Dependencies: Datastore & Purchase System

Your AI changes how a stat is shown in the player list.
Both boards in Play, then the player list with Cash and Wins.
Stats and boards in the plugin.
Stats and boards in the plugin.

In 3.0 the options 2.x kept in this pack's Settings folder live in your game's configuration module, Config.EasyLeaderstatsSystem in ReplicatedStorage (every option is shared). The plugin's panel shown on this page edits them, and your AI lists every option with T.config.reference("EasyLeaderstatsSystem").

What It Does

Leaderboards System adds two related features to your game:

  • Leaderstats: the in-game stat list shown in the Tab/escape menu. Values are read directly from player data (provided by the Datastore & Purchase System) and kept in sync automatically.
  • Global Leaderboards: physical in-world boards that display the all-time top players for any stat, stored in Roblox OrderedDataStores and refreshed on a configurable interval.

Both features are fully configuration-driven from the plugin. No script editing is needed to add or remove stats and leaderboards.

Plugin Configuration

Selecting the pack in the plugin opens a settings panel with two sections: Leaderstats and Leaderboards.

Leaderstats

Leaderboards System plugin settings: each stat's number format, column name and position

Each stat entry corresponds to one row in the Tab menu. Entries are grouped by the data group they belong to (e.g. Stats).

FieldDescription
DisplayNameLabel shown in the Tab menu (e.g. Cash, Wins).
OrderSort order within the stat list. Lower numbers appear first.
DataKeyDot-path into PlayerData (e.g. Stats.Cash). It must exist in Datastore & Purchase System's Default Data. A stat your game already shows needs Unlock before you change it.
DisplayFormatOptional formatting keyword applied to the raw number (see the keyword table below). If empty, Default is used.
PrefixOptional text prepended to the displayed value (e.g. $).
SuffixOptional text appended to the displayed value (e.g. wins).

DisplayFormat accepts these keywords (not printf-style format strings):

KeywordBehaviour
DefaultRaw number, displayed as-is.
ShortAbbreviated with a suffix tier: 1.5K, 2.3M: tiers go K, M, B, T, Qa, Qi.
FullFloored integer (52500.9 → 52500).
CommasThousands separators (52500 → 52,500).

These fields compose left-to-right: Prefix + formatted value + Suffix. When a Prefix or Suffix is set and the format is Default, the value is formatted as Full (a floored integer string) so the affix can wrap it.

DisplayFormatPrefixSuffixRaw valueResult
Default(empty)(empty)5250052500
Short(empty)(empty)5250052.5K
Short(empty)(empty)23000002.3M
Commas$(empty)52500$52,500
Default$(empty)52500.9$52500 (treated as Full because a prefix is set)
Full(empty) wins77 wins

+ Add stat creates a new entry at the end. Type its DataKey; the value must already exist in your Datastore Default Data.

Leaderboards

Global Settings

Leaderboards System plugin settings: Rows per board and Refresh every
SettingDefaultDescription
RefreshInterval60Seconds between board refreshes.
MaxEntries50Maximum rows shown per board.

Leaderboards

Leaderboards System plugin settings: the Cash and Wins boards Leaderboard model in workspace

Each entry drives one physical in-world leaderboard board: a Model tagged ELS_Leaderboard, matched to its entry by its ELS_LeaderboardId attribute. At runtime the model can sit anywhere in the workspace. The plugin manages the boards inside Workspace > RBLXEssentials > EasyLeaderstatsSystem > Boards: a tagged model there with no entry is listed as an orphan, which Delete removes.

FieldDescription
StatPathDot-path into PlayerData for the stat this board tracks (e.g. Stats.Cash). It also names the board's store, so another stat starts the board empty, and a board you already have needs Unlock first.
TemplateWhich of the three designs this board's model uses, from a dropdown. Changing it swaps the model in the world right away, keeping its position and orientation. It is not a configuration option: the design belongs to the model.
ValueFormatHow values are displayed: Raw (52500), Comma (52,500), or Abbreviated (52.5K).
EnabledWhen OFF, this leaderboard is skipped entirely.
A board's design and number format

+ Add Leaderboard asks for a name, a stat path and a template, then clones that template into Workspace > RBLXEssentials > EasyLeaderstatsSystem > Boards, gives it its own id, and adds its entry to your Leaderboards settings. The new model is selected in Studio for you, so you can drag it where it belongs.

The × on a board removes both its entry and its model, after a second click to confirm. A board your settings already hold shows it only after Unlock.

Duplicating a Board in Studio

If you duplicate a leaderboard Model inside Workspace > RBLXEssentials > EasyLeaderstatsSystem > Boards, the plugin notices the repeated id and gives the copy a new id and its own entry in your Leaderboards settings.

Uninstalling

The pack's More menu in the plugin: Where its files are and Uninstall

Choose Uninstall in the More menu of the pack's page. It moves the pack, and everything in Workspace > RBLXEssentials > EasyLeaderstatsSystem (the boards you added there included), into a protected backup. Your configuration module stays.


That's everything from the plugin.

The sections below cover how it works underneath and what to expect at runtime.

How It Works

Leaderstats

A leaderstats folder is created under each player as they join, with one entry per configured stat. The value is read from that player's replicated save using the DataKey path, and a changed signal keeps it in step for the rest of the session. You never write to leaderstats yourself: change the saved value and the row follows.

The leaderstat type follows the source value in PlayerData:

Source typeLeaderstat created
IntValue / NumberValueIntValue: or StringValue when a custom DisplayFormat, Prefix, or Suffix is set, so the formatted text can be displayed.
StringValueStringValue: Prefix/Suffix are still applied to the string.
BoolValueBoolValue: shown as true/false.

Global Leaderboards

Stats are written to OrderedDataStores in three situations:

  1. On join: once the player's save is ready (it waits up to 10 seconds), every configured stat is written. A stat the save does not have is skipped, with one warning per player and session.
  2. On leave: stats are written immediately when the player disconnects.
  3. Periodically: every 5 minutes, all current players' stats are written to keep leaderboard data fresh for long sessions.

Board UI is refreshed every RefreshInterval seconds. The first refresh runs 5 seconds after server start to allow player data to load. During each refresh, the top MaxEntries players are read from the OrderedDataStore and the SurfaceGui list on the in-world board is rebuilt. A countdown timer on each board shows when the next refresh will occur.

Per-board display settings have sensible fallbacks, all derived from the last segment of StatPath (e.g. Stats.Cash → Cash):

  • Empty TitleLabelText → TOP <STAT> (e.g. TOP CASH).
  • Empty VariableNameText → <STAT> (e.g. CASH).
  • ValueFormat defaults to Raw; any other value than Raw, Comma or Abbreviated fails the configuration check. Abbreviated covers the K, M and B tiers, always with one decimal (1.0K).

OrderedDataStore Naming

Store names are derived automatically from the stat path: GlobalLeaderboard_ followed by the dot-path with dots replaced by underscores.

-- e.g. Stats.Cash → GlobalLeaderboard_Stats_Cash

Inspecting the raw store: values are stored with a +1 offset (subtracted back on read), so a stored 52501 means the player's stat is 52500. A stat of 0 is stored as 1 and shows as 0; negative stats are not written at all.

Dummy Avatars

The top three players on each board wear their real Roblox avatar on Dummy1, Dummy2 and Dummy3 beside it, playing a looping emote.

The scale comes from the rig itself. Each template builds its podium dummies at its own size, and the pack measures that before applying anything, so an avatar lands at the size the template was designed for rather than at one number shared by every board. A podium you scaled yourself is measured the same way and keeps working.

A rank whose player has not changed since the last refresh is left alone, so only a genuine change costs a GetHumanoidDescriptionFromUserId call.

Settings Structure

All options live in your game's module ReplicatedStorage > RBLXEssentials > Config > EasyLeaderstatsSystem, which no update replaces. It returns only what you change; everything else keeps its default. The plugin is the way to edit it.

return {
    Leaderstats = {              -- the whole list, in Tab menu order
        { DataKey = "Stats.Cash", Name = "Cash", Format = "Default", Prefix = "", Suffix = "" },
        { DataKey = "Stats.Wins", Name = "Wins" },
    },
    Leaderboards = {
        RefreshInterval = 60,    -- seconds between refreshes
        MaxEntries = 50,         -- rows per board, 1 to 100
        Boards = {               -- the whole list
            { Id = "df9dad80-8ee9-4005-a1a5-0259749b45f9", StatPath = "Stats.Cash",
              Enabled = true, ValueFormat = "Raw", Title = "", Header = "" },
            { Id = "a28430f9-c7b6-4352-b3ba-9b33f0ebe37f", StatPath = "Stats.Wins",
              ValueFormat = "Abbreviated" },
        },
    },
}

In the plugin, Name is DisplayName, Format is DisplayFormat, Title is TitleLabelText and Header is VariableNameText; a stat's Order is its position in the list. A board's Id is the ELS_LeaderboardId of its model in the workspace. Leaderstats and Boards are replaced whole, so list every stat and every board you want. Never change the StatPath of a board that already has ranks: it names the board's store.

The three board designs live in the pack's own Assets folder on the server. They are the catalogue + Add Leaderboard clones from; nothing reads them at runtime.

ServerScriptService.RBLXEssentials.Packs.EasyLeaderstatsSystem
└── Assets/
    └── Templates/
        ├── LeaderboardTemplate1   [Model]
        ├── LeaderboardTemplate2   [Model]
        └── LeaderboardTemplate3   [Model]

In-World Board Setup

A board is a Model in the workspace tagged ELS_Leaderboard, wherever you put it, matched to an entry in your Leaderboards settings by its ELS_LeaderboardId attribute. New ones are cloned from the design you pick in the add form and dropped into Workspace > RBLXEssentials > EasyLeaderstatsSystem > Boards for tidiness, which is created if it is not there. Changing Template later swaps the model in place, keeping its position and orientation.

Copy a board in Studio and the plugin picks it up. A copy inside that Boards folder gets a new id and its own entry in your Leaderboards settings, and you point it at a different stat. A board with no entry is never filled in at runtime.

The system locates UI elements by ELS_Role attribute, not by path, so the internal hierarchy of the model can vary between templates.

[StatPath leaf] Leaderboard  [Model]
├── BoardModel
│   ├── BoardBase  [Part]
│   │   └── Leaderboard  [SurfaceGui]
│   │       ├── Rank   [TextLabel, header]  ELS_Role = HeaderRank
│   │       ├── Name   [TextLabel, header]  ELS_Role = HeaderName
│   │       ├── Value  [TextLabel, header]  ELS_Role = HeaderValue  (shows VariableNameText)
│   │       └── List   [ScrollingFrame]     ELS_Role = List
│   │           └── Template  [Frame, cloned per entry, must stay hidden]
│   │               └── Frame
│   │                   ├── Rank, Name, Value  [TextLabel]
│   │                   └── Icon  [ImageLabel]
│   └── TopPart  [Part]
│       └── Leaderboard  [SurfaceGui]
│           └── TextLabel  ELS_Role = TitleLabel  (shows TitleLabelText)
├── Dummy1 / Dummy2 / Dummy3  [Model, R15 rigs for top-3 avatars]
└── Timer  [Part]
    └── GUI  [SurfaceGui]
        └── Label  [TextLabel, shows "Refresh in: Xs"]
ELS_RoleElementPopulated with
TitleLabelTextLabel on TopPart boardTitleLabelText setting (e.g. TOP CASH)
ListScrollingFrame containing entry rows(used as parent for cloned entries)
HeaderRankRank header TextLabelRANK (static, set by the template)
HeaderNameName header TextLabelNAME (static, set by the template)
HeaderValueValue header TextLabelVariableNameText setting (e.g. CASH)

Each board Model also carries these attributes (managed by the plugin):

AttributeTypePurpose
ELS_LeaderboardIdstring (GUID)Stable unique link to the board's entry in Leaderboards settings (the entry's Id).
ELS_StatPathstringDot-path into PlayerData (e.g. Stats.Cash).

Requirements

  • Datastore & Purchase System must be installed and providing PlayerData for each player.
  • API Services must be enabled (Game Settings → Security → Enable Studio Access to API Services) for OrderedDataStores to work in Studio.

Notifications System

PackId: NotificationsSystem  ·  Version: 3.3.3  ·  Requires: nothing

Your AI turns on join messages and timed announcements.
Toasts stacking in the corner, then a banner, in Play.
Notification styles and triggers in the plugin.
Notification styles and triggers in the plugin.

In 3.0 the options 2.x kept in this pack's Settings folder live in your game's configuration modules, Config.NotificationsSystem in ReplicatedStorage (every option of this pack is shared, so there is no server-only module). The plugin's panel shown on this page edits them, and your AI lists every option with T.config.reference("NotificationsSystem").

What It Does

This is the pack that tells your players things. Three surfaces, four ready-made reasons to use them, and one line of code for anything else you want to announce.

  • Toasts. Cards that slide in, stack, and leave on their own. Four shapes ship: title only, title and subtitle, image and title, and image with both.
  • Chat lines. A system message in a colour you choose. Cheap, unmissable, and it never covers the screen.
  • Banner. A large centred card for the things that matter: a restart, an event going live, a message from you. One line or two.
Three Toy toasts stacked in the corner in game (Welcome back!, Quest complete! and Daily reward), each with its timer bar

Installed on its own it already announces four things with no code at all: a player's friend joining with their headshot, someone buying with Robux (a line to the server plus a confirmation to the buyer), your rotating announcements, and anyone joining or leaving (off by default, since most places already do this their own way).

Every other RBLX Essentials pack lights up when this one is installed: a code redeemed, a pet arriving from something other than an egg, a free spin coming up, a session gift becoming claimable. None of them require it. They simply go quiet without it.

Plugin Configuration

Templates

Notification design set to Toy above the seven templates listed in the plugin, each with its pencil

Two designs ship: Toy, the default, with bright gradients, a thick outline and a raised edge, and Sleek, navy cards like the music player. Choose one with Notification design at the top of the pack's settings: it makes your own copy of the notification layer with that design's cards, keeping each template's timing, sound and stacking, and any template you added. Revert changes in Interface goes back to the pack's. Each card has a bar that empties over its duration.

Seven templates ship. Expanding one shows the card itself at its real proportions with its true pixel size underneath. Beside its name is the pencil, the same one General UI Kit uses for menus. The pack's own templates are never edited: the first click makes your own copy of the notification layer, which updates never touch. After that, click it and the template appears on screen and is selected in the Explorer, so you can drag it where you want and design it in Studio. Click it again when you are done. The plugin warns you if you leave one visible, because Visible is saved with your place.

A template expanded: its Toy card preview with the example text and timer bar, its pixel size at 1080p, and every attribute

Triggers

TriggerWhat it doesShips
FriendJoinedA toast, with the friend's headshot, to both friends when one joins the other's server.On
PurchasesA server-wide chat line plus the buyer's own confirmation toast. Wants Datastore & Purchase System.On
AnnouncementsThe rotating messages, on a timer.On
JoinLeaveA chat line for anyone joining or leaving.Off

Each row carries a ? you can hover for what that trigger does. A trigger's wording is an option too: the plugin shows the texts of FriendJoined, JoinLeave and Purchases in their own groups below the switches, saved in Config.NotificationsSystem. To change "Friend joined!", edit FriendJoined's Title. Those texts understand {player}, and the Purchases ones {item} and {price} too.

Announcements

The rotating announcement messages: Every 5 min, Shown as, Random order and messages #1 to #3
FieldWhat it does
IntervalMinutesMinutes between messages. Anything under half a minute is treated as half a minute.
SurfaceChat or Banner.
ShufflePick at random instead of in order. It never repeats the message just shown.
MessagesThe messages themselves, in order (rows Message1..N in the plugin). + Add message and Delete message are in the plugin. A message must have some text: a blank one fails the configuration check.

An announcement is shown exactly as you typed it: {player}, {item} and {price} are not replaced here, only in the trigger texts above. Turning the whole rotation off is the Announcements switch in Triggers, not a field here.

Gains flying to the counter

When the cash counter grows, a "+amount" flies to it. CounterFlyout (3.3.2) decides which gains fly:

FieldWhat it does
MinAmountSmaller gains never fly (the counter still counts them). Default 0.
GroupSecondsGains this close together, like income every second, fly once, plus any gain 3 times bigger (a code, a spin). Default 0: every gain flies; 2 groups income every second.

To turn the flyouts off completely, delete Assets.CounterEffects in the pack.

Uninstalling

The pack's More menu in the plugin: Where its files are and Uninstall

Choose Uninstall in the More menu of the pack's page.


That's everything from the plugin.

Below: how to restyle a template, write your own trigger, and announce your own things from code.

Designing the templates

The seven live in the notification layer's Templates folder. Make your own copy of the layer first (the pencil in the plugin's Interface tab, or ask your AI): it goes to StarterGui > RBLXEssentials > Interface, updates never touch it, and its templates are yours to move, resize and restyle. Change BackgroundColor3 on a template frame to recolour the whole card.

A restyled notification template

They are drawn in General UI Kit's visual language, so they sit beside your menus rather than beside a different product. Their borders are UIStrokes on StrokeSizingMode = ScaledSize, which makes Thickness a fraction of the frame's height rather than a number of pixels: resize a card and its border keeps its proportions. That is how the whole kit is built.

Every Position and Size is in scale, never offset, with a UIAspectRatioConstraint holding each card's shape. A card is the same fraction of the screen on a phone as on a 4K monitor. Keep it that way when you move them: drag with the scale handles, not the offset ones.

Where they appear, and what queues behind what

Where you put a template is where its notifications appear. StackGroup decides who queues behind whom: give two templates the same group name and their notifications form one column, taking turns instead of landing on top of each other, whatever mix of heights they are. Leave a group empty and that template stacks on its own.

Out of the box the four toasts share the group Toasts, so a friend-joined card and a reward card queue in one column. The two banners share Banner. So a "friend joined" card can live in the bottom-left while a reward card comes down from the top-centre, and they never fight, as long as their groups differ.

Nothing ever waits for a slot. When a template is already showing its MaxOnScreen limit, the next one dismisses the oldest of that kind early and takes its place. A notification held back until a slot opened would arrive describing something that had already stopped being true.

Making your own template

Duplicate one in your copy of the layer and rename it. That is the whole procedure: the new name appears in the plugin immediately and can be used anywhere a template is named. It works because a template carries its own behaviour, as attributes on the frame:

AttributeWhat it does
DurationSeconds on screen.
StackDirectionDown, Up, Left or Right. Leave it on Auto and the stack grows away from the nearest edge.
MaxOnScreenHow many of this type show at once. At the limit a new one replaces the oldest. 0 means no limit.
SoundA sound from Sound System's SFX folder, picked from a dropdown of the ones you actually have. Silent, not broken, without that pack.
AnimationSlide, Fade or Pop.
StackGroupWhich column this template queues in.
SlideFromWhich edge the card slides in from. Only used when Animation is Slide, and it changes the entry only: the card still stops where you put it.

The renderer fills three children by name: Title, Subtitle and Image. Image is a container, a plate (a round badge in Toy, a rounded tile in Sleek) holding an ImageLabel called Content; the plate is what shows while a headshot loads. A Timer frame with a Fill inside empties over the card's duration. Delete one and that field simply is not drawn, so your redesign cannot break the pack. Add one to a template that had none and it starts being filled.

The two that behave differently

The banners are a fixed card at the top centre, 480 pixels wide on a 1080p screen (72 tall, 92 with a subtitle). A long title shrinks to fit inside it rather than widening the card, so it never runs past the corners.

The centre banner in game: the gold Toy banner with stars, Double Cash weekend! and a subtitle

Alert sits at the bottom centre. A red pill in Toy, a navy one with a red border in Sleek, with a "!" before the text. It stacks upward, because it hangs off the bottom edge. Use it when something could not be done: not enough money, a full inventory, a pass they do not own. It leaves after three seconds rather than five, because a refusal is a correction rather than news, and it plays Code_Error instead of the reward sound.

The pill is not decoration. Its fill and its outline (the UIStroke) are what keep the white text readable over whatever colour your game happens to be. Keep both if you restyle.

Easy Pet System already speaks through it: try to open an egg without enough Cash, or equip a fourth pet, and the line you see is this template.

Everything else in the kit is TextScaled, which means the height of the label decides how big the text renders, not TextSize. Make a label taller to make its text bigger.

Announcing your own things

From any Script or LocalScript of your own:

local Notify = require(game:GetService("ReplicatedStorage")
    .RBLXEssentials.Packs.NotificationsSystem.Notify)

-- server
Notify.Toast(player, "TitleSubtitle", { Title = "Well done", Subtitle = "You found the secret!" })
Notify.ToastAll("TitleOnly", { Title = "The boss has spawned!" })
Notify.Chat("Double XP is live for the next hour!", Color3.fromRGB(255, 215, 0))
Notify.ChatTo(player, "Welcome back!")
Notify.Banner(player, { Title = "Round starting", Subtitle = "Get to the arena" })
Notify.BannerAll({ Title = "Server restarting in 5 minutes" })

-- client: Toast, Banner and Chat, without the player (this player only)
Notify.Toast("TitleOnly", { Title = "Saved!" })

The data table can carry Title, Subtitle, Image (an asset id), ImageUserId (resolved to that player's headshot). A chat line's colour is the second argument of Chat and ChatTo.

It can also override the template's behaviour, for that one notification. Pass any of Duration, MaxOnScreen, Sound, Animation or SlideFrom and it wins over what the frame says:

Notify.Toast(player, "TitleOnly", { Title = "Saved!", Duration = 1, Animation = "Pop" })

The names are the template's own attribute names, so there is nothing extra to learn. A value the renderer cannot use is ignored and the template's own setting stands, so a typo costs that call its override rather than the message. Passing a Subtitle to a title-only card is harmless.

StackDirection is the one behaviour you cannot override per call, on purpose: direction belongs to a column rather than to a card. Set it on the template, where it describes the column.

Writing a trigger

Drop a ModuleScript into ServerScriptService > RBLXEssentials > Extensions > NotificationsSystem, a folder updates never touch, and it starts with the pack. Nothing else to wire:

local Players = game:GetService("Players")

local MyTrigger = {}

function MyTrigger.Start(ctx, trove)
    trove:Connect(Players.PlayerAdded, function(player)
        ctx.kernel.Notify:Toast(player, "TitleOnly", { Title = "Welcome!" })
    end)
end

return MyTrigger
  • trove cleans up with the pack, so connect through it and you have nothing to disconnect.
  • Read the pack's options from ctx.config. The 2.x ctx.settings is not there in 3.0.
  • Start must not yield. Do slow work in your own task.spawn.
  • A module with no Enabled attribute is on: you added it because you wanted it. Set Enabled to false to switch it off; the plugin's switches are for the pack's four triggers.
  • A module named like one of the four (FriendJoined, say) runs instead of the pack's, under that trigger's switch in Config.NotificationsSystem.Triggers.
  • A module that fails to load, or errors while starting, is skipped with a warning. It cannot take the other triggers down with it.

For pack authors

A pack does not use the module above. It calls the kernel facade:

ctx.kernel.Notify:Toast(player, "TitleSubtitle", { Title = "…" })  -- server
ctx.kernel.Notify:Toast("TitleSubtitle", { Title = "…" })          -- client

ctx.kernel.Notify is a silent no-op until Notifications System registers itself as its backend. That is why no pack declares this one in manifest.deps and why none of them checks whether it is installed. The asymmetry is deliberate: a pack wants silence when the pack is absent, and a person writing code wants to be told, so the front-door module errors at the require line instead.

Hooking purchases yourself

Datastore & Purchase System publishes a BindableEvent that this pack listens to, and so can you:

local hook = game:GetService("ServerScriptService").RBLXEssentials
    .Packs.DatastorePurchaseSystem:FindFirstChild("PurchaseCompleted")
if hook then
    hook.Event:Connect(function(player, kind, id, currencySpent)
        print(player.Name, "bought", kind, id, "for", currencySpent)
    end)
end

kind is "product" or "gamepass", For a product it fires once the reward and the receipt are saved; for a game pass, when Roblox reports the purchase, with currencySpent as nil. It also fires for FreeMode product grants (with 0 spent), which is how you test a purchase announcement in Studio without spending Robux.

Menus

None. Like Datastore & Purchase System and Leaderboards System, it has no panel and no HUD button, because there is nothing to open.

Roulette System

PackId: RouletteSystem  ·  Version: 3.3.4  ·  Requires: Datastore & Purchase System

Your AI sets how often the free spin comes back.
A spin in Play: the wheel lands, the prize bursts out and the free spin timer starts.
Prizes, odds and spins in the plugin.
Prizes, odds and spins in the plugin.

In 3.0 the options 2.x kept in this pack's Settings folder live in your game's configuration modules, Config.RouletteSystem in ReplicatedStorage and in ServerScriptService. The plugin's panel shown on this page edits them, and your AI lists every option with T.config.reference("RouletteSystem").

What It Does

Roulette System adds a spin-to-win wheel. Players spend spins to land on rewards, earn a free spin on a cooldown, and can buy more with developer products. All of it is configured from the plugin.

  • Weighted random rewards: Cash, Diamonds, more Spins, any number in the player's save (Stat), or a module you write (Custom). A random pet from an Easy Pet System egg ships ready to use.
  • A free spin cooldown whose clock starts when a player reaches zero spins, and a spin lands when it runs out.
  • +1 / +3 / +10 spin developer products. They ship as demo products: paste your own ids in the plugin.
  • 2 to 12 wheel slots (seven out of the box) with a name, an icon, a type, an amount and a weight. Typing a name or icon in the plugin redraws the wheel in Studio as you type.
  • If the client never reports the wheel finished, the server grants the reward anyway after 10 seconds, and on leave.

Plugin Configuration

Spins

Spins settings in the plugin: Starting spins, Most spins and Free spin every 15 min
SettingDefaultWhat it does
StartingSpins1Spins a brand new player starts with.
MaxSpins0Cap on spins in hand. 0 means no cap.
FreeSpinCooldown900Seconds until a free spin once the player runs out.

Dev Products

Spin products in the plugin: +1, +3 and +10 spins, each marked as a demo product

Paste the developer product id each button should sell. The ids that ship are RBLX Essentials demo products, so replace them with your own. 0 means that button is shown but sells nothing, and the server's Output says so when it starts. The receipts are handled by Datastore & Purchase System, so a purchase is granted once and recorded like any other.

Rewards

The Roulette rewards with a live wheel preview above its seven slots

The wheel at the top is the real one, redrawn as you edit. Raise or lower the slot count, from 2 to 12, and the wheel redraws for it. Each slot has six fields. The reward (Type, Target, Amount, Weight) goes in the server-only Rewards option, so players never see the odds; what players see on the slot (DisplayName, Icon) goes in the shared Wheel option, one entry per slot:

One reward slot open: Type, Amount, Chance, Label and Image with its picture
FieldWhat it does
TypeCash, Diamonds, Spins, Stat (any dot path in Target, such as Stats.Wins) or Custom (a module named in Target).
TargetOnly for Stat and Custom. For Custom the plugin lists your reward modules as a dropdown.
AmountHow much is granted. For Custom, how many times Grant runs.
WeightRelative chance. A slot at 100 lands twice as often as one at 50. 0 never lands.
DisplayNameText on the slot, in Wheel. The plugin shows it on the wheel as you type, and the game applies it at play time.
IconImage on the slot (rbxassetid://…), in Wheel. Each slot ships with its own.

Cash and Diamonds never go below zero. An unknown type, or a Stat or Custom slot with no target, fails the configuration check, and the pack does not start until it is fixed. A Custom slot whose module is missing is switched off at startup with a warning in the Output.

What ships in the seven slots

SlotTypeAmountWeight
1Cash100100
2Cash25080
3Cash50050
4Cash100030
5Diamonds1040
6Custom, RandomPet120
7Spins160

Uninstalling

The pack's More menu in the plugin: Where its files are and Uninstall

Choose Uninstall in the More menu of the pack's page. It removes the pack from every service it was installed into. Your Config.RouletteSystem modules stay.


That's everything from the plugin.

If you are not writing custom rewards or calling the pack from your own code, you can stop here.

Where things live

ReplicatedStorage.RBLXEssentials.Packs.RouletteSystem
└── manifest, Schema, Options, Pieces, RewardLabels, Client, Migrations
ReplicatedStorage.RBLXEssentials.Config.RouletteSystem    -- yours: Spins, DevProducts, Wheel
ServerScriptService.RBLXEssentials.Packs.RouletteSystem
├── Roulette                        -- the rules
├── PaidSpins, Starter              -- paid bundles, the shipped seven slots
└── CustomRewards/RandomPet, GrantPet
ServerScriptService.RBLXEssentials.Config.RouletteSystem  -- yours: Rewards (server only)
ServerScriptService.RBLXEssentials.Extensions.RouletteSystem  -- yours: reward modules
StarterGui.RBLXEssentials.RouletteSystem.RouletteSystemGUI

The Spin menu and its HUD button are this pack's own pieces, RouletteSystem.SpinPanel and RouletteSystem.SpinButton. To restyle them, make your own copy (the pencil in the plugin's Interface tab, or ask your AI); updates never touch it.

What it saves

The pack writes its own keys on join. There is nothing to add to Datastore's Default Data.

d.Roulette.Spins        -- spins in hand
d.Roulette.LastSpinTime -- os.time() when they ran out (0 = no countdown)

Both are mirrored to player.PlayerData.Roulette so the client can read them.

Custom Rewards

Drop a ModuleScript into ServerScriptService > RBLXEssentials > Extensions > RouletteSystem, a folder updates never touch:

local MyReward = {}

function MyReward.Grant(player, d)
    -- d is the live save inside a data update; changes persist
    d.Stats = d.Stats or {}
    d.Stats.Diamonds = (d.Stats.Diamonds or 0) + 1
end

return MyReward

Set the slot's Type to Custom and pick it from the Module dropdown. Amount is how many times Grant runs per spin. A slot pointing at a module that is not there is switched off at boot with a warning.

Two modules ship with the pack:

  • RandomPet is slot 6's default, and works with or without Easy Pet System. It hatches one pet from an Easy Pet System egg using that egg's own odds, free, with the usual hatch toast. EGG_ID at the top picks the egg (Tier1Egg as shipped) and FALLBACK is what it grants when Easy Pet System is absent (25 Diamonds, or nil for nothing).
  • GrantPet grants one specific pet, named in PET_ID (Dog as shipped). It needs Easy Pet System: without it, the slot grants nothing and the Output says so.

To change either, copy it into Extensions > RouletteSystem and edit the copy: a module there runs instead of the pack's one with the same name.

API

Declare "RouletteSystem" in your pack's manifest.deps, then:

local roulette = ctx.require("RouletteSystem")

-- capped by MaxSpins; false if the amount is not positive
roulette.addSpins(player, 5)

-- waits for the player's save; 0 if it could not be read
roulette.getSpins(player)

-- true, or false and why: "No spins available" ("Data not loaded" before the save loads)
local ok, why = roulette.canSpin(player)

-- inside your own ds.Update: adds spins to that save table, capped by MaxSpins
roulette.grantSpins(d, 3)

grantSpins is how Codes System and Time Rewards System give spins. They do not declare Roulette System; they reach it with ctx.companion("RouletteSystem"), so a Spins reward is switched off with a warning when it is not installed.

Remotes

Created by the kernel under ReplicatedStorage > RBLXEssentials > Kernel > Remotes > RouletteSystem.

RemoteTypeDescription
RequestSpinRemoteFunctionSpends a spin and returns { Success = true, Reward = { Index, DisplayName, Icon } } or { Success = false, Error }. The reward is held until the wheel finishes.
AnimationCompleteRemoteEventGrants the held reward. A second RequestSpin grants it too, as do the 10 second timeout and leaving.

The free spin countdown is worked out on the client from Spins.FreeSpinCooldown in ReplicatedStorage.RBLXEssentials.Config.RouletteSystem, which every client can read. There is no claim remote.

Sounds

Roulette_Click as the wheel passes each slot, Roulette_Reward when it lands. Both ship in Sound System's SFX group and play through the kernel, so they are silent rather than broken when that pack is not installed.

Time Rewards System

PackId: TimeRewardsSystem  ·  Version: 3.3.3  ·  Requires: Datastore & Purchase System

Your AI sets the daily rewards and how often a new day unlocks.
Claiming day 1 of the daily rewards in Play.
Streak days and timed gifts in the plugin.
Streak days and timed gifts in the plugin.

In 3.0 the options 2.x kept in this pack's Settings folder live in your game's configuration module, Config.TimeRewardsSystem in ReplicatedStorage (every option of this pack is shared, so there is no server-only module). The plugin's panel shown on this page edits them, and your AI lists every option with T.config.reference("TimeRewardsSystem").

What It Does

Two reward systems that run side by side: a seven day streak for coming back, and six timed gifts for staying. Types, amounts, icons and timers are all plugin settings.

  • A seven day cycle on a cooldown you choose. Missing a day does not reset the cycle, it only pauses it.
  • Six session gifts that unlock at fixed minutes of unbroken playtime. Session progress lives in memory and starts again when the player rejoins, because these are rewards for staying.
  • Badges on both HUD buttons light up when something is claimable, and the daily panel opens by itself on join when a reward is waiting.
  • The session icon counts down to the next gift on the HUD itself. It clears once a gift is waiting, because the badge says that better than a clock at 00:00.
  • The current day announces itself: its tile grows, takes the gradient, and its icon bobs. The emphasis follows the cycle, so it moves on its own.

Plugin Configuration

Every reward slot, day or gift, shares the same six fields:

FieldWhat it does
TypeCash, Diamonds, Spins, Stat or Custom.
TargetOnly for Stat (a data path such as Stats.Wins) or Custom, where the plugin lists your reward modules as a dropdown.
AmountHow much is granted. A negative amount takes away, never below 0. For Custom, the number passed once to your module's Grant (GrantPet: how many pets).
IconImage on the tile (rbxassetid://…).
EnabledLeave it out and the slot is on. false (On unticked in the plugin) keeps the slot in its place but never grants it. A day that is off stops the daily cycle there for every player who reaches it.
FallbackOptional: what the slot grants instead when the pack it needs is missing (a Spins slot without Roulette System, or a Custom module such as GrantPet without Easy Pet System). It is a Cash, Diamonds or Stat reward with its own Amount, a Target for Stat and an optional Icon. The slot then stays on, the panel shows the fallback and the server says so when it starts. Without one, such a slot is switched off. It is not a row in the plugin: it is written in Config.TimeRewardsSystem (or by your AI), and the plugin keeps it when it saves.

Tile labels are written from those fields: +500 for a currency, +1 SPIN for spins, +5 Wins for a stat. Custom is the exception, because there is no number to show and a module name is not for players, so the tile keeps whatever label you author on it.

Session Gifts

The six session gifts in the plugin

Gift slots add one field, IntervalMinutes: the minutes of unbroken session playtime before that gift unlocks.

GiftIntervalTypeAmount
15 minCash10
210 minCash25
315 minCash50
430 minCash75
545 minCash100
660 minDiamonds10

Daily Rewards

The seven daily rewards and the streak rail preview, with Cooldown 24 h
SettingDefaultWhat it does
DailyRewards.ResetModeHoursHours gives each player a private clock started by their own claim. Midnight unlocks everyone together at 00:00 UTC, so someone who claims at 23:50 can claim again ten minutes later.
DailyRewards.CooldownHours24Hours between claims; 0 means always claimable. Ignored when the mode is Midnight.
DayTypeAmountFallback
1Cash100
2Cash200
3Spins1300 Cash
4Diamonds20
5Cash500
6Diamonds100
7Cash1000

The cycle works with any set of packs. Day 3 is a spin, which needs Roulette System: without it, Day 3 gives its Fallback, 300 Cash, and the panel shows that instead. The other days give Cash and Diamonds. A Spins day needs Roulette System and a GrantPet day needs Easy Pet System: without that pack the day gives its Fallback, or, with none, is switched off and the cycle stops there for every player who reaches it. A game moved from 2.x keeps the days it had, and a game that already set its days keeps them.

One day, open

A single day open in the plugin: Type, Amount, Image and On

An unknown Type, or a Stat or Custom slot with no Target, fails the configuration check before the pack starts. A Custom slot whose module is missing, or a Spins slot without Roulette System, gives its Fallback instead, or, with none, is switched off at startup. Either way the Output says so when the server starts, rather than the slot failing the first time a player tries to claim it.

Uninstalling

The pack's More menu in the plugin: Where its files are and Uninstall

Choose Uninstall in the More menu of the pack's page. It removes the pack from every service it was installed into. Your Config.TimeRewardsSystem modules stay, so installing it again picks them up.


That's everything from the plugin.

If you are not writing custom rewards or calling the pack from your own code, you can stop here.

What it saves

The daily half persists one key, created on join if it is not there:

data.TimeRewards = {
    Daily = {
        Streak    = 1,  -- position in the cycle (1..7), wraps after the last day
        LastClaim = 0,  -- os.time() of the last successful claim
    }
}

Streak is a position in the cycle, not a count of consecutive days. It advances by one per claim and wraps. Someone who claims Day 3 and disappears for a month comes back to Day 4, because the cooldown is the only gate.

Session state (when they joined, which gifts they took) lives on the server for the length of the session and is never written to the datastore.

Custom Rewards

Drop a ModuleScript into ServerScriptService > RBLXEssentials > Extensions > TimeRewardsSystem, which updates never touch:

local MyReward = {}

-- `d` is the live save inside a data update: changes persist and
-- replicate on their own. `amount` is the slot's Amount field.
function MyReward.Grant(player, d, amount)
    d.Stats = d.Stats or {}
    d.Stats.Diamonds = (d.Stats.Diamonds or 0) + amount
end

return MyReward
Choosing a custom reward module in the plugin

Set the slot's Type to Custom and pick it from the Module dropdown. A module may also have a Prepare function, which runs when the server starts: if it errors or returns false, every gift or day that names the module gives its Fallback, or, with none, is switched off (a day switched off stops the daily cycle there). A GrantPet example ships in the pack's own CustomRewards and needs Easy Pet System: it grants a pet of the tier named in PET_RARITY (Legendary as shipped) rather than one hardcoded pet, so the reward keeps matching its label after you edit your pet list. Set PET_ID instead to pin one exact pet.

The menus

The pack ships its own Rewards and DailyRewards menus and their HUD buttons. To restyle one, make your own copy (the pencil in the plugin's Interface tab, or ask your AI): it lives in StarterGui > RBLXEssentials > Interface, where updates never touch it, and the pack drives it instead. The current-day emphasis is applied at runtime, so it follows the cycle rather than being frozen on one tile.

PartPurpose
Container/Gifts/Gift<N>/ButtonFrameClaim face: ClaimButton, TimeLeftText
Container/Gifts/Gift<N>/RewardFrameReward face once claimed: Reward/ImageLabel, Reward/AmountText
Container/ClaimedRewardsThe "n of total claimed" line
Container/Days/Day<N>Day tile: DayLabel, Icon, Amount, ClaimButton/StatusText
Container/ProgressFill (streak over days), ProgressText
Container/FooterDailyStreak, TimeLeft

Reusing the day's motion anywhere

The bob on the current day is the same one General UI Kit gives any element, so you can put it on something of your own without code: tag it UI_Animated and set Animation = "SineBob". Day 7's sunburst spins the same way with Animation = "Rotate".

To retune the day icon itself, put any of IdleBobAmplitude (scale), IdleBobRotation (degrees) or IdleBobPeriod (seconds per cycle) as attributes on the panel's Container/Days frame.

API

local rewards = ctx.require("TimeRewardsSystem")

-- Where they are in the cycle, and how long until the next.
local daily = rewards.getDaily(player)
print(daily.dayIndex, daily.cooldownRemaining)

-- Second return: the new state, or why it was refused.
local ok, result = rewards.claimDaily(player)

-- The session half, by gift number.
rewards.getSession(player)
rewards.claim(player, 3)

A refusal is a reason, never a sentence, so the wording on screen stays yours: NotReady, AlreadyClaimed, OnCooldown, NoSuchGift, NoSuchDay, NoDays, BadIndex, GiftDisabled, DayDisabled, NoSession, NoData, GrantFailed, AdvanceFailed.

Remotes

Created on demand under ReplicatedStorage > RBLXEssentials > Kernel > Remotes > TimeRewardsSystem.

RemoteTypeDescription
ClaimGiftRemoteFunctionClaims a session gift by index.
GetSessionRemoteFunctionThe caller's session state, for the first paint and re-opens.
ClaimDailyRemoteFunctionClaims the current day.
GetDailyRemoteFunctionThe caller's daily state, including the remaining cooldown.

Every claim is validated on the server against the same rules the panel shows. The client is never trusted for eligibility.

Codes System

PackId: CodesSystem  ·  Version: 3.3.2  ·  Requires: Datastore & Purchase System

Your AI creates a code and Play redeems it.
Redeeming a code in Play.
Codes, rewards and expiry dates in the plugin.
Codes, rewards and expiry dates in the plugin.

In 3.0 the options 2.x kept in this pack's Settings folder live in your game's configuration modules, Config.CodesSystem in ReplicatedStorage and in ServerScriptService. The plugin's panel shown on this page edits them, and your AI lists every option with T.config.reference("CodesSystem").

What It Does

Codes System lets you hand out redeemable codes for a launch, a milestone, a video or a Discord drop, and lets players claim them from a menu. You write the codes in the plugin (or your AI writes them in Config.CodesSystem); each player can redeem each one once.

  • Any number of codes, each granting Cash, Diamonds, any other saved Stat, Spins for the Roulette wheel, or a Custom reward you write yourself.
  • Case and the spaces around a code do not matter. welcome2027, WELCOME2027 and  Welcome2027  are the same code, so a player who pastes one with a trailing space still gets their reward. The box upper-cases as they type, so what they see is what will be matched.
  • An optional expiry per code, to the day.
  • One redemption per player, remembered in their save.
  • Guessing is throttled on the server: one try a second, and after five wrong codes in a row a wait that starts at 5 seconds and doubles up to a minute. A code that works resets the count, and an empty box never counts against anyone.
  • Every word the panel can say is a setting you edit, so the pack speaks your game's language.

Codes are authored in the plugin, not fetched from anywhere. A new code means opening the place in Studio, adding it, and republishing. In exchange there is nothing to host, nothing to authorise, and no second place to look when something is wrong.

Plugin Configuration

The code list

The Codes list in the plugin

One row per code: the code itself, what it grants, and a dot saying whether it is live, expired or refused. Add code and Delete code live here too, so the list grows and shrinks without touching the Explorer, and both are ordinary Ctrl+Z.

One code, open

A single code expanded, showing its fields
FieldWhat it does
CodeWhat the player types. Write it however you want it read; matching ignores case and surrounding spaces.
TypeCash, Diamonds, Spins, Stat or Custom.
TargetOnly for Stat (a data path such as Stats.Wins) or Custom, where the plugin lists your reward modules as a dropdown.
AmountHow much is granted. A negative amount takes away, never below 0. For Custom, the number passed to your module's Grant (GrantPet: how many pets).
ExpiresYYYY-MM-DD in UTC, or empty for a code that never expires. The plugin gives you a calendar for it.

Reward types

The five reward types in the dropdown

Spins only does anything with Roulette System installed, and Custom lists your modules in Extensions > CodesSystem and the pack's own CustomRewards. Neither is a declared dependency. Without Roulette System a Spins code warns in the Output when it is redeemed, answers GrantFailed and is not used up. Without Easy Pet System a GrantPet code is switched off at startup with a warning and answers CodeDisabled.

Expiry

Picking an expiry date from the calendar

Expires is the day the code stops working, not its last day. 2026-09-01 means it dies at 00:00 UTC on the 1st, so 31 August is the last day anyone can redeem it. The plugin prints that last day under the field, so you never have to hold the rule in your head.

If you want a code to stop working on a date, set Expires rather than deleting it. The code stays visible in your configuration and its history stays intact.

The codes that ship

SlotCodeGrants
1WELCOME2027500 Cash, expires 2027-12-31
2PETDAY20271 pet, through GrantPet. Only when Easy Pet System was installed before Codes System; otherwise the install leaves it out.

They are examples, and they ship live: the plugin and your AI flag them until you change or delete them, so do that before you publish. A game moved from 2.x never gets them. Installing from the plugin writes them into Config.CodesSystem in ServerScriptService. When your AI installs with T.install, that module comes back as an edit it still has to apply, and until it does the game has no codes.

What the panel says

The Messages section in the plugin

Messages, in Config.CodesSystem in ReplicatedStorage, holds every word a player can be told, one field per outcome.

FieldDefault
RedeemedRedeemed {code}!
EmptyType a code first!
NoSuchCodeThat code doesn't exist.
AlreadyRedeemedYou've already used that code.
ExpiredThat code has expired.
CodeDisabledThat code isn't available.
TooFastSlow down a moment, then try again.
NoDataYour data is still loading. Try again.
GrantFailedSomething went wrong. Try again.

Redeemed may contain {code}, which is replaced with the code that was redeemed. A message you leave out of the module keeps its default rather than saying nothing, so you only set the ones you change.

Uninstalling

The pack's More menu in the plugin: Where its files are and Uninstall

Choose Uninstall in the More menu of the pack's page. It removes the pack from every service it was installed into. Your Config.CodesSystem modules stay, so installing it again picks your codes back up.


That's everything from the plugin.

If you are not planning to write custom rewards or call the pack from your own code, you can stop here.

What it saves

One key, created on join if it is not there:

data.Codes = {
    Redeemed = { WELCOME2027 = true, PETDAY2027 = true },
}

A set of the codes this player has used, keyed in upper case. Renaming a code in your configuration lets everyone redeem it again, which is correct: it is a different code.

Custom Rewards

Drop a ModuleScript into ServerScriptService > RBLXEssentials > Extensions > CodesSystem, which updates never touch. It returns a table with a Grant function:

local MyReward = {}

-- `d` is the live player-data table inside a datastore update:
-- changes persist and replicate on their own. `amount` is the
-- code's Amount field.
function MyReward.Grant(player, d, amount)
    d.Stats = d.Stats or {}
    d.Stats.Diamonds = (d.Stats.Diamonds or 0) + amount
end

return MyReward

Set the code's Type to Custom and pick your module from the Module dropdown, which lists whatever is in that folder. A module may also have a Prepare function, which runs when the server starts: if it errors or returns false, every code that names the module is switched off and answers CodeDisabled.

A custom reward module selected in the plugin

A GrantPet example ships in the pack's own CustomRewards and needs Easy Pet System. It grants a pet of the tier named in PET_RARITY (Legendary as shipped) rather than one hardcoded pet, so the reward keeps matching its label after you edit your pet list. Set PET_ID instead to pin one exact pet.

The menu

The pack ships its own Codes menu and HUD button. To restyle them, make your own copy (the pencil in the plugin's Interface tab, or ask your AI): it lives in StarterGui > RBLXEssentials > Interface, where updates never touch it, and the pack drives it instead.

Inside the panel, the pack drives these by name:

PartPurpose
Container/Code/TextBoxWhere the player types. Upper-cased on every keystroke, with the caret left where it was.
Container/ButtonRedeem.
Container/ErrorTextRefusals.
Container/SuccessTextConfirmations.

Your copy needs Container/Code/TextBox and Container/Button to replace the pack's own. The two labels are optional: without them it keeps redeeming silently. Everything else in the panel is yours to restyle.

API

Another pack reaches this one through the kernel, after declaring it in its own manifest.deps:

local codes = ctx.require("CodesSystem")

-- ok, reason | { Code, Type, Amount }
codes.redeem(player, "WELCOME2027")

-- boolean; case does not matter here either
codes.hasRedeemed(player, "welcome2027")

Refusals come back as machine reasons, never as sentences: Empty, NoSuchCode, AlreadyRedeemed, Expired, CodeDisabled, TooFast, NoData, GrantFailed. The caller decides the wording.

Remotes

Created on demand under ReplicatedStorage > RBLXEssentials > Kernel > Remotes > CodesSystem.

RemoteTypeDescription
RedeemRemoteFunctionRedeems the given text. Returns { Success = true, Code, Type, Amount } or { Success = false, Error }.

Every redemption is validated server-side against the same rules the panel shows. The client is never trusted, and the throttle lives on the server rather than in the button.

Changelog

What changed in each release. Current version: 3.5.8

How to update: put the new plugin in your Plugins folder, restart Studio and update the packs from the card; your settings stay.

Version 3.5.8 Current release

Every gain flies

Only Notifications System changes: the plugin stays 3.5.6. Update it from the card.

  • Notifications System 3.3.3: every "+amount" card flies to its counter by default. Before, gains less than 2 seconds apart were grouped as passive income and only the first one flew, so a cash pad pressed once a second showed its "+500" only after a pause. CounterFlyout.GroupSeconds = 2 brings the grouping back.

Version 3.5.7

Pack fixes

Only packs change: the plugin stays 3.5.6. Update these three from the card.

  • Roulette System 3.3.4: the spin packs' prices keep the Robux icon in every GUI kit, as in the Shop. Since 3.3.3 the real price replaced the whole label and dropped it.
  • Leaderboards System 3.2.1: the global boards show a player's new value at the next refresh. Before, a player's stats were saved to the boards only on join, on leave and every five minutes, so a board could show the old value for up to five minutes.
  • Studded Glass UI Kit 3.5.4: the countdowns under the Spin and Rewards HUD buttons draw over the row below instead of behind it.

Version 3.5.6

Plugin update notice

  • The plugin tells you when a newer plugin is out: a pink button next to Minimize on the card, with the download link to copy. Before, only the old panel of 2.x games said so.

Version 3.5.5

Studded Glass UI Kit, a new GUI kit

  • Studded Glass UI Kit, new and sold apart: the same 17 menus and HUD with studded colour pieces over dark glass, in four styles. It needs no other kit.
  • Its menus slide up to open and down to close; buttons grow and darken on hover.
  • The plugin, Tools and the Kernel 3.5.3: the Style tab shows the new kit's four styles.

Version 3.5.4

Fixes

  • Easy Pet System: the egg boards work with a gamepad (X, Y and RB) and on phones, with round buttons next to the jump button.
  • General UI Kit and Classic UI Kit: a menu that opens by itself when you join, like Daily Rewards, no longer closes at once.
  • The plugin: Diagnostics explains example ids and the Shop's example offers in plain words.
  • The plugin tells us which published game a pack is installed in, so we know where packs are used.

Version 3.5.3

Fixes

  • Notifications System: income every second no longer floods the screen with "+5"; codes and spins still fly to the counter. The new CounterFlyout option tunes it.
  • Easy Pet System: with no pass id, the egg boards hide "Open x3" and "Auto", and R and T do nothing.
  • Easy Pet System: its own Shop uses your pass ids from the settings.

Version 3.5.2

Fixes

  • General UI Kit and Classic UI Kit: the Shop's example offers say "Not for sale" until you sell them.
  • Before publishing, your AI warns you about example ids that would sell another game's items.
  • AI guide: your AI can add its own HUD counter, like Diamonds.
  • AI guide: your AI asks before installing a second GUI kit.
Older versions

Version 3.5.1

  • Sound System: the music goes on to the next song when one ends.
  • Roulette System shows your products' real prices; Diamonds rewards land and show.
  • Classic UI Kit: notifications' second line is readable, and its cover shows on the card.

Version 3.5.0

  • Classic UI Kit, new: the same menus and HUD with a chunky stud look, in four styles.
  • The pet Index is its own menu; the plugin and the docs speak Spanish too.

Version 3.4.0

  • A gift button on Shop and Spin tiles buys an item for another player.
  • Gifts arrive even if the player left; passes you own show OWNED.

Version 3.3.2

  • With General UI Kit, the packs use the kit's own menus, so Studded reaches them all.
  • A Style tab on the card sets one style for the whole game.

Version 3.3.1

  • One RBLX Essentials toolbar button; Pack manager moved to the card's Settings tab.
  • Your AI sees which packs you own and can install them all.

Version 3.3.0

  • General UI Kit comes in two finishes, Plain or Studded, switched in one click.
  • The free Studded UI is now a design-only ZIP for your own menus.

Version 3.2.2

  • General UI Kit and Roulette System: themes can lay out menus their own way.

Version 3.2.1

  • Sound System: the music always starts on its own.

Version 3.2.0

  • Updates respect your edits: deleted pieces stay deleted and edited scripts are kept.
  • Buy buttons without an id show "Not for sale".
  • Easy Leaderstats System is now called Leaderboards System.

Version 3.1.4

  • An AI tab on the plugin card with the guide and prompt for your AI.

Version 3.1.3

  • Easy Pet System: a Robux egg without a product says it isn't for sale.

Version 3.1.2

  • Sound System installs from the plugin, and your library lists every free product.

Version 3.1.1

  • Easy Pet System: the demo Add Cash pad only works in Studio.

Version 3.1.0

  • Sign in once and install any pack from the plugin card.
  • Notifications System: new Toy and Sleek designs. Easy Pet System: 28 new pets.

Version 3.0.3

  • Time Rewards System: a fallback reward when the pack a reward needs is missing.
  • Studded UI 3.0.1: menu buttons show in their own spots in Studio.

Version 3.0.2

  • The free Studded UI theme for General UI Kit.

Version 3.0.1

  • General UI Kit ships all 14 menus again; a pack's menu replaces the kit's demo.

Version 3.0.0 Free update for 2.x owners

The 3.0 plugin's Home right after Move to 3.0, as it looked in 3.0.0 (the plugin has changed since).
The 3.0 plugin's Home right after Move to 3.0, as it looked in 3.0.0 (the plugin has changed since).
  • Tools for AI agents: your AI installs, configures and checks the packs through Studio.
  • Move to 3.0: a guided check-and-approve flow, with a backup first.
  • FreeMode only works in Studio. On 2.x, turn it off in Datastore & Purchase.
  • Codes System is free; Roulette System takes 2 to 12 slots.

Versions 2.x and 1.x

  • 2.1.1: menus and HUD buttons no longer disappear after a respawn.
  • 2.1.0: Studded UI templates, more sounds, safer saves and pet egg inventory.
  • 2.0.0: the plugin installs self-contained packs; Roulette, Time Rewards, Codes and Notifications arrive.
  • 1.x: the first plugin and packs.