Small games,
shared machinery

• Roll a Verity

  Free rolls, twelve collectible variants, six automatic income bays, and coin-funded rarity packs with visible odds. The server holds the result during the reveal and computes income before changing the lineup.

• Verity Knockout

  Draft a rolling mount, aim a launch, and try to knock five bots off a shrinking disk. A deterministic simulation produces replay frames; the client interpolates the action in a 3D ViewportFrame. Solo versus bots, with six variants.

• Patchball

  Choose one of three balls, set an angle, and watch an automatic battle before earning collectible unlocks. Fixed-step simulation and recorded inputs make matches reproducible.

• Meme Trials

  Choose a character and lane, watch a twelve-second obstacle trial, and collect medals and unlocks. Short sessions make the choose/watch/retry loop easy to test.

• Meme Factory

  An original factory-economy prototype: print memes, collect passive earnings, upgrade four machine tiers, and rebirth. The reusable economy drives an animated UI rather than a walkable 3D tycoon map.

• Word Forge

  Make unique words from six letters during sixty-second runs, with collectible score modifiers. A small curated vocabulary keeps the prototype’s rules inspectable.

• Forbidden Clues

  Describe a target without forbidden words and build a streak. A transparent rule-based judge evaluates the input; it does not call a live AI model or log the raw clue text.

The server owns the result

Clients send commands and choices. The server validates inputs, controls rewards and progression, and supplies the result. Shared session handling and rate limits support independent per-player sessions.

Simulation and presentation are separate

Patchball advances a fixed-step model and emits replay snapshots. Verity Knockout similarly computes a shot before animating it. Reproducible inputs make game rules easier to test without depending on engine physics determinism.

Shared work is checked across every game

Reusable UI, feedback, RNG, session transport, and economy modules sit in a private studio monorepo. CI derives a build matrix from the game catalog, then checks and builds all seven places so a shared change cannot skip a dependent game.

1. Player inputCommands and choices
2. Server rulesValidation and state
3. Result / replayAuthoritative outcomes
4. Client UIReveal and interpolation

The suite has passed code compilation, pure-module type checks, thirty test groups, and builds for all seven games. Each game has a first solo playtest in Mac Studio.

Persistence, public releases, purchases, and multi-client verification remain ahead. Names and art are provisional. These are development prototypes, so there are no public play links or player-count claims yet.