DataModel

This property describes the ID of the user or group that owns the place. If the DataModel.CreatorType property is User then CreatorId will be the Player.UserId of the place's owner. If the DataModel.CreatorType is Group then CreatorId will be the ID of the group that owns the place.

This property describes the CreatorType of the place, whether the place is owned by a user or a group. If User, then the DataModel.CreatorId property will describe the UserId of the account that owns the game. If Group, then it will describe the group ID.

This property describes the ID of the experience that the place running on the server belongs to.

See Also#

• DataModel.PlaceId, which describes the ID of the place running on the server
• DataModel.JobId, which is a unique identifier for the server game instance running
• TeleportService, which is a service that can be used to transport Players between games

This property, along with DataModel.Genre, no longer functions correctly and attempting to read it may throw an error.

This property is broken and should not be used.

This property historically described the Genre of the place as set on the Roblox website.

This property, along with DataModel.GearGenreSetting, no longer functions correctly due to genres existing on the Roblox website that are not reflected in the Genre enum. As a result, attempting to read this property may throw an error.

This property is a unique identifier for the running game server instance. It is a universally unique identifier (UUID), meaning that no two servers, past or present, will ever have the same ID.

Defaults to an empty string in Studio.

See Also#

• TeleportService:GetPlayerPlaceInstanceAsync() which can be used to retrieve the DataModel.JobId of a user's current server.
• TeleportService:TeleportToPlaceInstance() which can be used to teleport a Player to a specific server.
• DataModel.PrivateServerId describes the ID of the private server the game server instance belongs to.
• HttpService:GenerateGUID(), a function that can be used to generate your own UUIDs.

This property was once used to get the game's Lighting service.

This property represents how players in the server are handled by matchmaking. Players with different MatchmakingTypes cannot be in or teleport to the same server.

Note that this property is only valid on the server DataModel and it will be the MatchmakingType.Default value for all clients, so only reference this property inside of a server‑side Script.

This property describes the ID of the place running on the server.

If the place has not been published to Roblox, this ID will correspond with the template being used.

See Also#

• DataModel.GameId, which describes the ID of the experience that the current place belongs to
• DataModel.JobId, which is a unique identifier for the server game instance running
• TeleportService, which is a service that can be used to transport Players between places

This property describes the version of the place the server is running on.

This version number corresponds with the version number shown under the Version History section of the place's settings. It is not the current version of the Roblox client. This property is 0 for all unpublished experiences.

When a server instance is created for a place, it uses the place's current version. If the place is later updated while this server is running, the server will remain at its current version.

This property can be used to display a ScreenGui showing the current version of the game to Players to assist with debugging.

This property describes the private server ID of the server, if the server is a private server.

If the server is not a private server, then this property will be an empty string.

Private servers#

Private servers refer to the following:

• Private servers that users can purchase from the games page
• Reserved servers, private servers created by the developer using TeleportService:ReserveServerAsync()

PrivateServerId vs JobId#

The PrivateServerId of a server is different from the DataModel.JobId. The JobId is the unique identifier of the current server instance.

Private servers (private or reserved servers) can have multiple server instances associated with them over time. This is because, although only one server instance can be running at once for a private server, new server instances can open and close as players join and leave the game. For example, no server instance is running when nobody is playing in the server. The PrivateServerId will be consistent across all of these server instances, and the DataModel.JobId will be unique for each one.

See also:

• DataModel.PrivateServerOwnerId, a property describing the owner of a private server
• TeleportService:ReserveServerAsync(), a function which creates a reserved server

This property describes the UserId of the Player that owns the private server if the server is private.

If the server is a standard or reserved server then this property will be set to 0.

This property could be used to identify if a Player is the owner of the private server, for example:

local Players = game:GetService("Players")

-- is this a private server?
if game.PrivateServerId ~= "" and game.PrivateServerOwnerId ~= 0 then

    -- listen for new players being added
    Players.PlayerAdded:Connect(function(player)

        -- check if the player is the server owner
        if player.UserId == game.PrivateServerOwnerId then
            print("The private server owner has joined the game")
        end
    end)
end

See also:

• DataModel.PrivateServerId, a property describing the unique ID of private and reserved servers

A reference to the RunService service. Always points to RunService and is never nil. You can also retrieve it with GetService(), for example game:GetService("RunService").

This property was string that could identify the current server as a private server.

This property indicates the UserId of the account who owns the private server.

This property is a reference to the Workspace service. It always points to Workspace and will never be nil.

Binds a function to be called before the server shuts down. If the bound function accepts a parameter, it passes CloseReason specifying the reason for the server shutdown.

You can bind multiple functions by calling BindToClose() repeatedly. Bound functions are called in parallel and run at the same time.

The experience server waits 30 seconds for all bound functions to stop running before it shuts down. After 30 seconds, the server shuts down even if functions are still running. Teleports are disabled during moderation shutdowns.

To verify that the current session is not in Roblox Studio, use RunService:IsStudio(). This prevents bound functions from completing their run in offline testing sessions.

When you use DataStoreService, you should also use BindToClose to bind a function saving all unsaved data to DataStores. This prevents data loss if the server shuts down unexpectedly.

See also:

