Developer docs

Quick start

1. Make your game as a normal HTML5 game with an index.html.
2. (Recommended) Download the SDK below and add it to your game.
3. Put everything in one .zip file. index.html must be at the top level of the zip.
4. Open your dashboard, press + ADD NEW GAME, fill in the details, add your icon and zip, and press UPLOAD GAME.
5. Our team reviews it (up to 2 days). After approval we make it live on UNTILS.

The starter game already uses every SDK command. Upload it as a test game to see how publishing works.

Game package (the zip)

Device: mobile or desktop

When you upload, choose Mobile game if it plays well on phones and PC. Choose Desktop game if it needs a keyboard or mouse. Desktop games show "This game is for desktop (PC) only" on phones instead of a Play button.

Recommended game size (what the player sees)

Most important: make the game responsive. It must fill the window (window.innerWidth x window.innerHeight), keep its aspect ratio, and never need scrolling. Add this to your page:

<meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
<style>html,body{margin:0;height:100%;overflow:hidden;touch-action:manipulation}</style>

Unity, Cocos, Godot and other engines

Web (HTML5) exports from game engines work if the zip follows the same rules as above: index.html at the top, relative paths, under 50 MB.

Unity (WebGL)

1. File → Build Settings → WebGL → Build.
2. In Player Settings → Publishing Settings: Compression Format can be Brotli, Gzip or Disabled (UNTILS serves all three). We recommend Gzip with Decompression Fallback ON. Turn Data Caching OFF.
3. Zip the contents of the build folder (index.html, Build/, TemplateData/) so index.html is at the top of the zip.
4. Make the canvas fill the window so it works on phones and PC.

Cocos Creator (Web)

1. Project → Build → Platform Web Mobile → Build.
2. Zip the contents of the build folder, so index.html is at the top of the zip.

Godot

Game icon (logo) - required

What to put in it:

• One clear subject: your main character, object or logo mark, in the centre.
• Keep about 10% empty space around the edges. UNTILS rounds the corners itself, so do not round them.
• Bright, high-contrast colours and a solid background. It must look good very small (about 60 px).
• Little or no text. Tiny text becomes unreadable. A short game name in large letters is fine.
• No borders, no store badges, no "NEW" or "FREE" stickers, no blurry or stretched images.
• Only artwork you made or are allowed to use. No copied characters or logos.

The icon is shown on the game card, the Play screen, "More games" and the popular banner.

Demo

Popular banner - optional

If the UNTILS team marks your game as Popular, it appears in the big banner at the top of the home page. A banner is optional, but without one your game shows only its icon on a gradient.

How to upload: choose it in the Popular banner field when you add the game. You can also add or change it later: open your dashboard, click the game, pick a new banner, and press SAVE CHANGES.

Demo

Thumbnail - optional

The thumbnail is a wide picture that shows your game at a glance. UNTILS can use it on game cards and in lists, so players see the real look of your game together with its name.

Tip: keep the important art away from the edges, because the picture is cropped a little on small cards.

Demo

Screenshots - optional

What to show: real screenshots taken from your running game, exactly as the player sees it, with all the UI, text and buttons (menu, gameplay, a level, a win or upgrade screen). They must not be edited, redrawn or mocked up. No device frames, no added promo text, no screens from other games.

Screenshots appear at the very bottom of your game page. Click one to see it large. You can remove or add screenshots later from the dashboard.

Demo

Text logo - optional

The text logo is your game name drawn as a logo (a wordmark). UNTILS can show it on top of your popular banner and on your game page, so players see a clean title instead of plain text.

Demo

Gameplay video - optional

A short video that shows how your game plays. UNTILS can show it on your game page before the screenshots.

Demo

2D Art

Choose one 2D style and use it everywhere: characters, backgrounds, buttons and icons. A game that looks the same from screen to screen feels finished. Tap any example to see it bigger.

• Use PNG or WebP for art. Keep images only as big as they are shown, so your zip stays small (the limit is 50 MB).
• Keep buttons and important things big enough for a thumb on a phone.
• Make sure text and the player stay easy to see against the background.

3D Art Style

For 3D games, pick one style and keep every model, texture and light in the same style. Tap any example to see it bigger.

• Keep models light (fewer triangles) so the game runs smoothly on phones.
• Use small, compressed textures, and share one texture between many objects when you can.
• Go easy on real-time shadows and effects. Test on a mid-range phone, not only on a PC.

HTML SDK

