Building and testing a Stake Engine front end

The short version. The front end is a static website that plays the rounds Engine's server picks. Engine's open-source web SDK (Svelte 5, PixiJS 8, Turborepo) gives you sample games, Storybook for rendering any round offline, and the RGS calls. Build it as a static site, upload the build folder in Studio, publish a front-end version, and test it with Play Game or a redirect to your local dev server. Bet replay is mandatory.

Your stack: the web SDK or your own

You don't have to use the web SDK. Its own FAQ says you can use anything "as long as it compiles to a static website", and Engine requires a non-empty index.html at the root of what you upload. The SDK is a good starting point because it already handles the RGS, bet levels, social-mode wording and replay. It uses SvelteKit, PixiJS, XState and TypeScript, and specifies Node 22.16.0 and pnpm 10.5.0. Its sample games cover lines, ways, scatter and cluster.

1. Render rounds without a server: Storybook

After pnpm install, run Storybook for a sample game (for example pnpm run storybook --filter=lines). It has stories for the whole game, single components, a random book per mode and single book events. That last one is the heart of front-end work: the SDK's README says that if each book event is implemented well, the game is technically finished. Because rounds are just data, you can render a big win or the win cap on demand here.

2. Run against the RGS

pnpm run dev --filter=lines starts a dev server, which shows an error until it's connected to the RGS. In Studio, Local Testing → Redirect URL sends a real session to your dev server (for example http://localhost:3001) with the same launch parameters, so you can test bets, balances and currencies while you edit.

3. Build and upload

1. Build: pnpm run build --filter=lines. Engine's current docs say the apps use SvelteKit's static adapter and write to apps/<game>/build (an older README describes assembling the output by hand; follow the docs).
2. In Studio, open the game's Files page → Import files → Front end, and pick the build folder. Engine asks for a Chromium browser here.
3. Publish new version → Front end. Math and front end publish separately, and each publish freezes the files into a new version.
4. Use relative asset URLs, and load every image and font from the build itself: Engine serves games with a strict content policy and no external sources.

4. What the launch URL gives you

Engine launches a game at https://{team}.live.engine.io/{game}/v{version}/ with query parameters including sessionID, rgs_url, lang, currency, device, social and demo. Read them; never hard-code the RGS address or bet levels. Reviewers deliberately launch with an invalid rgs_url and expect an error.

5. Bet replay (mandatory)

"Bet Replay is now a mandatory requirement for all games seeking approval." In replay mode (replay=true plus game, version, mode and event in the URL) the game loads a past round without a session, makes no authenticated calls, shows a Play button and then Play Again, hides the bet controls and shows the real cost. It must work in the small popout player too. The current web SDK has replay built in. When you submit, reviewers may ask for round IDs per mode for a normal win, a big win, the win cap, a loss and a bonus trigger, so note them as you test.

6. Run Engine's AI review before you submit

Engine publishes a review prompt to run with a coding agent against your project. It reports PASS, FAIL, AT RISK, NEEDS A HUMAN or N/A per guideline. "A clean report is not an approval," but it catches the common misses before a reviewer does.

The details reviewers check most

• Unique art and sound, with no web-SDK sample assets and no Stake Engine logo or loader.
• Works on mobile and in the mini-player (Popout S and L), with no scrolling and double-tap zoom disabled.
• Space bar spins; autoplay asks for confirmation; any mode costing more than 2× the base bet asks for confirmation.
• Bet size changeable through every level the RGS allows; balance shown; win counter counting up; a sound-off option.
• An active round restores its bet; /play isn't called without enough balance; end-round only for winning rounds.
• Sub-cent payouts shown precisely (new games should support bets down to $0.01).

The full list is in Stake Engine's requirements.

In Volt, Build plays your game at real screen sizes against its own math and lets you pick a specific round to watch, which is handy for collecting those replay round IDs.

Sources: Engine docs (front end getting started, RGS, game replay requirements, AI review, front-end and RGS communication guidelines) and the Stake Engine web SDK README. Checked October 22, 2026.