AI Initiative logoAI Initiative

AI Initiative lab

Game Creation Studio: reusable foundations for making games

Let creators focus on the experience they want to make while reusing common behaviour for play, input, display, saves and checking.

Creation toolkit A creation toolkit and engineering workflow. It is separate from any AI trained inside a game and from a player-facing AI feature.

The design question

What should each new game be able to reuse?

The reusable toolkit supports making and checking experiences. Its role is to give an idea a dependable starting point and an understandable route through review, while preserving the creative work and attribution of the people contributing it.

A view of the responsibilities

From a creative idea to a reviewable version

  1. 01Begin with an experienceDefine the question
  2. 02Connect the foundationsKeep the responsibilities distinct
  3. 03Build and reviewFollow the chosen path
  4. 04Exercise the difficult pathsInspect what happened
  5. 05Prepare a versionUse the result carefully
Across the flow

Follow an idea through shared game foundations, difficult-path checks and preparation of a reviewable version. Publication remains a separate decision.

A responsibility-level flow through the work. It does not imply that separate experiments or applications are one deployed service. Select a step to read its walkthrough.

What each part is responsible for

The building blocks

Starting templates

Provide a small working structure for different game types so a creator can concentrate on the game-specific rules and presentation.

Receives
A game idea, intended audience and interaction type
Produces
A small working starting structure

Round lifecycle

Coordinates starting, playing, pausing, resuming and ending a round, including ownership of resources created during play.

Receives
Player input and the current round phase
Produces
A controlled transition between play states

Input and layout

Adapts supported controls and the play surface to the device while preserving a usable route through menus and gameplay.

Receives
Device capabilities and intended interactions
Produces
A usable control and presentation path

State and saves

Keeps game progress separate from temporary round state, handles versioned saves and makes failed storage visible.

Receives
Progress, saved versions and storage outcomes
Produces
Restored progress or a visible failure

Display handling

Applies the configured text-handling policy at the point where dynamic content enters and is displayed. Unavailable checks should not silently become permission to display everything.

Receives
Dynamic material and configured display requirements
Produces
Material accepted for display or withheld

Game-specific logic

Contains the actual rules, challenge and creative decisions. Reusable foundations do not replace the author’s contribution.

Receives
Player input and the current game state
Produces
The next state, challenge response or result

Checks and release preparation

Examines source and runtime behaviour, packages a defined version and leaves publication as a separate decision.

Receives
A defined candidate and checks appropriate to it
Produces
Review findings and a prepared version

Following one piece of work

How the flow fits together

01Begin with an experience

Specify the idea and intended audience before choosing a template. The reusable layer provides working foundations; the challenge, creative direction and the experience worth returning to still need to be designed.

02Connect the foundations

Start from the appropriate structure and connect game-specific rules to input, layout, round state and saves. Shared behaviour should reduce repeated engineering while making it clear which state belongs to a round, a player or a saved version.

03Build and review

AI-assisted authoring can produce and revise implementation, while separate review examines the changes. Dynamic material passes through the configured display handling. Neither assistance during creation nor an ordinary saved state means the game itself learns through a neural model.

04Exercise the difficult paths

Check more than the happy path: pause and resume, navigation, small screens, storage failures and incompatible saved versions. Deliberately introduced faults can help establish whether checks detect the failure they are meant to detect.

05Prepare a version

Collect a defined candidate and its relevant checks for review. A quick initial pass, full release preparation and actual publication are separate milestones. Player feedback and creative judgement remain necessary even when the technical checks pass.

Illustrative example · not a benchmark result

Illustrative creation flow

A creator wants a small word puzzle.

  • Start from a matching template, add the challenge and answer rules, reuse input and save behaviour, then test play, pause, small screens and storage failures.

The useful result: A reviewable playable candidate with its shared foundations already connected.

Passing technical checks does not establish that the puzzle is enjoyable, educationally effective or suitable for every audience.

What is learned, remembered or calculated?

Learning: AI can assist authoring and review. That does not mean the resulting game trains a neural model or adapts through machine learning.

Memory: Saved progress and preferences support continuity for the player; they are ordinary application state.

Exact computation: Game rules and selected mathematical exercises can use deterministic calculation. Correctness depends on the rule and the implementation, not on a model’s confidence.

Authorship: The toolkit supplies reusable engineering. Game ideas and creative contributions keep their own attribution.

Reading the architecture accurately

Scope and status

What the work covers

  • A creation toolkit and engineering workflow. It is separate from any AI trained inside a game and from a player-facing AI feature.
  • AI can assist authoring and review. That does not mean the resulting game trains a neural model or adapts through machine learning.
  • Saved progress and preferences support continuity for the player; they are ordinary application state.
  • Game rules and selected mathematical exercises can use deterministic calculation. Correctness depends on the rule and the implementation, not on a model’s confidence.

What this work does not establish

  • Automatic publication.
  • AI-powered gameplay in every game made with the toolkit.
  • Guaranteed enjoyment or educational effectiveness.
  • Universal child-safety certification.

Where the design must hold up

Boundaries and evaluation

BoundaryWhy it mattersHow to examine it
Saved-version compatibilityA saved file from a newer game version must not be silently overwritten by an older implementation.Try the older implementation with a newer saved version and check that it preserves the data or refuses the unsupported version explicitly.
Storage failureA failed write must not be presented as successfully saved progress.Exercise unavailable or failing storage and inspect both the actual saved state and the message shown to the player.
Round and player ownershipPause, navigation and player changes can expose resource or ownership mistakes.Exercise repeated pause/resume, navigation and player changes; check that old round activity does not alter the wrong state.
Content handlingText filtering and content review have limits; no blanket guarantee of child safety is implied.Exercise unavailable checks and relevant content edge cases, inspect what reaches display and retain appropriate human content review.
Release milestonesA fast initial test pass is not equivalent to complete release preparation or publication.Identify which checks ran against which candidate, which release conditions remain and whether publication actually occurred.