HTML SDK (version 1.2.0) is one small file, untils.js, for HTML5 games. It gives your game progress saving, pause/resume, share links, language, fullscreen and event tracking. Ads and leaderboards are reserved and will work later without changing your code. It is optional, but recommended.

Import

1. Download untils.js.
2. Put it next to your index.html inside your game folder (and so inside the zip).
3. Add this in your page before your own game script:

<script src="untils.js"></script>

Using a local copy means your game also runs on your own PC without UNTILS. In that case the SDK switches to offline mode: saves go to your browser and ads are skipped, so nothing crashes.

Full flow

async function main() {
  await Untils.init();               // 1. always first

  Untils.loadingStart();             // 2. assets start loading
  await loadAssets();
  Untils.loadingFinished();          // 3. menu is ready

  let level = await Untils.load("level", 1);   // 4. read saved progress

  playBtn.onclick = () => {
    Untils.gameplayStart();          // 5. player starts playing
  };

  function onGameOver() {
    Untils.gameplayStop();           // 6. player died / opened menu
    Untils.save("level", level);     // 7. save progress
    Untils.showAd("interstitial");   // 8. ad between levels (not live yet)
  }

  rewardBtn.onclick = async () => {
    const watched = await Untils.showAd("rewarded");   // 9. watch ad for a reward
    if (watched) giveCoins();
  };

  Untils.onPause(() => pauseGame());     // tab hidden / app switched
  Untils.onResume(() => resumeGame());
}
main();

SDK commands

Unity SDK (beta, Unity 2020.1 to Unity 6, WebGL)

Pick the package for your Unity version from the list below, newest first (Unity 2019 and older are not supported, they use an older WebGL loader). Every package has everything you need: the C# SDK, the Untils WebGL template (it appears in Player Settings, like other platform SDK templates), UntilsPrefs (a save-safe replacement for PlayerPrefs), an editor menu and a sample script.

Install and build

1. Unzip the file into your Unity project folder (the one that contains Assets). Merge the Assets folder.
2. In Unity open the menu Untils → Apply recommended WebGL settings. This sets everything in the table below for you.
3. In your first script call Untils.Init(...) and use UntilsPrefs instead of PlayerPrefs (see the code below).
4. File → Build Settings → WebGL → Build.
5. Zip the contents of the build folder, so index.html is at the top of the zip, and upload it in your dashboard. UNTILS then opens the Inspector view to check your SDK.

The template makes your game fill the whole window (phones and PC), shows a loading bar, loads untils.js, starts the SDK, and tells UNTILS when loading starts and finishes. You do not need to call LoadingStart yourself.

Code

using UnityEngine;

public class GameManager : MonoBehaviour
{
    int level;

    void Start()
    {
        Untils.Init(ok =>
        {
            level = UntilsPrefs.GetInt("level", 1);    // saved progress
            StartGame();
        });
        Untils.OnPause  += () => Debug.Log("paused");   // optional
        Untils.OnResume += () => Debug.Log("resumed");
    }

    public void OnPlayPressed() { Untils.GameplayStart(); }

    public void OnGameOver()
    {
        Untils.GameplayStop();
        UntilsPrefs.SetInt("level", level);             // saved automatically
        Untils.CommercialBreak(() => ShowGameOverScreen());   // ads not live yet: continues at once
    }

    public void OnRewardButton()
    {
        Untils.RewardedBreak(rewarded => { if (rewarded) GiveCoins(); });
    }
}

Commands

If something goes wrong

• "untils.js is not loaded" in the browser console: the WebGL template is not set to Untils. Run the menu Untils → Apply recommended WebGL settings and build again.
• Progress is not saved: you used PlayerPrefs. Change it to UntilsPrefs. Unity's own save uses IndexedDB, which is blocked in the UNTILS sandbox.
• The game stays on the loading bar: open the browser console (F12). Check that the zip has index.html at the top and the Build folder next to it.
• Very large builds: keep the zip under 50 MB. Compress textures and audio.

This SDK is in beta. If you find a problem, please tell us through the contact page and include your Unity version.

Cocos SDK (beta, Cocos Creator 2.4 and 3.x, Web)

Pick the package for your Cocos Creator version. Both have the same commands. Each one has everything you need: the SDK script, UntilsPrefs (a save-safe replacement for the local storage), a sample script, and untils.js already placed in build-templates, so it is copied into your build for you.

Install and build

