Services

What a Service Is

A service is a container that exists once in every Space. On disk it is a folder at the top of the Space holding a _service.toml file; in Studio it is a top-level row in the Explorer. Everything you make lives inside one: parts in Workspace, materials in MaterialService, scripts in SoulService.

When a Space opens, Eustress treats every top-level folder that holds a _service.toml as a service. Sixteen standard services load even when their folder is missing: Workspace, Lighting, Players, StarterGui, StarterPack, StarterPlayer, ReplicatedStorage, ServerStorage, ServerScriptService, SoulService, MaterialService, SoundService, AdornmentService, DataService, Teams and Chat.

Services stay put

Delete skips any service in the selection, and Cut refuses one with a warning. Removing a service would orphan everything inside it.

Every Service

The Explorer lists the standard services in a fixed order, then any other service folders by name. Some rows open to show their contents; the rest are listed as a single row for now.

A Space created in Studio also gets Website and ExperimentService, plus StarterPlayerScripts and StarterCharacterScripts folders that the Explorer does not list yet. A service shown as a single row still loads the objects in its folder; the Explorer just does not show them under it.

Large Spaces open lean

In a Space with more than 100,000 stored instances, only Workspace, Lighting and StarterGui load their contents when the Space opens. The other services open empty, which keeps a large import responsive.

Folder and Service File

Each service is a folder named after it, with a _service.toml inside. The file's [service] table names the class and holds the service's values; [metadata] records an id and when the file was created and last changed. This is a Lighting file after its time of day was set in Studio:

[service]
class_name = "Lighting"
icon = "lighting"
description = "Controls global lighting, shadows, and atmospheric effects"
can_have_children = true
clock_time = 18.5
time_of_day = "18:30:00"

[metadata]
id = "lighting-service"
created = "2026-09-22T09:14:03.512004+00:00"
last_modified = "2026-09-22T09:20:41.087311+00:00"

When you are signed in, each save also appends your name, public key and the time to [[metadata.modifications]], and the first signed save sets [metadata.created_by], so the file carries its own edit history.

Property Values

Values sit directly under [service]. The loader accepts six shapes and skips anything else:

Properties shows a four-number color on a 0 to 255 scale, with the alpha as a decimal.

A [properties] table is skipped

The service templates a new Space starts from keep their starting values in a separate [properties] table. The loader reads plain values and skips tables, so that table never reaches the service, and the first save from Studio rewrites the file without it. Until a value is saved under [service], the engine runs that setting on its own built-in value, while Properties shows the row's listed default.

The Properties Panel

Select a service's row in the Explorer to see it in Properties. Eight services ship with a row layout: Workspace, Lighting, Chat, StarterPlayer, SoulService, ServerStorage, ExperimentService and Website. The layout names each row, its type, its description and a default, and the panel fills in the service's current value wherever one is set. Other services list their class, description and file path, and whatever values their file holds.

An edit writes the new value into the service and saves the whole file back. Studio keeps an edit only for a value the file already holds under [service]; Lighting's ClockTime and TimeOfDay are the exception and are always kept. Lighting's time, latitude, brightness, fog distances and exposure also change the scene the moment you edit them, saved or not.

Your Own Services

Any top-level folder with a _service.toml becomes a service when the Space opens, with no code. Studio lists it after the standard services, shows the objects inside it, and lists its values in Properties, where you can edit them.

[service]
class_name = "Tuning"
icon = "folder"
description = "Constants the Space's scripts read"
can_have_children = true
enabled = true
max_connections = 100
timeout_seconds = 30.0
spawn_offset = [0.0, 5.0, 0.0]
highlight_color = [1.0, 0.5, 0.0, 1.0]

[metadata]
id = "tuning-service"

Properties shows these as Enabled, HighlightColor, MaxConnections, SpawnOffset and TimeoutSeconds, sorted by name, followed by the file's path.

A class_name that differs from the folder name