• CloseReason for reasons for the experience server shutdown.
• PluginGui:BindToClose(), which binds a function to a PluginGui close button.

Returns a table containing basic information about the jobs performed by the task scheduler.

In computing, a task scheduler is a system responsible for executing key tasks at the appropriate intervals.

You can also find live task scheduler statistics in the Task Scheduler window in Roblox Studio.

The first entry in the table returned is a reference dictionary containing the statistics (or headings) available. It is in the following format:

{
    ["name"] = "name",
    ["averageDutyCycle"] = "averageDutyCycle",
    ["averageStepsPerSecond"] = "averageStepsPerSecond",
    ["averageStepTime"] = "averageStepTime",
    ["averageError"] = "averageError",
    ["isRunning"] = "isRunning",
}

The subsequent entries in the table returned are dictionaries containing the above statistics for jobs performed by the task scheduler. For example:

{
    ["name"] = "Heartbeat",
    ["averageDutyCycle"] = 0,
    ["averageStepsPerSecond"] = 0,
    ["averageStepTime"] = 0,
    ["averageError"] = 0,
    ["isRunning"] = false,
}

See also:

• TaskScheduler

This function will always return a blank string. It was originally used to set the message displayed on screen while the game was loading.

This system was phased out a very long time ago, and recently the APIs for setting this message were removed.

This method returns an array of Instances associated with the given content URL. It can be used to insert content from the Roblox library. It's not possible to insert Sounds using this method as they do not have an Instance associated with them and have only a content URL.

Unlike InsertService:LoadAsset(), DataModel:GetObjects() does not require an asset to be "trusted," meaning that an asset doesn't need to be owned by the logged in user, or created by Roblox, to be inserted. However, if the asset is not owned by the logged in user it must be freely available.

Due to this function's security context it can only be used by plugins or the command bar. For an alternative that can be used in Scripts and LocalScripts, see InsertService:LoadAsset().

This method is no longer useful and will always return false. Use RunService:IsServer() to see if your code is running on the server.

Currently this function only returns the correct value on the client

This function returns whether gear of the given GearType is permitted to be added to Players' StarterGears. For example:

local meleeWeaponsAllowed = game:IsGearTypeAllowed(Enum.GearType.MeleeWeapons)

Whether gear of a specific GearType is permitted in the game is determined in a place's settings page under 'Permissions'. Note, all of a gear's associated GearTypes must be enabled for it to be permitted in a place.

When all initial Instances in the game have finished replicating to the client, this function returns true.

Unless they are parented to ReplicatedFirst, LocalScripts do not run until the game has loaded. The following snippet, run from a LocalScript in ReplicatedFirst yields until the game has loaded:

if not game:IsLoaded() then
    game.Loaded:Wait()
end

See also:

• Replication order for a more detailed summary of the loading process.
• DataModel.Loaded, an event that fires when the game has loaded
• Instance:WaitForChild(), a function which can be used to wait for an individual Instance to replicate without having to wait for the whole game to finish loading.

This function was used by an ancient data persistence method to save the current place.

Note:

• In order for this method to work the save place API has to be enabled for the current place.

This function sets the DataModel.PlaceId of the game instance to the given placeId.

This function sets the DataModel.GameId of the current game instance to the given universeId. This is useful when testing local .rbxl files that have not been published to Roblox.

To access the DataStoreService in an unpublished place, both DataModel:SetUniverseId() and DataModel:SetPlaceId() must be set.

This event fires when SetGearSettings is called with a different value for allowedGenres.

Fires when the user prompts an increase or decrease in graphics quality using the hotkeys.

This event fires under the following conditions:

• If the user presses F10, this event fires with a betterQuality argument of true.
• If the user presses ShiftF10, this event fires with a betterQuality argument of false.

This event does not provide the current graphics quality level or cover all updates to the graphics quality. For example, changes made in the core GUI escape menu are not registered.

You can retrieve a user's SavedQualitySetting using UserGameSettings with the following snippet:

UserSettings():GetService("UserGameSettings").SavedQualityLevel

If the user's graphics settings are set to automatic then the SavedQualitySetting will be Automatic. There is currently no way for developers to reliably get the current graphics quality level of a user's machine.

This event fires when a property of any object in the DataModel is changed.

This event fires on the client when all initial Instances in the game have finished replicating to the client.

Unless they are parented to ReplicatedFirst, LocalScripts do not run until the game has loaded. The following snippet, run from a LocalScript in ReplicatedFirst yields until the game has loaded:

if not game:IsLoaded() then
    game.Loaded:Wait()
end

See also:

• Replication order for a more detailed summary of the loading process.
• DataModel.Loaded, an event that fires when the game has loaded
• Instance:WaitForChild(), a function which can be used to wait for an individual Instance to replicate without having to wait for the whole game to finish loading.

Fires when the server has been scheduled to restart, for example when you restart servers from the Creator Hub or Open Cloud to release an experience update, or when Roblox needs to restart servers for infrastructure maintenance.

You can use this event to inform players on the server of the impending restart. You could then let them save their progress or teleport them to updated servers at the most convenient time for your game.

Invoked before the game is shut down. When this callback returns, or the timeout period is hit, the game finishes shutting down.