# GameArter Game Publishing Standard v0.2

> **First version, in testing.** This standard, its tools and the GameArter player are early versions and may still change. Please report bugs, suggestions and improvements via https://www.gamearter.com/contact.

This document tells you (a developer or an AI agent) exactly what to deliver to publish a game on GameArter.
Everything that is not game-specific is defined here, so you never need to ask GameArter about formats.

Version 0.2 describes **what to deliver** (information about the game, texts, images). HTML5 games need no SDK: GameArter adds its player automatically (section 13). Further player modules (ads, analytics, leaderboards) will come in later versions.

## Tools

The standard uses the tools below. Each is available in two equal ways – use whichever your agent can reach. Both are public and read-only: **no login, no API key**, and nothing is stored.

| Tool | Plain HTTP (works in any agent that can send HTTP requests) | MCP |
|---|---|---|
| `list_categories` | `GET https://www.gamearter.com/api/publishing/categories` (optional `?search=car`) | `list_categories` |
| `validate_package` | `POST https://www.gamearter.com/api/publishing/validate` | `validate_package` |
| JSON Schemas (optional) | `GET https://www.gamearter.com/api/publishing/schema` | `get_package_schema` |

- **Plain HTTP:** nothing to set up. Validate with a JSON body `{ "manifest": <manifest.json>, "texts": <texts.json>, "images": [<image metadata>], "partial": false }` (max 1 MB – image metadata only, never image files). Write the body to a file and send it, for example with curl:

  ```
  curl -s -X POST https://www.gamearter.com/api/publishing/validate -H "content-type: application/json" --data-binary @validate-request.json
  ```

  These are ordinary HTTP requests – curl is only an example, any HTTP client works (wget, PowerShell `Invoke-RestMethod`, a short script). In Windows PowerShell call `curl.exe`, not `curl`. Keep `validate-request.json` outside the package folder.
- **MCP:** remote server `https://www.gamearter.com/api/mcp` (Streamable HTTP, no authentication). Worth adding for agents without a shell or for repeated use.

This document as Markdown: `https://www.gamearter.com/api/publishing/standard`

**Never ask the developer for their GameArter password or any token.** Preparing and validating a package needs no account access; the developer uploads the finished folder in their GameArter account themselves (section 14).

## 1. Workflow

1. **Learn the game.** Play it, read its code or ask the developer. Collect: genre, setting, goal, core loop, progression, modes, controls (desktop and touch), supported languages, content rating. **Never invent features, numbers or modes.**
2. **Get the slug from the developer.** The developer signs up or signs in at https://studio.gamearter.com/ and adds the game as a new project there – that gives the game its slug. The slug cannot be changed by the package. Ask the developer for it, never invent one. Check the name against the rules (section 4). The developer name comes from the GameArter account the game is uploaded under – do not ask for it and do not put it in the package.
3. **Pick genres and tags** from section 3a (also available through `list_categories`). Choose 1 main genre, optionally up to 2 more, and 3–8 tags that really describe the game.
4. **Write `texts.json`** in English (section 8) and fill in gameplay facts, content and declarations (sections 6–7).
5. **Create images** in the required aspect ratios (section 9), optionally a preview video (section 10).
6. **Write `manifest.json`** (section 3).
7. **Validate.** Call `validate_package` (see Tools above) with the manifest, the texts and image metadata. Fix every error, fix warnings when you can. Repeat until `valid: true`. Validation checks the slug format only; that it matches the game in the account is checked on upload.
8. **Submit** the package folder (section 14).

## 2. Package layout

```
<slug>/
├─ manifest.json
├─ media/
│  ├─ cover-4x3.png        (required)
│  ├─ wide-16x9.png        (required)
│  ├─ square-1x1.png       (optional)
│  ├─ portrait-2x3.png     (optional)
│  ├─ screenshot-1.png …   (Unity WebGL only, 3–5)
│  └─ preview.mp4          (optional)
├─ texts.json              (required, English – filled into the
│                             game page form, not uploaded as a file)
└─ build/                  (hosted games only)
```

