Getting Started

Step 1 — Install the Plugin

Download the RBLX Essentials Plugin from Itch.io and drag the .rbxm file into Studio. It installs automatically to your Plugins folder. Restart Studio once.

The plugin appears as RBLX Essentials in the Plugins toolbar.

Step 2 — Drag a Pack into Studio

1. Download any pack .rbxm from Itch.io.
2. Drag the file into your Studio Workspace — it lands there temporarily.
3. Open the plugin (Plugins → RBLX Essentials).

The plugin will detect the pack and show both Ecosystem Core and the pack in its list.

Note: Ecosystem Core is bundled inside every pack — you do not download it separately. It will always appear in the plugin list when you drag in any pack.

Step 3 — Install the Packs

Always install Ecosystem Core first, then the pack you dragged in.

1. Click Ecosystem Core in the pack list and click Move & Install.
2. Once done, select your pack and click Move & Install.

Repeat Step 2 and Step 3 for each additional pack. Follow this install order when combining packs:

1. Ecosystem Core — always first (bundled, install before anything else).
2. Datastore & Purchase System — no other dependencies.
3. Sound System — no other dependencies.
4. General UI Kit — requires Ecosystem Core (already installed). Sound System is optional.
5. Easy Pet System — requires Datastore & Purchase System. Sound System is optional.

Step 4 — Enable API Services

If you are using the Datastore & Purchase System, go to:

Game Settings → Security → Enable Studio Access to API Services

Without this, player data will not save in Studio playtests.

Step 5 — Configure

Select any installed pack in the plugin to open its settings panel. Change values directly in the panel — no script editing required.

Typical things to configure:

• Easy Pet System: egg prices, drop rates, pet multipliers, gamepass IDs.
• Datastore & Purchase System: auto-save interval, DataStore name.
• Sound System: which sounds are loaded.

Step 6 — Press Play

Hit Play in Studio. All packs initialise automatically. No bootstrap code, no wiring required.

Uninstalling a Pack

Select the pack in the plugin and click Uninstall Pack. The pack's deployed code is removed from all services. The pack template stays in ServerStorage so you can reinstall at any time.

Uninstalling Ecosystem Core does not clean up any packs that depend on it — remove dependent packs manually first.

Plugin

The plugin is the package manager for the RBLX Essentials ecosystem. It handles discovery, deployment, configuration, and removal of packs — entirely within Studio, without touching any project files manually.

How It Works

The plugin has three core systems:

Scanner reads ServerStorage.RBLXEssentials looking for _manifest folders. Each manifest identifies a pack (PackId, Version, DisplayName). This is how the plugin knows which packs are present in the project.

Verifier compares the pack's source in ServerStorage against the deployed code in the actual game services (StarterGui, ServerScriptService, ReplicatedStorage, etc.). This produces a status for each pack.

Installer copies pack code from ServerStorage into the target services on demand, and removes it on uninstall.

Pack Statuses

Registry and Update Checks

On each refresh the plugin fetches https://rblxessentials.com/registry.json, which lists all available packs and their latest versions. This powers two features:

1. Catalogue listing — packs not yet downloaded appear in a separate "More from RBLX Essentials" section so you can discover them.
2. Plugin update banner — if a newer version of the plugin itself is available, a banner appears at the top of the plugin UI.

The registry fetch is non-blocking: the plugin renders local packs immediately, then updates the list when the fetch completes.

Ecosystem Core Requirement

No pack can be installed unless Ecosystem Core is already deployed. The plugin enforces this by checking Verifier status for Ecosystem Core before allowing any install action. The install button shows "Install Ecosystem Core first" and is disabled until EC is deployed.

Settings Panel

Selecting an installed pack opens a settings panel on the right side of the plugin. The panel reads the pack's Settings folder from ServerStorage and renders each value as an editable field. Changes are applied directly to the ServerStorage instances and take effect on the next Play session.

Developer Bypass

For development workflows where Ecosystem Core is intentionally absent, middle-clicking the disabled install button bypasses the EC check and installs the pack directly.

PackId: EcosystemCore  ·  Version: 1.0.6  ·  Dependencies: None

What It Does

Ecosystem Core is the shared UI foundation for the RBLX Essentials ecosystem. It must be installed before any pack that uses the tag-based UI system.

It provides:

• A central GUI manager that discovers and controls all UI_Panel and UI_Button elements across your game.
• GUIBridge — a cross-pack handler registry that lets each pack register its own button actions without knowing about the others.
• Panel animations, image preloading, tooltip hover effects, and effect icon management, shared across all installed packs.

GUIBridge API

GUIBridge lives in ReplicatedStorage.RBLXEssentials.EcosystemCore. Require it from any LocalScript.

local GUIBridge = require(ReplicatedStorage.RBLXEssentials.EcosystemCore.GUIBridge)

GUIBridge.registerHandlers(handlers)

Registers a table of action handlers. Call this once per pack during initialisation.

GUIBridge.registerHandlers({
    OpenShop = function(button)
        -- open the shop panel
    end,
    BuyItem = function(button)
        -- handle purchase
    end,
})

