Coming from Roblox

You already know how to make a game players like: you design it, build it, publish it and run its community. On Spawnite you keep the design and the community, and the building moves to your coding agent. You say what you want, play the result and say what is wrong, and the agent writes the game in TypeScript and checks its own work.

Roblox ideas and their names here

The following table puts each Roblox idea beside the closest thing on Spawnite and the page that covers it:

On Roblox	On Spawnite	Read
An experience	A game. It has an id that never changes, a name and an address, and the store lists it once it is public	Publishing
A place in an experience	A scene. A game registers its scenes and switches between them with useScenes().go(name). A room runs one scene	Scene
A server	A room: one running copy of the game that players join together, 20 players by default and 50 at most. The platform hosts it and runs your game’s own rules in it, so you write no separate server	Multiplayer
Luau	TypeScript, with React for what the game draws	Game
A Script, a LocalScript and a ModuleScript	A system, a function each step runs, runs in the room unless its runsOn says otherwise: RunContext.Client runs it on each client, and RunContext.Both on both. A view, a React component, draws on each client. Shared code is a module other files import	Where a system runs
A RemoteEvent and a RemoteFunction	The room streams the game’s traits and events to each client, and a game declares a command for what a player asks for, as the paragraph under this table says. Moves, walks, shots and item verbs need no command of the game’s own	Commands and what each client sees
Network ownership and Server Authority	The room runs every character, the player’s own included, and the player’s client predicts it so a key moves it at once. The room judges each instant shot itself, with the targets rewound by the shooter’s latency, and flies each projectile	Fair play, built in
A DataStore	A save. The game declares what it keeps in src/save.ts, and the engine and the platform write it. In a room game, every player’s save moves to the same moment or none does	Saving progress
The Workspace, its Instances and Parts	A scene’s entities. An entity holds traits, its state, and behaviours that act on it, and stands on the map as a model or a simple shape	Entity, Your own behaviour
A Humanoid	The character. <CharacterSpawn> spawns the player’s, which walks, runs and jumps, and Health gives an entity hit points	Player
A StarterCharacter	The look <CharacterSpawn> gives the character: a VRM character model in avatar, a GLB model in model or a simple shape in shape. The game picks the look	Player
Tools and the Backpack	Items in an inventory. The inventory() plugin gives the character a bag of 16 slots and equipment slots, and <Bag /> draws the bag on screen	Inventory
StarterGui and a ScreenGui	The HUD. A <Hud> holds Panels of the engine’s UI components, such as Text, Button and Bar	Hud
A MaterialVariant and post-processing effects	Any three.js material on a model, a <Shader> written in GLSL, and post-processing passes of the game’s own	Shader, Post-processing
Playtesting in Studio	Your agent runs a scene with no window, opens a playtest page in Chromium, and plays a room with bots. While you play as you build, the game keeps a replay, and F8 marks a moment for the agent to open	How your agent works on your game
Team Create and version history	A folder of files on your computer. It starts as a git repository, and your agent offers to push it to a repository of your own, such as one on GitHub. The platform keeps each version you publish	Where your game lives
Robux, passes, developer products and DevEx	Purchases in money, through the platform’s checkout. You keep 70 percent of net, and you are paid through PayPal once your payable balance reaches $200	Earning from your game
A private server	To play with just your friends, publish the game unlisted and share the link: only people with the link can join, and everyone with it plays in one room until it is full. In a public game, a private room, under this table, is the nearest thing	Play with friends in one room
Publishing, and moderation	spawnite publish makes a version live at an unlisted link, and spawnite visibility public puts the game on the store once it has a store page. Nobody reviews a game before it goes live, as the paragraphs under this table say	The states of a game
Free models in the Creator Store	The shared asset library, which spawnite add asset <id> adds from, and the templates: eight whole games to start from, and scaffolds for a behaviour, an entity, a scene and more	Assets, Templates

In place of a RemoteEvent, the room streams the traits a game defines to every client by default: a trait defined with ownerOnly reaches only the player whose character holds it, and one with serverOnly or local reaches no client. The room sends the events it emits beside the stream, to every client that holds the event’s entity, unless the event’s delivery keeps it on the room. In place of a RemoteFunction, a game declares a command for what a player asks for, such as “I am ready”. The room checks it, changes the world and answers with one result, accepted or refused with a reason, and the client sees the change there.

In a public game, a player opens a private room for the people they invite and shares its link. The room runs while two or more players are in it, and once it is empty it closes and its link stays.

Moderation works on what players see: the platform acts on players’ reports, and a word filter reads names and store pages.

How the work changes

On Roblox you build in Studio: you place parts, write scripts and test the place in Studio, and a coding agent can work in Studio too, through its MCP server, while Studio is open. Here your coding agent does the building from a terminal, with no editor open and no sign-in until you publish:

1. You say what you want, in your own words.
2. Your agent writes one piece, runs the game with no window to read what happened, and takes a screenshot to check the look.
3. You play it and say what is wrong. When something looks wrong as you play, you press F8, and the agent opens that moment to see what you saw.

How your agent works on your game shows each step with the commands your agent runs.

The editor runs inside your game while you build it. You sculpt and paint the ground, set the sea, scatter trees and rocks, click models and simple shapes onto the map, and move, turn and scale them with handles, and Save writes them to the map’s file. Your agent writes everything else, including characters, items, rules and UI. An inspector change to an entity lasts only once your agent writes it into the code. There is no UI or animation editor. The editor covers its tools.

What carries over

• Your sense of design: what makes a round fun, and how long a session should last.
• What you know about players: what they come back for and what they pay for.
• Level design. You lay out the ground in the editor and tell your agent where things go.
• Tuning: a jump’s height, a run’s speed, a price or a reward. You say the change, and your agent sets the number.
• Your community. The people who play your games open a link in a browser, on a computer or a phone, with nothing to install.

What does not carry over

• Luau code. A game here is TypeScript, so your agent writes a mechanic again rather than converting the script.
• Studio skills, past laying out a map. Your agent does the building.
• A place file. Spawnite does not open one, so a game starts from a template or from nothing.

When to stay on Roblox

Roblox’s players find games on Roblox, and Spawnite is new. If your audience plays on Roblox and finds your games there, weigh that first: a game here reaches players through the links you send and the store’s listing, and Spawnite promises no traffic. A game that needs more than 50 players in one shared space does not fit Spawnite, since a room here holds 50 at most.

When Spawnite fits

• An idea you want to try quickly. You reach players with a link: friends, a game jam, or your own followers. A 13+ game needs no account, and the game’s numbers, such as how many players came back the next day, start with its first player, as What you can see about your game says.
• A larger share of each sale. You keep 70 percent of net, paid in money, as Earning from your game says. A creator code pays people who send players a share from Spawnite’s part.
• TypeScript and an agent that tests its own work. The game is TypeScript and React, and your agent runs it with no window, reads what happened and checks its own work before it tells you a step is done.

Where your players come from says how a creator with an audience and one without each reach their first players.