Studio finds the service behind an Explorer row by the row's name, which is the folder name. If class_name does not match it, the row still appears, but Properties shows none of the service's values.

Workspace

Workspace is the 3D world. Every part, model and mesh in the viewport lives in it, stored as a folder with an _instance.toml, as a .part.toml, .model.toml, .glb.toml or .instance.toml file, or as a .glb or .gltf model. Billboard UI attached to parts loads here too. The Explorer lists the Camera first, then everything else by name.

When render_distance is saved in the file, editing RenderDistance re-applies the distance to every part at once. The other Workspace rows (FallenPartsDestroyHeight, GlobalWind, AmbientColor, OutdoorAmbient, Brightness, the three ColorCorrection values, SignalBehavior, TouchesUseCollisionGroups and AllowThirdPartySales) are stored in the file and not applied yet. Gravity and bodies are covered in Physics.

Lighting

Lighting holds the sun, sky and overall light of the Space. A Space created in Studio starts with four objects in its Lighting folder, each an .instance.toml file: Sun (class Star), Moon, Sky and Atmosphere. The engine gives the Sun and Moon directional lights, places them from the time of day and latitude, and drives the physically based sky from the Atmosphere. Placing lights of your own is covered in Building.

Sun

Class Star. The main directional light, with cascaded shadows.

Moon

A dimmer directional light, placed from the same time of day and latitude.

Sky

The sky object. Its file holds the sky mode, star count and sky colors.

Atmosphere

Scattering settings for the physically based sky.

Stop in Play mode puts Lighting back exactly as it was when you pressed Play.

Lighting Properties

What applies at once

ClockTime, TimeOfDay, GeographicLatitude, Brightness, FogStart, FogEnd and ExposureCompensation change the scene as you edit them. The others in the table apply from the value saved under [service], when the Space loads or that value changes. GlobalShadows, ShadowSoftness, ColorShift_Top, ColorShift_Bottom and Technology are stored but not applied yet.

MaterialService

MaterialService holds the material definitions parts use: one .mat.toml file per material in the Space's MaterialService folder, loaded into a MaterialRegistry of named materials. A definition sets PBR factors and optional texture maps (base color, normal, metallic-roughness, occlusion, emissive, depth). Texture paths resolve against the Space first, then the engine's bundled library, and every map is mipmapped as it loads. The bundled library repeats every 4 m with no visible seam.

[material]
name = "CustomBrick"
preset = "Brick"

# Factors multiply the maps.
[pbr]
base_color = [1.0, 1.0, 1.0, 1.0]
roughness = 1.0
metallic = 0.0

# metallic_roughness is packed glTF-style:
# R = occlusion, G = roughness, B = metallic.
[textures]
base_color = "textures/brick_base_color.png"
normal = "textures/brick_normal.png"
metallic_roughness = "textures/brick_orm.png"
occlusion = "textures/brick_orm.png"

A part uses a material through its Material property, by name. Materials and textures in depth are covered in Building.

SoundService

SoundService is where audio belongs. The Insert menu's Audio group puts a new Sound here when nothing is selected, and the Space loader recognizes audio files (.ogg, .mp3, .wav, .flac) in this folder only. Eustress Engine does not play audio yet; Audio covers what is stored today and what comes next.

Its template lists AmbientReverb (NoReverb), DistanceFactor (3.33), DopplerScale (1), RolloffScale (1), VolumeScale (0.5) and RespectFilteringEnabled (false). No system reads these values yet.

Data, Experiments, Adornments

• DataService holds Data Platform objects: Dataset, Series, Column, Run and Connector. Connect on the Data tab creates a REST Connector here, with its endpoint, poll interval in seconds and format to fill in through Properties. A new Connector starts switched off. Once enabled, a Connector whose source is SAM.gov or Grants.gov polls it on its interval, never more often than every 60 seconds; other source types are not polled yet.
• ExperimentService is the place for designs, the parts they are made of, the laws wiring those parts, and every run over them. Its Properties rows (Designs, Runs, Envelopes, Conflicts, FreeParameters, Unfalsifiable) are read-only counts that nothing computes yet.
• AdornmentService holds beams, billboards, particles and highlights. Instance files placed loose in its folder load as objects.