- All JSON files are UTF-8, no comments.
- File names in `media/` are fixed (section 9): only the extension may differ (png, jpg or webp). After approval the originals stay available under these names for the websites that take the game over.

## 3. manifest.json

| Field | Required | Format |
|---|---|---|
| `standard` | **yes** | `"0.2"` |
| `slug` | **yes** | Exactly the slug of the project the developer added at https://studio.gamearter.com/ (ask the developer). Becomes the game URL. |
| `name` | **yes** | English game name, max 40 chars (section 4). |
| `version` | **yes** | Game version, e.g. `"1.0"` or `"1.2.3"` (section 13). |
| `changelog` | no | What changed in this version, plain text, max 1000 chars. |
| `languages` | **yes** | Languages the game itself supports, ISO 639-1 codes. Must include `"en"` (section 5). |
| `genres` | **yes** | 1–3 genre slugs, main genre first (section 3a). |
| `tags` | no | Up to 8 tag slugs (section 3a), ideally 3–8. Pick precise ones, most relevant first. |
| `min_age` | **yes** | Recommended minimum age of players: 3 / 7 / 12 / 16 / 18. Your honest estimate based on the content (violence, fear, language). Older packages may still use the name `pegi`. |
| `platforms` | **yes** | `{ "desktop": bool, "mobile": bool }`. `mobile: true` only if the game is fully playable with touch. |
| `orientation` | no | `landscape` (default) / `portrait` / `any` – how the game should be held on mobile. |
| `game` | **yes** | Hosted on GameArter: `{ "type": "hosted", "engine": "html5" | "unity" }` (Unity may add `"build_folder"`, default `"Build"`). Elsewhere: `{ "type": "external", "url": "https://…" }`. |
| `media` | **yes** | Paths to images (keys from section 9), `screenshots` for Unity WebGL (section 9), optional `preview_video` and `youtube` (https URL of a gameplay trailer). |
| `theme` | no | `{ "primary": "#RRGGBB", "background": "#RRGGBB" }` (section 11). |
| `gameplay` | **yes** | Player modes, session length, audience, saving (section 6). |
| `content_descriptors` | **yes** | Content behind the recommended age, may be empty (section 6). |
| `declarations` | **yes** | Rights and privacy confirmations (section 7). |
| `credits` | no | Third-party assets and licenses (section 7). |

Example:

```json
{
  "standard": "0.2",
  "slug": "turbo-drift",
  "name": "Turbo Drift",
  "version": "1.0.0",
  "languages": [
    "en",
    "de",
    "es",
    "fr",
    "pt",
    "ru"
  ],
  "genres": [
    "racing",
    "arcade"
  ],
  "tags": [
    "drifting",
    "cars",
    "stunts",
    "3d"
  ],
  "min_age": 3,
  "platforms": {
    "desktop": true,
    "mobile": true
  },
  "orientation": "landscape",
  "game": {
    "type": "hosted",
    "engine": "unity",
    "build_folder": "Build"
  },
  "gameplay": {
    "player_modes": [
      "single"
    ],
    "session_length": "short",
    "audience": "everyone",
    "saves": "browser"
  },
  "content_descriptors": [],
  "media": {
    "cover_4x3": "media/cover-4x3.png",
    "wide_16x9": "media/wide-16x9.png",
    "square_1x1": "media/square-1x1.png",
    "portrait_2x3": "media/portrait-2x3.png",
    "screenshots": [
      "media/screenshot-1.png",
      "media/screenshot-2.png",
      "media/screenshot-3.png"
    ],
    "preview_video": "media/preview.mp4"
  },
  "theme": {
    "primary": "#FF5A1F",
    "background": "#14141F"
  },
  "credits": [
    "Music: Example Composer (CC BY 4.0)"
  ],
  "declarations": {
    "owns_rights": true,
    "no_personal_data": true,
    "no_third_party_tracking": true
  }
}
```

## 3a. Genres and tags