1. Unzip the file into your Cocos project folder (the one that contains assets). Merge the folders. You get assets/UntilsSDK and build-templates/web-mobile/untils.js.
2. In your first script call Untils.init() and use UntilsPrefs instead of the local storage (see the code below).
3. Project → Build → Platform: Web Mobile → Build. Web Mobile works on phones and PC. Set the build Orientation to match the Mobile screen option you choose in the dashboard.
4. Open the build folder and check that untils.js is next to index.html.
5. Zip the contents of the build folder, so index.html is at the top of the zip, and upload it in your dashboard. UNTILS then opens the Inspector view to check your SDK.

You do not need to call loadingStart / loadingFinished: the SDK sends them for you (set Untils.autoLoading = false to do it yourself). When the tab is hidden the SDK also pauses the game and sound, and resumes them when the player returns (set Untils.autoPause = false to handle it yourself).

Code

Cocos Creator 3.x (TypeScript)

import { _decorator, Component } from 'cc';
import { Untils, UntilsPrefs } from './UntilsSDK/Untils';
const { ccclass } = _decorator;

@ccclass('GameManager')
export class GameManager extends Component {
    level = 1;

    start() {
        Untils.onPause(() => console.log('paused'));      // optional
        Untils.onResume(() => console.log('resumed'));

        Untils.init().then(() => {
            this.level = UntilsPrefs.getInt('level', 1);    // saved progress
            this.startGame();
        });
    }

    onPlayPressed() { Untils.gameplayStart(); }

    onGameOver() {
        Untils.gameplayStop();
        UntilsPrefs.setInt('level', this.level);            // saved automatically
        Untils.commercialBreak().then(() => this.showGameOverScreen());   // ads not live yet: continues at once
    }

    onRewardButton() {
        Untils.rewardedBreak().then((rewarded) => { if (rewarded) this.giveCoins(); });
    }
}

Cocos Creator 2.4.x (JavaScript)

const { Untils, UntilsPrefs } = require("Untils");

cc.Class({
    extends: cc.Component,

    start: function () {
        var self = this;
        Untils.onPause(function () { cc.log("paused"); });     // optional
        Untils.onResume(function () { cc.log("resumed"); });

        Untils.init().then(function () {
            self.level = UntilsPrefs.getInt("level", 1);       // saved progress
            self.startGame();
        });
    },

    onPlayPressed: function () { Untils.gameplayStart(); },

    onGameOver: function () {
        Untils.gameplayStop();
        UntilsPrefs.setInt("level", this.level);               // saved automatically
        Untils.commercialBreak().then(function () { /* show game over screen */ });
    },

    onRewardButton: function () {
        Untils.rewardedBreak().then(function (rewarded) { if (rewarded) { /* give coins */ } });
    }
});

Commands

If something goes wrong

• "untils.js was not found" in the browser console: the file is not next to index.html in your build. Check that build-templates/web-mobile/untils.js exists in your project and build again.
• Progress is not saved: you used the engine's own local storage. Change it to UntilsPrefs. Browser storage is blocked in the UNTILS sandbox.
• The game stays on the loading screen: open the browser console (F12). Check that the zip has index.html at the top, with the assets and src (or cocos-js) folders next to it.
• Sound does not start: browsers only allow sound after the first tap or click. Start your music from a button press.
• Very large builds: keep the zip under 50 MB. Compress textures and audio.

This SDK is in beta. If you find a problem, please tell us through the contact page and include your Cocos Creator version.

Godot SDK (beta, Godot 3.x and 4.x, Web)

Pick the package for your Godot version. Both have the same commands. Each one is a Godot plugin: it adds the Untils Autoload for you, with saves (like PlayerPrefs), loading and gameplay events, pause handling, and a sample script. The web SDK is already inside it, so there is nothing else to copy.

Install and export

1. Unzip the file into your Godot project folder (the one that contains project.godot). Merge the folders. You get addons/untils_sdk.
2. Project → Project Settings → Plugins: tick Enable for UNTILS SDK. This adds the Autoload Untils. (You can also add addons/untils_sdk/Untils.gd yourself as an Autoload named Untils.)
3. In your first script call Untils.init() and use Untils.set_int / get_int ... instead of user:// files (see the code below).
4. Project → Export → Add... → Web (Godot 3: HTML5). Turn Thread Support off (Godot 3: Export Type Regular), because threads need special server headers. In Project Settings → Display → Window → Stretch use Mode canvas_items (Godot 3: 2d) and Aspect expand so the game fits phones and PC.
5. Click Export Project, name the file index.html, and export into an empty folder. Zip the contents of that folder, so index.html is at the top of the zip, and upload it in your dashboard. UNTILS then opens the Inspector view to check your SDK.