Website

Website holds the values a website reads. Publishing bakes them into a single manifest at universes/{id}/website-manifest.json for a site to fetch. Its Properties panel carries the manifest's Namespace and SchemaVersion and the rows for its access key. The whole workflow is in Website Service.

Players and Starters

• StarterGui holds the Space's ScreenGuis. It loads as a full-window UI root layered above the 3D view; how and when its ScreenGuis draw is covered in UI Systems.
• StarterPlayer lists default character and camera settings in Properties, such as CharacterWalkSpeed (16), CharacterJumpHeight (7.2), CameraMode (Classic) and CameraMaxZoomDistance (128). The Play character does not read them yet.
• Players is a runtime-only service: it has no contents while you edit, and the Explorer shows it as a single row.
• StarterPack and Teams are containers, for the tools every player starts with and for Team objects.
• Chat lists BubbleChatEnabled, LoadDefaultChat and FilteringEnabled in Properties, all on. No system reads them yet.

Storage Services

ReplicatedStorage and ServerStorage hold folders and objects that are not part of the 3D world. Their names follow the Roblox convention: shared with every client, or kept on the server. Eustress has no network transport yet, so nothing replicates; both behave as plain containers, and Luau scripts ported from Roblox still find them through game:GetService. See Networking.

Script Services

SoulService is the home for scripts. The Insert menu's Scripting group puts new scripts here when nothing is selected, the Workshop saves its sessions in SoulService/Workshop, and AI requests are logged in SoulService/Logs.

Script files (.rune, .soul, .md, .lua, .luau) load as script objects in any service folder, ServerScriptService included; Scripting covers how they run. The SoulService panel's EnableAI, SandboxEnabled, AllowFileSystemAccess and AllowNetworkAccess rows are not read by any system yet.

From Luau

In Luau, game:GetService(name) returns the table registered under that name: Players, ReplicatedStorage, ServerStorage, ServerScriptService, StarterGui, StarterPlayer, StarterPack, Lighting or CollectionService. Workspace is the workspace global. Any other name raises Service 'Name' not found; RunService, TweenService, UserInputService, HttpService, DataStoreService, SoundService, MarketplaceService and SimulationService are globals instead.

local Players = game:GetService("Players")
local Lighting = game:GetService("Lighting")

print(Players.LocalPlayer.Name)  -- LocalPlayer
print(Lighting.ClockTime)        -- 14
print(workspace.Gravity)         -- 9.80665

-- SoundService is a global, not a member of game.
local ok = pcall(function()
    return game:GetService("SoundService")
end)
print(ok)                        -- false

These tables stand in for the services today. Lighting carries fixed starting values (ClockTime 14, Brightness 2), and assigning to them does not change the scene.

From Rune

Rune has no service objects. A service's features are functions in the eustress module, named after the service: tween_service_create, datastore_service_get, run_service_is_studio, collection_add_tag, workspace_raycast and workspace_get_gravity. A script file imports each one by name:

use eustress::log_info;
use eustress::run_service_is_studio;

pub fn on_init() {
    if run_service_is_studio() {
        log_info("Running in Eustress Engine");
    }
}

The command bar adds use eustress::*; to a one-line snippet for you; a script file declares its imports. Which of these functions act on the live world is covered in Scripting.

Every Row Applied

The rows that are stored today will reach the systems they name: shadows and color shift for Lighting, fallen-part cleanup and wind for Workspace, character and camera defaults for StarterPlayer, and the audio settings on SoundService. New Spaces will start with their values under [service], so the value a row shows is the value that runs.

Live Services

The Luau service tables will become live views of the Space's services, the Explorer will open every service to show its contents, and Players will fill with real players once networking lands.