Genres are the game categories used by Google Play and the App Store, so players, stores and websites understand them the same way. Tag names follow Steam tags where one exists. Use the slugs exactly as written.

**Genres** (`manifest.genres`, main genre first):

`action`, `adventure`, `arcade`, `board`, `card`, `casino`, `casual`, `educational`, `music`, `puzzle`, `racing`, `role-playing`, `simulation`, `sports`, `strategy`, `trivia`, `word`

**Tags** (`manifest.tags`, optional):

- **gameplay:** `shooter`, `fps`, `sniper`, `fighting`, `platformer`, `runner`, `parkour`, `battle-royale`, `io`, `clicker`, `idle`, `merge`, `match-3`, `hidden-object`, `physics`, `tower-defense`, `survival`, `sandbox`, `building`, `crafting`, `management`, `tycoon`, `escape-room`, `stealth`, `roguelike`, `bullet-hell`, `drawing`, `coloring`, `dress-up`, `makeover`, `cooking`, `parking`, `drifting`, `stunts`, `jigsaw`, `mahjong`, `solitaire`, `chess`, `snake`, `upgrades`
- **theme:** `animals`, `horses`, `dinosaurs`, `cars`, `trucks`, `motorbikes`, `bicycles`, `flight`, `trains`, `naval`, `tanks`, `military`, `police`, `zombies`, `monsters`, `robots`, `space`, `sci-fi`, `fantasy`, `medieval`, `pirates`, `ninja`, `stickman`, `superhero`, `horror`, `christmas`, `halloween`, `food`, `fashion`, `farming`, `city`, `doctor`
- **sports:** `soccer`, `basketball`, `american-football`, `tennis`, `golf`, `hockey`, `baseball`, `boxing`, `skiing`, `fishing`, `hunting`, `billiards`, `bowling`
- **style:** `3d`, `2d`, `pixel-graphics`, `low-poly`, `cartoon`, `cute`, `funny`, `relaxing`, `difficult`
- **education:** `math`, `language`, `geography`, `science`, `typing`

- Do not use tags for things the manifest already says: number of players (`gameplay.player_modes`), audience (`gameplay.audience`), mobile support (`platforms`) or the engine (`game`).
- No brand, franchise or character names. Missing a tag that fits the game? Tell us via the contact form.
- Packages made for standard 0.1 with numeric `category` and `tags` are still accepted for now, but please switch to `genres` and tag slugs.

## 4. Game name

The name is the most important piece of SEO and marketing – it appears in search results, on tiles and in links. Choose it deliberately.

- **Short and punchy:** 1–3 words, ideally up to 25 characters (hard max 40). Easy to say, spell and remember.
- **Tells what the game is about** where possible: one word players would search for (drift, tower, merge, parking, sniper…) combined with a distinctive word (`Turbo Drift`, `Merge Kingdom`, `Sky Sniper`).
- **Unique:** must not copy or imitate an existing game or brand..
- **No filler words:** "game", "games", "online", "free", "unblocked", "html5", "browser", "play", "new", "best", "hd" – portals add such words to their titles themselves.
- No version numbers, years, emoji or special characters. Title Case, not ALL CAPS.
- English. The name stays the same in every language.

## 5. Game language

- **English is required:** the game must be fully playable in English and English is its default language.
- **Recommended languages:** `en` English, `ar` Arabic, `cs` Czech, `de` German, `es` Spanish, `fr` French, `ja` Japanese, `pl` Polish, `pt` Portuguese, `ru` Russian, `tr` Turkish.
- **Multilingual games** pick the language automatically from the browser (`navigator.languages`): the first browser language the game supports wins. If the game does not support any of the browser languages, it falls back to **English**. A language switch in the game menu is welcome, but the game must never start with a language selection screen.
- List every supported language in `manifest.languages`, e.g. `["en", "de", "es"]`. Use the base code (`pt`) or a region code (`pt-BR`) as the game does.

## 6. Gameplay and content