You do not need to call loading_start / loading_finished: the SDK sends them for you (set Untils.auto_loading = false to do it yourself). When the tab is hidden the SDK also pauses the game and sound, and resumes them when the player returns (set Untils.auto_pause = false to handle it yourself).

Code

Godot 4.x

extends Node

var level = 1

func _ready():
    Untils.paused.connect(func(): print("paused"))       # optional
    Untils.resumed.connect(func(): print("resumed"))

    var info = await Untils.init()
    level = Untils.get_int("level", 1)                   # saved progress
    start_game()

func on_play_pressed():
    Untils.gameplay_start()

func on_game_over():
    Untils.gameplay_stop()
    Untils.set_int("level", level)                       # saved automatically
    await Untils.commercial_break()                      # ads not live yet: continues at once
    show_game_over_screen()

func on_reward_button():
    var rewarded = await Untils.rewarded_break()
    if rewarded:
        give_coins()

Godot 3.x

extends Node

var level = 1

func _ready():
    Untils.connect("paused", self, "_on_paused")         # optional
    Untils.connect("resumed", self, "_on_resumed")

    var info = yield(Untils.init(), "completed")
    level = Untils.get_int("level", 1)                   # saved progress
    start_game()

func on_play_pressed():
    Untils.gameplay_start()

func on_game_over():
    Untils.gameplay_stop()
    Untils.set_int("level", level)                       # saved automatically
    yield(Untils.commercial_break(), "completed")        # ads not live yet: continues at once
    show_game_over_screen()

func on_reward_button():
    var rewarded = yield(Untils.rewarded_break(), "completed")
    if rewarded:
        give_coins()

Commands

If something goes wrong

• "Call Untils.init() first" warning: you used a save or event command before init() finished. Wait for await Untils.init() (Godot 3: yield(Untils.init(), "completed")) in your first script.
• Untils is not found: the plugin is not enabled. Tick Enable in Project Settings → Plugins, or add Untils.gd as an Autoload named Untils.
• Progress is not saved: you used user:// files or ConfigFile. Browser storage is blocked in the UNTILS sandbox. Use Untils.set_int and the other save commands.
• The game does not start, or shows a "SharedArrayBuffer" error: Thread Support is on. Turn it off in the export settings and export again (Godot 3: Export Type Regular).
• Sound does not start: browsers only allow sound after the first tap or click. Start your music from a button press.
• Large exports: keep the zip under 50 MB. Compress textures and audio, and remove unused export templates.

This SDK is in beta. If you find a problem, please tell us through the contact page and include your Godot version.

Inspector view and SDK check

Before a game or a new version (new zip) is uploaded, UNTILS checks your zip for the Untils SDK. If the SDK is missing, a red panel appears and the upload does not start, so integrate the SDK first and upload again. After the upload, UNTILS opens an Inspector view panel in your dashboard. It starts your game in the background and checks whether the Untils SDK is running, and the panel confirms the result.

The panel always has a link to the Inspector page. There your game opens like on UNTILS, with a console on the side that shows each event as it happens:

• init: the SDK started (and which SDK and version).
• loading start and finished, gameplay start and stop.
• save: how many keys and how big, and track events with their data.
• ad and score requests (ads and leaderboards are not live yet).
• error: errors from your game, when the SDK is running.

Chips at the top turn green when an event has fired. You can switch between Desktop and Phone size, restart the game, and copy the log.

Review and going live

1. PENDING - your game is waiting. Our team plays it on PC and phone and writes reviews. Review takes up to 2 days. While you wait, click your game in the dashboard and press Preview on UNTILS to play it on a UNTILS game page. The preview link works for 24 hours.
2. APPROVED or REJECTED - the leader decides. If rejected, a note explains why on your dashboard, and you can fix it and upload again.
3. LIVE - the game is public on UNTILS. A green PLAY button appears next to it in your dashboard, together with plays, players and likes. Messages from our team also show there, next to the game.

Rules

• Your game must be yours, or you must have the right to publish it.
• No adult content, hate, or violence aimed at real people.
• No malware, crypto-mining, tracking, or collecting players' personal data.
• No misleading names, icons, screenshots or banners.
• The game must work, load in a reasonable time, and not crash.

Questions? Use the contact page.