If two packs register the same action name, the last registration wins.

GUIBridge.dispatch(action, button)

Calls the registered handler for action. Called automatically by the GUIManager for every UI_Button click — you do not need to call this manually.

GUIBridge.getPanel(panelId)

Returns the UI_Panel GuiObject with the given PanelId attribute, searching the local PlayerGui. Returns nil if not found.

local shopPanel = GUIBridge.getPanel("Shop")

Only call this inside a running LocalScript after the GUI has loaded.

Tag System

Ecosystem Core's GUIManager discovers elements by CollectionService tag. Apply tags in Studio via the Tag Editor or via script.

Built-in Button Actions

These actions are handled by the GUIManager itself and do not need a GUIBridge handler:

Notes

• Image preloading is batched (2 images per frame) to avoid frame hitches on startup.
• Sound playback degrades gracefully if Sound System is not installed.
• ScrollFrames inside panels automatically support mouse wheel scrolling.

PackId: DatastorePurchaseSystem  ·  Version: 1.0.5  ·  Dependencies: None

What It Does

The Datastore & Purchase System is the data and monetisation backbone of RBLX Essentials. It handles:

• Loading and saving player data automatically on join/leave.
• An in-memory cache so all reads mid-session are instant.
• Game pass ownership checks with caching.
• Developer product purchase callbacks with receipt history to prevent duplicate grants.
• Automatic retry with exponential backoff to handle Roblox DataStore throttling.

All other RBLX Essentials packs that need to persist data (e.g. Easy Pet System) read and write through this system. There is only one DataStore per game — no duplicate stores or conflicting keys.

DataStoreManager API

Require from any Script or ModuleScript in ServerScriptService.

local ManagerProvider = require(ServerScriptService.RBLXEssentials.DatastorePurchaseSystem.ManagerProvider)
local Manager = ManagerProvider.get()

Manager:Get(player)

Returns the player's complete data table. The first call loads from DataStore and caches the result; subsequent calls return the cache instantly.

local data = Manager:Get(player)
print(data.Stats.Cash)

Manager:Update(player, mutator)

Applies a mutation function to the player's data and queues a save. The mutator receives the data table directly.

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

PurchaseManager API

local PurchaseManager = require(ServerScriptService.RBLXEssentials.DatastorePurchaseSystem.PurchaseManager)

PurchaseManager.HasPass(player, passId)

Returns true if the player owns the game pass. Checks the cache first, then DataStore, then MarketplaceService. Returns true in FreeMode (for Studio testing).

if PurchaseManager.HasPass(player, 123456789) then
    -- grant perk
end

PurchaseManager.registerHandler(productId, callback)

Registers a handler for a developer product. The callback receives (player, receiptInfo) and must return true to confirm the purchase. Returning false or erroring will cause Roblox to retry the receipt.

PurchaseManager.registerHandler(987654321, function(player, receipt)
    Manager:Update(player, function(data)
        data.Stats.Cash += 1000
    end)
    return true
end)

PurchaseManager.InvalidatePass(player, passId)

Clears the cached ownership result for a pass, forcing a fresh check on the next HasPass call. Use this after a player purchases a pass mid-session.

PurchaseManager.GrantProduct(player, productId)

Directly invokes a registered product handler without a real purchase. Only works in FreeMode. Useful for testing reward flows in Studio.

Default Player Data Schema

{
    Meta = {
        SchemaVersion = 1
    },
    Stats = {
        Cash = 0
    },
    Pets = {
        Equipped = {},
        Owned    = {}
    },
    Purchases = {
        Gamepasses = {}
    }
}

Missing keys return their default values automatically. Additional keys can be added in the Settings module without any migration logic.

Configuration

Settings live in ServerStorage.RBLXEssentials.DatastorePurchaseSystem.Settings and are editable via the plugin.

PackId: EasyPetSystem  ·  Version: 1.0.14  ·  Dependencies: Datastore & Purchase Sound System (optional)

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 rarity rolls for egg hatching (single and triple hatch).
• Auto-hatch gamepass support.
• Pets follow and orbit the player with smooth animations.
• 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 hatching animations.

PetService API

Require from any Script or ModuleScript in ServerScriptService.

local PetService = require(ServerScriptService.RBLXEssentials.EasyPetSystem.PetSystem.PetService)

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

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