Facts about the game in `manifest.gameplay` and `manifest.content_descriptors`. Players filter by them and websites use them in their texts.

| Field | Required | Values |
|---|---|---|
| `gameplay.player_modes` | **yes** | Array of `single`, `local_multiplayer`, `online_multiplayer`. |
| `gameplay.max_players` | for multiplayer | Maximum number of players. |
| `gameplay.session_length` | **yes** | Typical play session: `short` (under 5 minutes), `medium` (5–20 minutes), `long` (over 20 minutes). |
| `gameplay.audience` | **yes** | Main target audience: `kids`, `teens`, `everyone`, `adults`. Must match `min_age` (`kids` only with min_age 3 or 7). |
| `gameplay.saves` | **yes** | `none` or `browser` – progress saved in the browser (localStorage / IndexedDB) and kept after a page reload. Cloud saves will come later. |
| `content_descriptors` | **yes** | What led to the recommended age, may be empty: `violence`, `bad_language`, `fear`, `gambling`, `sex`, `drugs`, `discrimination`, `in_game_purchases`. |

## 7. Rights and privacy

`manifest.declarations` must confirm all of the following with `true`. A game that cannot confirm them cannot be published yet.

- `owns_rights` – You own or have a license for everything in the game: code, graphics, music, sounds and fonts. No third-party IP (characters, brands, names) without permission.
- `no_personal_data` – The game itself does not collect personal data (names, e-mails, location, device identifiers).
- `no_third_party_tracking` – The game contains no own tracking, analytics or advertising code of third parties.

`manifest.credits` (optional) lists third-party assets and their licenses, one line each, e.g. `"Music: Jane Doe (CC BY 4.0)"`. Assets whose license requires attribution must be listed.

## 8. Texts (texts.json)

**English only.** These texts are the source for the GameArter game page and for every website that distributes the game – each of them creates its own language versions and its own SEO texts from your English text. Do not send other languages.

All four fields are required.

Put `texts.json` into the package folder. When the developer drops the folder in their GameArter account, the texts are filled into a form on the game page (the file itself is not stored). The developer can review and edit them there before submitting.

| Key | Format | Length | Content |
|---|---|---|---|
| `title` | plain | max 60 chars, ideal 30–60 chars | SEO title tag. Starts with the game name, then a short natural description of the game type (e.g. "Turbo Drift - Neon Street Racing Game"). No keyword stuffing. |
| `meta_desc` | plain | max 160 chars, ideal 110–150 chars | Meta description. One or two natural sentences saying what the player does and why it is fun. Mentions the game name. |
| `controls` | controls | – | Complete control mapping, one control per line in the format `*key* = action`, including touch controls for mobile games (see Controls format). |
| `description` | html | min 200 words, ideal 250–700 words | Detailed description of the game – the source for every other text about the game (see What the description must cover). Paragraphs (<p>) with <h2> subheadings, lists allowed. |

Formats:
- **plain** – text only, no HTML, no Markdown.
- **html** – an HTML fragment. Allowed tags: `<p>`, `<h2>`, `<h3>`, `<ul>`, `<ol>`, `<li>`, `<strong>`, `<em>`, `<b>`, `<i>`, `<br>`, `<a>`. Every tag closed, no attributes except `href` on `<a>` (https:// or relative). No inline styles, scripts or classes. Use `<h2>` for section headings (never `<h1>`).
- **controls** – see below.

Minimums are hard requirements; the "ideal" ranges are recommendations.

### What the description must cover

Only the points that apply to the game, each with concrete, true facts (numbers of levels, cars, characters, modes):
- What kind of game it is: genre, setting, story or theme.
- The player's goal and how a round or level goes (core gameplay loop).
- Progression: levels, worlds, upgrades, unlocks, currencies, difficulty curve.
- Game modes, single player / multiplayer, saving progress.
- How to play: the first steps for a new player.
- Tips and strategies.
- What makes this game different from similar games.

### Writing rules

- Clear, simple international English that is easy to translate: short sentences, no slang, puns, idioms or culture-specific jokes.
- Write for players, not for search engines. Natural, concrete, scan-friendly sentences.
- `title` starts with the game name. `meta_desc` and the first paragraph of `description` must not be the same sentence.
- Only facts that are true for this game. No superlatives without proof ("best game ever"), no invented numbers.
- No keyword lists, no comma-separated search phrases, no "free online unblocked" stuffing.
- Never mention SEO, keywords or what "this page" should do.
- Do not mention prices, other portals, app stores or download links.

### Controls format

One control per line: `*key* = action`. Keys are wrapped in single asterisks.

```
*W* / *up arrow* = accelerate
*A* *D* = steer
*space* = jump
*1* ... *6* = select weapon
*mouse* = aim
*left click* = shoot
Player 1:
```

- Allowed line shapes: `*key* = action`, `*key* / *key* = action`, `*key* *key* = action`, `*key**key* = action`, `*key* ... *key* = action`, a group label like `Player 1:`, or only key tokens.
- Never `**key**`. After a closing `*` comes a space, `=`, `/`, `...` or another `*key*`.
- List every control the player needs, including pause or menu keys.
- If the game is playable on mobile, add the touch controls as well (e.g. `*tap* = jump`, `*swipe* = steer`).
- No sentences or paragraphs.

### Example texts.json

```json
{
  "title": "Turbo Drift - Neon Street Racing Game",
  "meta_desc": "Drift through neon city streets, chain long slides for boost and beat rival racers in Turbo Drift, a fast arcade racing game.",
  "controls": "*W* / *up arrow* = accelerate\n*S* / *down arrow* = brake and reverse\n*A* *D* = steer\n*space* = handbrake drift\n*shift* = turbo boost\n*P* = pause\n*on-screen pedals* = accelerate and brake on mobile\n*tilt* / *on-screen arrows* = steer on mobile",
  "description": "<p>Turbo Drift is an arcade racing game set in a neon city that never sleeps. You join an underground street racing league and work your way from the harbor docks to the rooftop circuit downtown. Every race takes place on narrow streets full of sharp corners, where the fastest line is almost always sideways.</p><h2>Drift to charge your turbo</h2><p>The core of the game is the drift combo. Hold a long, clean slide through a corner and your boost meter fills up; chain several corners without touching a wall and the combo multiplier grows. Release the turbo on the straights to overtake rivals. Hitting a wall resets the combo, so smooth driving pays off more than raw speed.</p><h2>Cars, upgrades and progression</h2><p>Winning races earns coins that unlock 12 cars, from light hatchbacks that turn on a dime to heavy muscle cars with a huge top speed. Every car can be upgraded in three areas: grip, acceleration and boost capacity. New districts open once you win enough races in the previous one, and each district ends with a duel against its local champion.</p><h2>Game modes</h2><p>Career mode has 30 races across four districts. Time Attack lets you chase your best lap on any unlocked track, and Drift Zone is a score mode where only your combo counts. The game is single player and saves your progress automatically in the browser.</p><h2>How to play</h2><ol><li>Pick a car in the garage and start the first Career race.</li><li>Accelerate into a corner and tap the handbrake to start a drift.</li><li>Steer against the slide to hold it and fill the boost meter.</li><li>Release the turbo on long straights to pass rivals and finish first.</li></ol><h2>Tips</h2><ul><li>Avoid walls, a crash resets your drift combo.</li><li>Upgrade grip first if you keep spinning out.</li><li>Save some boost for the final straight of each lap.</li></ul>"
}
```

## 9. Images

Two required images: one preview for the web (game tile) and one for social networks. Deliver one master image per aspect ratio – GameArter converts them to all sizes it needs, so do not resize to small sizes yourself.

| Key | File | Ratio | Recommended size | Min width | Required | Used for |
|---|---|---|---|---|---|---|
| `cover_4x3` | `media/cover-4x3.png` | 4:3 | 800×600 | 450px | **yes** | Main game tile in the catalog (resized to 350×263 and 230×172) and the Gameplayer cover (460×344). |
| `wide_16x9` | `media/wide-16x9.png` | 16:9 | 1920×1080 | 1280px | **yes** | Social share image (cropped to 1200×630), banners and featured slots. |
| `square_1x1` | `media/square-1x1.png` | 1:1 | 1200×1200 | 512px | optional | Icon-style listings and mobile shelves. |
| `portrait_2x3` | `media/portrait-2x3.png` | 2:3 | 800×1200 | 600px | optional | Vertical cards on mobile. |

Files: png, jpg, jpeg, webp (PNG preferred), sRGB, opaque (no transparency), max 5 MB each. Ratio tolerance ±1.5 %.

### Art direction

- **Same key art in every ratio**, recomposed for each format. Never stretch, squash, letterbox or add blurred bars.
- **The image must grab attention** – design it like a typical eye-catching game thumbnail, not a plain screenshot.
- **Include the game title** (logo / wordmark). One version for all languages.
- Other short text is fine when it makes the thumbnail more attractive (a short tagline, a level count, a callout like "Boss fight!"). Keep it in English, short and secondary to the title.
- The title must be readable at 230×172 px: on 4:3 and 16:9 at least ~15 % of the image height, strong contrast (outline or shadow if needed).
- **Safe zone:** keep the title and the main character/object inside the central 80 % of the image. Edges get cropped (16:9 is cropped to 1.91:1 for social sharing).
- Show what the game really is: its characters, vehicles, world and art style. Nothing that does not appear in the game.
- One clear focal point, vivid colors, strong contrast, little clutter – it must work as a small thumbnail next to other games.
- **Forbidden:** fake buttons ("Play now"), prices, ratings or stars, age rating labels, platform, engine or store logos, URLs, watermarks, misleading claims, borders, frames, rounded corners, raw screenshots with HUD/UI, AI artifacts (garbled letters, deformed hands).

For `validate_package` pass image metadata: `[{ "key": "cover_4x3", "width": 800, "height": 600, "format": "png", "bytes": 412345 }, …]`.

### Screenshots (Unity WebGL only)

Unity WebGL games show screenshots on the loading screen while the build downloads, so they need 3–5 screenshots in `media.screenshots`. Other games do not deliver screenshots.

- 16:9, recommended 1280×720, min width 960px, same file formats as above.
- File names: `media/screenshot-1.png`, `media/screenshot-2.png`, … in the order of the array.
- Real gameplay from different parts of the game (levels, modes, characters). HUD may be visible, no added text or frames.
- For `validate_package` use the key `"screenshot"` in image metadata.

## 10. Preview video (optional)

Short gameplay loop shown when a player hovers over the game tile.

- MP4, H.264, 4:3, 640×480.
- 10–20 seconds, loops seamlessly, no audio, max 2 MB.
- File name: `media/preview.mp4`.
- Real gameplay only, the most exciting moment first, no text overlays, no intro or logo screens.
- To fit the size limit, compress the video, e.g. with https://www.freeconvert.com/video-compressor: codec H.264, target video quality 31, compression speed "very slow".
- The package check rejects videos that are not H.264, are outside the length range or exceed the size limit. GameArter may decide not to use the video and replace it with its own.

## 11. Theme colors (optional)

`theme.primary` is the dominant accent color of the key art, `theme.background` a dark or neutral backdrop color. GameArter uses them for the loading screen and accents on the game page.

- Take both colors from the cover image so the page matches the art.
- `background` must keep white text readable (contrast ratio at least 4.5:1).

## 12. Technical recommendations

Recommended, not validated. Games that follow them load faster and get through review faster.

- **Size:** whole build up to 50 MB, at most 20 MB downloaded before the game is playable. Load the rest in the background.
- **Load time:** playable within ~10 seconds on an average connection. Show loading progress.
- **Performance:** a stable 60 FPS on desktop and at least 30 FPS on a mid-range phone.
- **Window size and fullscreen:** the GameArter player handles the container and fullscreen itself. The game must be ready for it: fill the given area, adapt to any size and aspect ratio and to size changes at runtime (window resize, entering/leaving fullscreen, phone rotation) without reloading or distorting. No own fullscreen logic is needed.
- **Audio:** start sound only after the first player interaction (browsers block autoplay). Provide a mute option.
- **Tab switching:** pause the game and mute audio when the page is hidden (`visibilitychange`), resume when it is visible again.
- **No redirects or external links:** the game never navigates the page away, opens pop-ups or links to other sites or stores.
- **Saving:** if `gameplay.saves` is `browser`, progress must survive a page reload.

## 13. Hosted builds and updates

Only for `"game": { "type": "hosted" }`. The game is served from `https://www.gamearter.com/game/<slug>/`, so every path inside the build must be relative.

- **html5:** `build/index.html` plus all assets. GameArter takes the contents of `<head>` and `<body>` from `index.html`; the page gets `<base href="/game/<slug>/">`.
- **unity:** Unity 2020 or newer WebGL build in `build/<build_folder>/` (default `Build`) containing `*.loader.js`, `*.data`, `*.framework.js` and `*.wasm` (optionally `.br`, `.gz` or `.unityweb` compressed). Enable "Name Files As Hashes".

**Updates:** send a new package with the same `slug`, a higher `version` and a short `changelog` (what changed for players, max 1000 characters). Files are cached for a long time, so changed files must get new names (hashed file names); never overwrite a file under the same name. Saved progress from the previous version must keep working.

### GameArter player (html5)

GameArter adds a lightweight player to every hosted HTML5 game page: a small **G** button with *Back*, *Fullscreen* and *Powered by GameArter*. It is shown expanded for a few seconds after load, then collapses to a semi-transparent circle.

- **Nothing to integrate.** No SDK, no init code, no configuration in the game. The player is built from modules; the `toolbar` module (the G button) is added by GameArter to every game. More modules (ads, analytics, leaderboards) will follow – a game will only include the scripts of the modules it wants.
- **Isolated from the game.** The player UI lives in a Shadow DOM: it adds no global styles, resets or fonts, the game's CSS cannot break it, and clicks and touches on the button never reach the game.
- **Optional placement.** By default the button sits at the screen edge (bottom left). If that covers game controls, put this element where the button should be – ideally top left, next to the game's own menu:

  ```html
  <div id="gamearter-toolbar"></div>
  ```

  The player sizes it to 44×44 px, covers it exactly and follows it when it moves. When the element is hidden or removed, the button returns to the screen edge. Do not give the element a size or content, use the id only once and leave about 250 px free next to it (the expanded button briefly overlaps neighbours).

## 14. Submission and review

- Upload the package folder (no ZIP) in your GameArter account. `texts.json` fills the Texts form on the game page, where the texts can be edited at any time before submitting. The upload is done by the developer in the browser – an agent does not need their login.
- Whoever uploads a package immediately gets a private **test URL** to check the game page.
- **Every game is reviewed by GameArter** before it is published. Reviewers may adjust texts, categories or images.
- Special cases are handled by GameArter manually (for example images without text, or a different game name per language). Do not try to cover them in the package.

## 15. Final checklist

- [ ] `validate_package` returns `valid: true`
- [ ] Name is short, punchy and unique; `manifest.slug` matches the game in the GameArter account
- [ ] The game runs in English by default, other languages are detected from the browser with English as fallback
- [ ] `texts.json`: `title`, `meta_desc`, `controls` and a detailed `description` in English
- [ ] Controls in `*key* = action` format, touch controls included for mobile games
- [ ] `cover_4x3` and `wide_16x9` present, eye-catching, with a readable game title inside the safe zone; screenshots for Unity WebGL games
- [ ] Gameplay facts, content descriptors and version filled in; all declarations confirmed
- [ ] The game adapts to any window size, pauses when the tab is hidden and does not redirect
- [ ] Nothing in texts or images that is not true for the game