local result = PetService.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) — must match a key in the Eggs configuration.
• count (number) — 1 for single hatch, 3 for triple (requires 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".

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

PetService.EquipPet(player, uid)

Equips a pet by its unique ID. Players can have up to 3 pets equipped (4 with the ExtraPetSpace pass).

PetService.UnequipPet(player, uid)

Unequips a pet by its unique ID.

PetService.DeletePet(player, uid)

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

PetService.MergePets(player, petId)

Merges 3 non-equipped pets of the same type into one pet of the next rarity tier.

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

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

PetService.MergeAll(player)

Merges all eligible pet sets in a single call.

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

PetService.EquipBest(player)

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

PetService.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 = PetService.GetTotalMultiplier(player)

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

-- Apply to a reward
local reward = baseCash * PetService.GetTotalMultiplier(player)

Configuration

All configuration is data-driven. No code changes are needed to add pets, eggs, or rarities.

Key Settings

Gamepasses

Included Pets

28 pets across 5 rarities sourced from a Roblox asset pack. All pet models are fully replaceable — add, remove, or swap models at any time without code changes.

PackId: SoundSystem  ·  Version: 1.0.12  ·  Dependencies: None

What It Does

Sound System is a centralised audio playback system for Roblox. It provides clean client and server APIs for playing sound effects — from simple UI sounds to positional 3D audio at a world location.

It integrates with Roblox SoundGroup for volume control and respects a global SFX toggle, so players can mute sound effects independently of music.

Other RBLX Essentials packs (Easy Pet System, General UI Kit, Ecosystem Core) use Sound System for their audio feedback. It degrades gracefully if not installed — packs check for its presence before calling it.

Sound Storage

All sounds are stored as Sound instances under:

SoundService > RBLXEssentials > SoundSystem > SFX

Sounds are looked up by name. Add sounds to this folder in Studio to make them available to both APIs.

Client API

Require from any LocalScript.

local SFX = require(ReplicatedStorage.RBLXEssentials.SoundSystem.SFXSystem)

SFX:Play(name)

Plays a sound by name. If the sound is already playing, it restarts from the beginning.

SFX:Play("ButtonClick")

SFX:PlayOverlap(name)

Clones the sound and plays the clone. Multiple instances can overlap simultaneously. Each clone destroys itself when playback ends.

SFX:PlayOverlap("Coin")

Use PlayOverlap for sounds that can trigger rapidly (e.g. collecting coins, rapid button presses).

Server API

Require from any Script in ServerScriptService.

local SFX = require(ServerScriptService.RBLXEssentials.SoundSystem.SFXSystem)

SFX:PlayAt(name, position, range?)

Plays a sound for all clients at a world position. With a range, the sound has 3D rolloff (quieter with distance). Without a range, it plays globally at full volume for everyone.

-- Global sound (no rolloff)
SFX:PlayAt("Explosion", workspace.Part.Position)

-- 3D positional sound (audible within 40 studs)
SFX:PlayAt("Explosion", workspace.Part.Position, 40)

SFX:PlayAtForPlayer(player, name, position, range?)

Same as PlayAt but only plays for one specific player.

SFX:PlayAtForPlayer(player, "LevelUp", player.Character.HumanoidRootPart.Position)

Notes

• Positional sounds use RollOffMode.LinearSquare.
• An invisible Part is created at the position to host the sound and is destroyed when playback ends.
• The global SFX toggle (SFXEnabled BoolValue) is set by the Bootstrap script and affects all playback.

PackId: GeneralUIKit  ·  Version: 1.0.7  ·  Dependencies: Ecosystem Core Sound System (optional)

What It Does

General UI Kit is a tag-based UI framework for Roblox. UI behaviour is declared through CollectionService tags and Instance Attributes — no hardcoded paths, no script modifications needed to add new panels or buttons.

It provides:

• Panel management (open/close, exclusive mode, animated transitions).
• Universal button sounds and tooltip hover effects.
• Decorative UI animations (rotation, hover bob).
• Effect icon system with tooltip descriptions.
• TextBox typing sounds.
• Dispatch integration with Ecosystem Core's GUIBridge for cross-pack button handling.

How It Works

The GUIManager (a LocalScript) discovers all tagged elements in PlayerGui at runtime. Tags declare what an element is; Attributes declare how it behaves. You tag a Frame as UI_Panel and set PanelId = "Shop" — GUIManager handles the rest.

Button actions are dispatched through GUIBridge.dispatch(). To handle an action in your own code, call GUIBridge.registerHandlers() with a table of action functions.

Tag Reference

UI_Panel

A toggleable menu panel (Frame or ScreenGui).

UI_Button

A clickable button (TextButton or ImageButton) that dispatches an action.

UI_Animated

A decorative UI element with a looping animation.

UI_Tooltip

A Frame that appears on hover for an adjacent UI_Button or UI_EffectIcon.

UI_EffectIcon

An icon representing a buff or game effect, with an automatic tooltip.

UI_TypeSound

Apply to a TextBox to play a typing sound on each character input. No attributes required.

Registering Button Handlers

Call GUIBridge.registerHandlers from a LocalScript that runs after the GUI loads.

local GUIBridge = require(ReplicatedStorage.RBLXEssentials.EcosystemCore.GUIBridge)

GUIBridge.registerHandlers({
    OpenShop = function(button)
        GUIBridge.getPanel("Shop").Visible = true
    end,

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

Built-in Actions

These actions are handled by GUIManager directly. Do not register handlers for them.

Notes

• Sound playback (button clicks, hover effects) is skipped gracefully if Sound System is not installed.
• Tooltips are throttled at 16ms intervals to avoid layout thrashing.
• All GUIManager connections are cleaned up via Trove when the GUI is destroyed (respawn/reload safe).