Make your own · A studio · What’s new Beta
Each release of the Homie plugin for Claude Code, Codex and Grok, and of @homie-rocks/studio (your studio’s command, its site and its multiplayer rooms), newest first: what you can do now, what changed, what was fixed, and anything to do yourself when you upgrade.
These are historical release notes for the installed toolkit and its local tools. They are not the remote MCP’s tool list. For a new project, use the current installation guide; ask the remote MCP for tools/list before calling its tools.
Newest: 0.58.19, plugin 0.58.13124 releases
Your studio keeps the version it pins until you choose. Tell your AI: “Upgrade my studio to the newest Homie.” It shows what’s new since your version and what would change, and changes nothing until you agree.
Plugin 0.58.13
A platform that runs a studio's scheduled ticks can use the worker's own cron parser.
@homie-rocks/studio/worker/schedule exports the worker's own cron parser (parseSchedule, nextDue, with its types), Cloudflare's five-field UTC dialect, so a platform that runs a dispatch Worker's scheduled ticks schedules them as the studio's Cron Triggers would fire.Plugin 0.58.12
Docs and tool descriptions describe the toolkit as it is today.
HOMIE_MEDIA) is worker/host-media.mjs; it behaves as before.Plugin 0.58.10
A failed deploy says what Cloudflare or the host actually refused.
Plugin 0.58.9
A tab left open in a lobby no longer holds a studio move's drain.
homie-studio drain on has run for 5 minutes, a room still waiting in its lobby (no round started, or the last round over and its results seen) is ended: the people in it are told "This studio is moving. Please join again shortly." and their pages do not knock on the paused door again. A room with a round in progress still plays until it finishes, and a room whose results are not yet saved is never ended. homie-studio drain status says how many rooms it ended this way (idleLobbiesEnded), so you can see why the drain finished.Plugin 0.58.8
A hosted workspace no longer offers the tools that need the person's own fal or Stripe account.
asset_make, character_make, stripe_shop_plan or stripe_bookings_sync, which generate on the person's own fal account or set up the shop on their own Stripe account, and its instructions no longer promise them or ask the person to sign in to providers there.Plugin 0.58.7
A hosted workspace offers only the tools that work there, and a build put on the private preview no longer ends the check it is part of.
HOMIE_PREVIEW_URL named by the host), the local MCP server does not offer the tools that set up or sign in this computer, change the studio's own Cloudflare account or build for another platform (setup, scaffold and open, the GitHub, Cloudflare and Stripe sign-ins, the Stripe webhook, domains, the read-only switch, event webhooks, the Game Lab and standalone builds): the studio is already made and online with its host, whose sign-ins, domains and payments those are. Its instructions say so in place of the paragraphs about them.deploy --preview inside a check or playtest no longer ends that run's progress feed as passed before the check and the pictures have run; its stage says the build is on the private preview, not live.Plugin 0.58.6
Every browser the toolkit opens can be a cloud browser, and a studio worked on away from the person's screen previews on its own private preview.
HOMIE_BROWSER_WS_ENDPOINT set to a CDP WebSocket address (Cloudflare Browser Run, for example), they connect to it instead of starting Chrome on this computer. A platform target leaves queues and cron triggers to the platform.HOMIE_PREVIEW_URL. For a studio whose studio.json has a preview target (cloudflare.preview), the local MCP server's preview_run then puts the build there (deploy --preview) and gives that address, check and playtest put the current build there and open it, and preview_stop has nothing to stop. Without it, the site runs on this computer as before.Plugin 0.58.5
Host a studio on Workers for Platforms with a private preview, check it with a browser in the cloud, and prepare a studio for a move with an owner-controlled read-only switch.
cloudflare.dispatchNamespace, worker, d1Id and domain in studio.json name the preprovisioned Worker, and homie-studio deploy sends the build there with Wrangler's own --dispatch-namespace. cloudflare.preview names a second Worker and database, and homie-studio deploy --preview sends the same build to it. A platform that deploys studios this way enforces the target at its own API boundary.homie-studio check and the playtest script can use a browser in the cloud: with HOMIE_BROWSER_WS_ENDPOINT set to a CDP WebSocket address (Cloudflare Browser Run, for example), they connect to it instead of starting Chrome on this computer.homie-studio drain on|off|status pauses new room admissions without deploying or closing existing sockets. A move waits for empty rooms and delivered records before freezing the source.HOMIE_MEDIA) preserves streamed media, range requests and large player saves.homie-studio read-only on|off|status (and the local MCP tool studio_read_only) freezes the live studio for a few minutes, for a move to another host or maintenance, without losing anything. It sets the Worker secret STUDIO_READ_ONLY with the studio's own Cloudflare sign-in, as a new Worker version. While on, changes answer 503 with Retry-After and x-studio-read-only: 1; pages, games, live rooms and the Stripe webhook keep working, D1 takes no other write, room records wait in each room, scheduled and queued work waits, and /api/games reports readOnly.Plugin 0.58.3
Build games from shared parts while keeping server rules deterministic.
part_new. Every dependency receives the existing rules checks, including filesystem boundary checks.Plugin 0.58.3
Play falling-block games with visible standings, round winners and controls that follow a sliding thumb.
Plugin 0.58.3
A falling-block starter gives board-game requests a working mechanic to build on.
block-drop: separate 10×20 wells, seven-piece bags, rotation and wall kicks, ghost pieces, line clears, keyboard and touch controls, procedural audio, bots and two-minute server rounds. A newcomer taking a bot seat gets a fresh well.seat, room events and exact-location compiler repairs.game new <id> --from block-drop.Plugin 0.58.2
A page that no longer has access stops. It does not keep waking the records object.
Plugin 0.58.2
A signed-in app gets its live socket. Leaving that page open no longer wakes the records object.
Plugin 0.58.2
An open app rests while nobody is changing it. The live connection sleeps with the records object, and a studio MCP client no longer holds an event stream open.
events/stream still works for that one request, and it no longer sends a heartbeat that would wake the object again.Plugin 0.58.2
An idle studio no longer keeps its lobby awake. Reading who is playing uses the summary already stored for the lounge, and a room that is merely sitting there lets its lobby shard hibernate.
Plugin 0.58.2
The studio owner opens a private app role. A staff link can expire, and it can be listed or revoked on its own.
homie-studio app role <id> --list lists each private role's link and expiry. --expires takes a day count (30d) or a unix time in milliseconds. --revoke-link revokes the link and leaves a player's own grant as it was.Plugin 0.58.1
A room nobody is playing rests, and the next touch wakes it with that input still applied.
room.restSeconds), or every page in the background for ten seconds. Its clock stops with everybody still connected and the room hibernates, so it is not charged for duration while it sleeps. It still wakes about once a minute for a liveness alarm (one request, and the CPU of that short wake). A deliberate rest is restored as the same world, under the same epoch, without rewriting the save. The first touch, command, AI command, returning page or new arrival starts it again on the tick it stopped on, and a phone that reconnects keeps its seat. By default (room.rest: "quiet") a room rests only when its world has nothing of its own to do: no round clock, no event, timer, spawn or ask waiting, nothing moving, and no AI command for that minute. "idle" rests anyway and pauses round clocks, timers, bots and AI with it; Coin Dash, Ember Vale, Gem Rush, Gem Rush 3D and Hero Rush 3D use it. "never" keeps a room going while anybody is there (a turn timer, a show). Browser-hosted rules games rest the same way. A spectator or agent on an older build keeps pinging the room itself, so the object stays in memory while that socket is open. Rebuild your games to get it: a room rests only when every seated browser is on this version.room.rest to "never" (or restSeconds to 0) for a turn timer or a show that must keep going while people are present. A lasting world never rests.Plugin 0.58.0
Two new shared parts — an owner action checklist and a 3D terrain route map — and booking calendars that can skip or change single dates in a weekly series.
packages/studio/docs/toolkit-place-patterns.md).Plugin 0.57.0
Studios can book at each other on behalf of a person, with proven studio identity and signed events, and friends joining a browser-hosted game at the same moment always get their seat.
packages/studio/docs/studio-to-studio.md.Plugin 0.56.0
Studios scale with hibernating rooms, add custom routes with built-in access checks, and deploy reliably with background queue handlers.
useRoutes hook for custom APIs, well-known files and callbacks, after Homie's matched routes and before Worker asset fallback, with response security headers.isOwner(request, env) and hasRole(request, env, app, role) authorization helpers using existing live session and app access checks.self for the runtime studio origin, with origin and redirect restrictions retained.fetch now inherit missing toolkit queue and scheduled handlers in the generated entry, so background queue consumers attach during deploy. Custom handlers remain intact./api/custom/* paths and app cookie scope.assets.run_worker_first entries cannot exclude paths with !; the build refuses them so private app files always stay behind their access checks.net.on('link', listener) now calls the listener synchronously on subscription with why: 'subscribe' and prev === state, then reports changes as before.packages/studio/docs/custom-routes.md (the installed package uses docs/custom-routes.md).Plugin 0.55.0
Studios start faster and serve files straight from Cloudflare, background work and Stripe events go through retrying queues so nothing is lost, and the runtime follows Cloudflare's published practice.
stats.analytics: true in studio.json to count page activity with Analytics Engine and hourly, replay-safe D1 rollups that preserve historical totals. Owner statistics explain ingestion lag and sampling.Plugin 0.54.0
Studios answer faster, private apps stay private and usable, shops catch every payment, and the toolkit's CI costs a quarter of what it did.
maxQuantity (default 99), slot links accept groups within published remaining capacity, and confirmation uses the paid seat quantity atomically. Payments that cannot be fulfilled remain visible as review orders with a durable staff event and customer notice. Full connect saves public JSON link assets, retaining replaced links until deployment.room.me readers share a presentation even when CPU work crosses a simulation tick; the next microtask refreshes it. Fixes the 60 Hz browser prediction smoke flake without relaxing thresholds.shop connect to publish its public link configuration. Review group availability and resync slot manifests after confirmations, moves or refunds; a Payment Link is not an exclusive unpaid hold.Plugin 0.53.0
Take bookings against real resources, keep private apps usable, collect deposits reliably and turn tested examples into your own place.
booking.slots_need_payment_links events let your studio respond when rolling slot inventory needs payment links.shop observe accepts incremental public responses from Stripe's official plugin and returns the next setup plan without a hand-built observations file. New Stripe sign-ins show pairing instructions in the job's progress before approval completes.0030_booking_resources.sql after the existing booking migrations to use resource-aware bookings.Plugin 0.52.0
Run your place with trusted actions across screens and AI, live business records, shared booking capacity and stronger proofs that it works for your customers.
createAppTools, with strict input schemas, server role checks and versioned writes.0027_app_live.sql, 0028_business_events.sql and 0029_booking_holds.sql in order.createAppContext.Plugin 0.51.8
Run your studio across more screens with reliable shared records, clearer checks and a simpler owner connection.
check --webgl-failure; fallback notices stay in the page flow so controls remain reachable.build --types checks when imported into your app or game.connector uses your Wrangler sign-in to save a private MCP configuration limited to the chosen tools, studio origin and expiry. You can revoke access; the server stores only token hashes and command output contains no bearer secret.Plugin 0.51.7
Finish setting up your shop through Stripe's official plugin, and see what your studio's scheduled work is doing.
Plugin 0.51.6
Keep each customer's exact basket through payment, and check that your studio meets its needs across screens, AI jobs and handover.
--shots.shop.json.basket and require Stripe with tax-inclusive menu prices. Automatic tax and Managed Payments are refused for basket mode. Staff can use the reported basket total, actual payment and settlement status to collect a shortfall.Plugin 0.51.5
Connect your shop and media through official plugins, keep renewals and free bookings working, and see progress while you build.
build --quick keeps type and guard checks while skipping play and snapshot smoke checks.media import places completed media, checks scene references and records file hashes, rights, provenance and explicit cost status. Video guidance and local processing tools now ship with the toolkit.stripe_shop_plan / shop plan, then stripe_webhook / shop webhook. Private webhook setup may need a separate Stripe CLI browser approval. shop connect remains the full CLI alternative; shop listen forwards local events privately.build --quick while iterating.Plugin 0.51.4
Your studio’s declared events reach supporting AI clients through experimental MCP polling, SSE streams and signed webhooks.
events/list, cursor/replay polling, SSE push with heartbeat and resume, and authenticated webhook subscribe/refresh/unsubscribe with negotiated TTLs and client-supplied Standard Webhooks secrets.receivers array for extension webhooks. Workers fetch cannot pin DNS with original TLS SNI, so arbitrary callbacks are refused; the guide documents this draft limitation. Poll and push need no callback setup.Studio events through experimental MCP Events.
Plugin 0.51.3
Business and cause apps use their own words, count every paid monthly gift, and test real Stripe checkout locally.
shop connect --local --profile <sandbox> --url <Wi-Fi address> syncs test Payment Links without Cloudflare or a public webhook. Stripe CLI forwards signed events to dev; phones return to the same Wi-Fi thank-you page.dev loads root .dev.vars. App collections no longer stop accepting records at 1,000..dev.vars. Local Stripe links are test-only; live connection and deployment are unchanged.screen.share choices and authored site headers remain in control. Subscription renewals now emit order.paid as well as lifecycle events; fulfilment listening to both should deduplicate by payment identity.Plugin 0.51.2
Your studio follows your listing choice, shares one public address, and keeps its apps and tools working after deploy and upgrade.
/mcp/auth; public tools remain available through /mcp.homie.directory: true or a directory URL before deploy./mcp/auth for staff AI connectors and /mcp for public connectors.Deploying and listing do what the studio chose, under one address.
Plugin 0.51.1
Your platformer keeps a player's runner moving smoothly through network corrections and reconnects, with less work per frame on slower phones.
respawned.A player's own runner never jumps across the screen.
Plugin 0.51.0
One Stripe approval enables mixed menus, paid capacity bookings and monthly giving through the owner’s own account.
order.paid.stripe_bookings_sync.STRIPE_CHECKOUT_MODE=sessions explicitly opts into the fuller connection.Take the money through your own Stripe, keyless by default.
Plugin 0.50.7
Your app checks can show that your staff, tablet, kiosk, phone and wall workflows meet the needs you wrote down. Local checks use fresh records, and everyday studio work is more reliable.
0024_tool_data_versions.sql, which lets functions detect conflicting record updates. This release adds no studio quota or automatic history deletion.check --no-isolate when you deliberately want to check existing records. Production sign-in stays the same.Prove your needs on every screen, with fixes from studio testers.
Plugin 0.50.6
Your studio runs scheduled functions even when nobody has the office open. Your owner AI can check what ran, see failures and retries, and tell you when each function is next due.
homie-studio functions runs [<name>] [--errors]. Each execution attempt stays in history, including failures followed by successful retries. Errors have credentials redacted, and older runs remain available through pagination.studio_function_runs tool to see run history, next due times, configured triggers and the last observed scheduled tick. Invalid schedules stop the build with the function name and reason; deploy plans show the triggers being installed.0023_function_runs.sql history migration. Workers Builds redeploys register functions too. Cloudflare can take up to 15 minutes to apply trigger changes.Scheduled functions run, and your AI can see every run.
Plugin 0.50.5
Your studio no longer tracks sales referrals or manages referral payments. Visit-source statistics remain available in your studio’s own stats.
?via= links still count as visit sources, without attributing sales.shop.json fields referrals and referralNewPlayersOnly, and studio.json referrals, are ignored with a one-line build note per field. They do not prevent a build; you can remove them from your configuration.0022_remove_referrals.sql, deleting referral tables, stored referral keys and sales-attribution columns from orders. Orders, payments, refunds and entitlements remain intact. Old referral cookies are ignored, and the removed referral features are no longer available.Homie has no referral system.
Plugin 0.50.4
Your studio can send booking updates and other events to your AI or service, even when it cannot keep a live connection open.
homie-studio events webhook. Your local AI can set them up, and your remote owner AI can check their status and send a test. Signing keys are stored in Worker secrets and shown once for receiver setup; delivery diagnostics keep keys and receiver response bodies private.homie-studio events webhook add <feed> <https-url>, then build and deploy your studio. Configure your receiver to verify Standard Webhooks HMAC-SHA256 signatures using the key shown during setup.Send studio events by signed webhook.
Plugin 0.50.3
A player's own dash or jump pressed while prediction catches up after a knock or correction starts at once from where they see their character, never from a stale position that jumps them across the screen.
f.press() (or f.pulse() for a byte-valued action), send it through room.input, and implement predicted movement in move. Existing games with these declarations receive the fix automatically. To retain pulses through a knock or stun until control returns, opt into player: {control: 'canMove', pulses: 'hold'}; the default is 'drop'. The game's action handler still decides cooldowns. This fix changes drawing only; server authority, input timestamps and replay rules are unchanged.A counter-dash continues from where the player sees it.
Plugin 0.50.2
Your player's own runner stays outside declared solid terrain in a 2D game on server rules, even on a lossy connection.
map: './map' in rules, put solid geometry in map/main.json, and keep it consistent with custom movement. Declare a square 2D runner with body.shape: 'box', radius (its half-width) and maxSpeed. Use ctx.substeps for custom integration so the toolkit draws that path without a second view-side displacement. Blocked visual corrections do not change authoritative movement.Keep your own runner out of solid ground.
Plugin 0.50.1
Committed events start delivery promptly, and an owner's AI can subscribe without polling.
Last-Event-ID; current roles filter live events and replay.app_role tool grants or revokes staff by verified email or exact sign-in name. app_records can delete with the role's permission and current record version.studio.json under mcp.events. Build regenerates the Worker configuration and retry cron. Existing studios need no subscription configuration to receive the delivery fix.Studio events reach their functions and the owner's AI.
Plugin 0.50.0
Apps now follow their owner’s words through planning, a living scene and evidence of each need.
Build the person's app from their dream.
Plugin 0.49.0
Businesses and causes can start, check and preview their first live app without hand fixes.
Apps from the first request.
Plugin 0.48.4
Requested deploys proceed, visitors reach the current build, and paired screens keep their private room.
Deploys go right.
Plugin 0.48.3
Rules input history fits the wire without starving current aim and trigger controls.
Restore rewind-based hits with input history.
Plugin 0.48.1
Rules views recover missing input and acknowledge late movement scheduling.
room.predict.blendMs and expire within one second (or an explicitly longer blend), including while stationary; idleHold no longer holds them indefinitely. Placement counters still distinguish respawns from prediction corrections. Vertical travel cannot erase a horizontal correction fast enough to reverse the held direction. Remaining offsets drain over the final 250 ms rather than snapping at expiry.room.input(sample, {at}) timestamps a control inside the current predicted tick. player.pulses: 'hold' queues actions while control is taken; 'drop' remains the default.Input history under loss.
Plugin 0.48.0
Rules games can sweep capsules through a baked GLB with the same deterministic physics on the server and in local prediction.
@homie-rocks/physics: build-time GLB baking, asynchronous initialization before ticking, synchronous metered capsule sweeps, casts, rays, overlaps and solver steps, and complete physics snapshots saved with the room. Browser movement replays against the same baked world. Games without physics retain their existing behavior and budget costs.ctx.substeps(body, hz, callback) lets a game choose its own integration rate within a room tick. Server and browser share the callback and budget; the view draws its recorded intermediate poses. The build checks authoritative body fields separately from these temporary drawing traces.docs/physics-048-calibration.md and docs/receipts/.@homie-rocks/physics 0.1.2 and name the game's static GLB with map.physics.level; see the Physics section of the rules guide. The complete solver save can exceed browser-host checkpoint caps, so the real-mesh example uses server hosting.Baked physics worlds for server rules and local prediction.
Plugin 0.47.0
Games can wrap across map edges and replace seeded tile levels during play, with the same collision geometry in server rules and prediction.
wrap: {x:true}; periods come from bounds. Bodies, sweeps, rays, overlaps, support, near/box queries, area events, ranged effects, spatial delivery, rewind and view interpolation use periodic geometry. Crossing an edge wraps rather than clamps. Sweeps/rays retain their supplied direction and pay for each periodic image they visit.world.map.replace(data). A replacement is validated, indexed and activated atomically at the next tick, preserving bounds and wrapping. Compact current/pending revisions are saved and sent once per collision revision; local prediction replays the same compiled map by activation tick.tiles with width, height, size, optional origin and solid height. Nonzero cells compile to indexed horizontal runs. Rules and movement can query map.tile(x,y); views read room.map.tiles.tiles.flows bake during map compilation. Rules and movement use constant-work map.distance(name,x,y) and map.flow(name,x,y). The standalone rules runtime ships the nav package's new Flow.js baker, checked against its source in the release gate. Generation, copying, indexing and baking are charged to the rules handler; ordinary static-map budget charges are unchanged.world.dispatch now report their coverage to the build checker, including failures, without opening a second handler budget.export * is refused), and the rules guide explains that mandatory spawn fields precede deferred arrive.Wrapped worlds and generated collision maps.
Plugin 0.46.6
What one room object carries on Cloudflare, measured in six trials and stated: with a light game at 20 ticks a second, 300 players with margin, 600 at the edge, 800 to 1,000 only by luck.
allowUnconfirmed; a save an admission asks for is confirmed as before and replaces it. A lasting world's writes are unchanged. At 300 players the gap every Gate saw once a second is gone, and a Gate's round trip to the room fell from 40 ms to 18.lib/crowd-probe/README.md): the in-Cloudflare probe offers compression as a browser does, reports every thirty seconds so a request cut short has still said what it saw, can play slow players among healthy ones (--slow-every), and times a fixed piece of work against your computer with the stopwatch outside Cloudflare (--calibrate). lib/crowd-probe/run-trial.sh runs a whole trial, each in-Cloudflare step three times, and writes one summary. The home driver can stop every Kth player's socket reading (--slow-every). Slow players' own figures are kept apart from everybody else's.docs/rooms-capacity-findings.md. Homie still sets no limit on players.max: choose it with your own game's numbers.HOMIE_GATE_PLAYERS on a studio's Worker sets the players a Gate holds, for a trial that is finding the right number. A studio does not set it.npm run test:crowd; docs/crowd-transport-0462.md says what it can and cannot show.Big rooms: what one room carries, measured. · release-2026-10-11-studio-0.46.6
Plugin 0.46.5
A page left open across a deploy is brought up to date with its game, and a check never opens the live site unless it is asked to.
room.bots: { keep, names: [...] }: a rules game names its own bots, by seat. The roster, the results and world.label all use it. Opt-in: without names the toolkit's own list is used, as before.ctx.judgedTick(aimTick) (the tick the server will pose the others at for this seat; the snapshot's control row now carries the seat's own rewind allowance in a game that declares room.historySeconds), ctx.ray/rays(..., { atTick }) and room.poseAt(id, tick) (the pose at a tick from the snapshots the browser holds), and ctx.math (the rules' own math).room.records), the player saw an empty history and finished rounds were not recorded until they reloaded the page themselves. The page now says what it was made for, the Worker answers the frame with a stand-in when a page made now would differ, and the page does one full reload to the same room and seat. A page from before this handshake is sent to a fresh page, by the one way it has, only when the game cannot keep its results inside it. A deploy that changes only a game's code or art still reloads the frame alone.record-unsaved, and the player is told on their screen that the round was not saved and to reload.homie-studio check with no --url opened the studio's live site, and with no game the first game by name: npm run check could seat two check browsers in a live public room of a game nobody was working on. With no --url a check now runs against this studio's own build: its running dev server, or one it starts on a free port and stops afterwards. With no game it covers the games this checkout changed (against the default branch, committed or not), else every game. The live site is checked only when asked: --live, or its address in --url. port check and perf follow the same rule (the running dev server, --url, or --live).homie-studio check reaching the live site says --live now.Plugin 0.46.3
A guest who signs in keeps both histories; a rival's sounds reach the players who can hear them; a shooter's own actions answer at once; a tap moves as far as it was held; a client cannot stretch its own lag compensation.
mergeSaves({ '<game>': { saves: { '<key or prefix*>': rule }, stats: { … } } }) from @homie-rocks/studio/worker: how a guest's saves combine with an account's when the guest signs in to an account that already has the same key. Rules: 'account', 'guest', 'newer', 'larger', 'smaller', 'sum', 'union' (a list joined by id), or the game's own function, run on the server. It happens once, in the sign-in's own transaction, guarded against a room writing a result at the same moment. The sign-in response says what was merged, moved and kept (adopted), and a key no rule could combine reaches the game's onConflict with the guest's value (saves/SAVES.md, "When a guest signs in to their account").world.emit(effect, at, data, { within: metres, to: id | [ids] }) sends an effect only to the players whose own body is in range or who are named; a watcher receives the ones with a range. For a sound a rival could hear or a number only the shooter may see, in place of drawing it from state the rival should not have. An effect with no audience is public and is sent as before.f.held(), an input type: the browser sends the average of the control over each tick, so a key held for part of a tick moves the body for that part. Short taps no longer travel a whole tick or two by where the tick's edges fell. An entry that reaches the server after its tick is settled on the next ticks, not counted twice.openRoom({ predict: { <kind>(me, input, ctx) { … } } }): the player's own actions predicted like their own movement (run each predicted tick and between ticks, put right by every snapshot and re-run). ctx.ghost shows a provisional entity and ctx.effect a provisional effect that the server's own then confirms (confirms: true) or the room retracts (room.on('retract', …)). A valued pulse (f.pulse()) now names the tick it was pressed on and the server acts on it in that tick; the control row says the newest pulse acted on, so a prediction holds when the pulse's own message is late (as it can be through a Gate).world.unitsLeft: the budget units the running handler may still spend, so a handler that plans can stop early.room.rewindSeconds in rules: the game's hard cap on how far a person's ray is rewound for latency (from 0 to historySeconds). Without it the cap is historySeconds, as before; 0.25 is a sensible value for a shooter.server: record was dropped, and nothing could combine the two afterwards because a browser cannot write a server: key. Two server records are now joined by id when the guest signs in, with no rule declared.appendServerRecord, at the same one read and one write).room.rewindSeconds.mergeSaves, add it to site/src/worker.mjs beside hostRules.Plugin 0.46.2
A room of hundreds has a new shape, a deploy the owner asked for is approved by the asking, and Homie paces no input of a server-hosted game.
Measured on Cloudflare with a game where every player sees about 180 others: 300 players at 20 frames a second from a home connection; 600 at 20 frames a second measured from inside Cloudflare, marginal from one home connection carrying all 600; 1,000 are admitted and the room keeps its ticks, but delivery is not there yet. On the same game 0.45.0 delivered 13 frames a second at 300 and lost every player at 1,000.
room.rates in game.json: a studio's own pace on what one player may send, in messages a second by kind ({ "in": 60 }). Leave it out and there is none.lib/crowd-probe/: a Worker of its own that plays simulated players against a studio from inside Cloudflare, five a request, and lib/crowd-cloud.mjs, which adds the requests up into the report the home driver writes. A trial's tool: no studio's Worker imports it./_studio/api/room answers from that copy with its age. Measuring a room costs it nothing, and a room too busy to answer still has its last word read.g on its inputs and pings). A Gate that finds a player more than a second behind sends that player fewer, fresher frames, down to one a second, and restores the rate when they have caught up. Each frame is a change from the last one sent and carries the player's own body. A client that says nothing is sent every tick, as before.view.precisionM (near bodies) or half the distance it covers between view.farHz refreshes (far ones). On the crowd-circuit game at 1,000 players a frame falls from 71 rows to 20, a player from 14.8 KB a second on the wire to 6.3, and a far body is drawn 3 cm from the truth on average where it was 35 cm. A game page built before 0.46.2 is sent every moving body, as before.CONCENTRATOR binding stays declared and unused, so an upgrade needs no migration.lib/crowd-load.mjs plays a crowd from your computer and lib/crowd-probe/ from inside Cloudflare. lib/crowd-probe/README.md has the commands and how to delete the probe afterwards.docs/crowd-transport-0462.md.Big rooms: the room runs the rules, its Gates do the rest.
Plugin 0.46.0
Keep a world and its account characters across restarts.
room.lifetime: "persistent" retains a room across empty periods, restarts and compatible builds. State fields declared { durable: true } are written the moment they change, as one small journal record committed before that tick is published, exactly once across a crash. The rest of the room is checkpointed every room.durability.movementSeconds (30 by default for a lasting world) and on pause or an orderly stop; a restore is the last checkpoint plus the journal, so value is never lost or repeated though positions may rewind a moment. A room where nothing changes writes nothing. Storage failures stop play and retain committed state.room.characters: true keeps one character per game on the existing signed-in player account. Rules read player.character on join and write its inventory through declared entity fields. A durable lease and return outbox prevent two rooms holding the character at once. Explicit world.finish() resets retain the latest account character instead of replaying its old inventory. No manual provisioning.offline: false so practice cannot look like a durable session. An explicit offline: true still allows unsaved local practice.room.durability.movementSeconds defaults to 30 when lifetime is "persistent"; it is still 1 for every other room. In a lasting world an undeclared field, a position or an undeclared non-player entity can come back up to that many seconds old after a crash: declare what must not.0020_function_meta.sql migration preserves refund IDs and delivery behavior.Plugin 0.45.3
Run richer server-authoritative combat, admission and bots with shared collision queries.
rayAll hits, named hit regions, projectile profiles, immutable query scenes and scratch movement queries.f.pulse() carries a nonzero byte action once over the reliable input-event channel. Use it for weapon selection; ordinary sampled fields must not carry one-frame actions.owner, server and results. Per-recipient projections also apply to welcome, watching and reconnect snapshots. Private-delivery deltas refer to a keyframe so packet loss cannot leave moving actors at stale poses.navigation graphs validate once at compilation, avoiding repeated graph-validation charges in bot handlers while retaining live obstacle checks and full searches.collider.fields, and geometry revisions are sent only when changed relative to the snapshot baseline.label, dispatch, rayAll, rays and restart remain legal ordinary property and destructuring names. Guarding capability calls does not reserve these data names.body.terrain: 'exact' and ray option terrain: 'exact' opt into the new algorithm and cost. Seeded compatibility tests pin old results and costs.sweep(body, delta, {ground:false}) skips redundant support work when the mover explicitly computes grounding. Default sweep behavior is unchanged. Exact terrain casts reject irrelevant support features early, reuse face-entry calculations and cache identical immutable queries within a handler. Ten thousand seeded exact casts pin zero result drift through the face optimization. Near-first tile traversal cuts charged work by 30% across 2,000 seeded dense-terrain casts; its maximum contact-component drift is 2.6e-14. These opt-in savings do not enlarge handler budgets.server: save keys are reserved for declared room records; player-owned saves use other keys. Records retain at most 100 completed rounds.Plugin 0.45.2
Give a game or app solid bodies, characters that climb steps, and a complete physics save.
@homie-rocks/physics 0.1.0 brings rigid bodies, joints, collision and trigger events, spatial queries, triangle meshes and heightfields to browsers, Node and Workers. A world can use Y-up or Z-up, and a complete save resumes the same commands exactly.node scripts/renumber-release.mjs if main advances again. Physics is optional; existing studios gain no dependency.node scripts/first-publish-private.mjs physics, then remove the private flag and update the lockfile and package contract test in a follow-up after trusted publishing is registered.@homie-rocks/walk or its gait and biped parts.Plugin 0.45.1
Crowds keep finding their way while a world changes.
@homie-rocks/nav bakes tiled walking surfaces, finds routes across slopes and links, carves obstacles, streams tiles and moves crowds at a fixed tick. It supports either up axis, seeded queries and grid paths, with matching saved-state continuation in browsers and Workers.detach() and meshes never retain discarded crowds.node scripts/renumber-release.mjs.@homie-rocks/nav@0.1.0 in a studio that needs it. Its README has the imports, storage contract, larger test commands and CPU measurements for Node and workerd, including edits and full room wakes.node scripts/first-publish-private.mjs nav, then remove the private flag and update the lockfile and package contract test in a follow-up after trusted publishing is registered.Plugin 0.45.0
Choose room sizes in the hundreds and reduce the state each phone downloads.
room.view.precisionM, nearM and farHz for distant bodies. The controlled body keeps its exact movement state.players.max without the 32-player clamp.Plugin 0.44.3
Solid terrain and indexed map queries keep large arenas within the rules budget.
base is declared. Solid tiles collide against the whole body, so capsule clearance on a slope differs from the old foot-point surface.Plugin 0.44.1
Predicted movement meets the live world, and local builds keep dev running.
collider: true or {size, enabled} field names. Movement uses ctx.world.sweep/support/overlaps; existing ctx.map.sweep includes declared colliders too. Games without colliders keep their existing snapshot shape.node_modules/@homie-rocks/studio/guides/game/ after upgrading. Older plugin sessions need an update and a new session; the installed guides are usable immediately.Plugin 0.44.0
Send each player the part of the room near their character.
room.view.radiusM in game.json. Views receive nearby entities and their own body, with compact state updates and fresh state on reconnect. Omit it to keep the whole-room view.room.each, enter and leave describe visible entities when a radius is set. Dispose of departed meshes and recreate them when they return. Rules and movement need no changes; existing starters keep their whole-room views.Plugin 0.43.0
Ask for a game and its rules run on your server.
Plugin 0.42.0
Customers and other businesses can use a studio's tools, buy its goods and services, and trigger its own functions.
wrangler.custom.json.wrangler.custom.json; apply migrations 0018 and 0019 with the other studio migrations. Functions add a Cloudflare cron for retries only when declared.Plugin 0.40.0
New 3D games keep their matches on the server and answer your controls immediately.
Plugin 0.39.0
Your studio has its own MCP server. Connect your AI with one browser approval and add tools for the work your studio does.
/mcp address. Use your existing studio account; there is no key to find or copy. Client setup and workspace policies still apply.homie-studio tool new, test it with tool call and share its code as a part. Tools can also supply prompts and signed inbound integrations; readable app records are resources.Plugin 0.39.0
Your own character answers as soon as you press, even when the room runs on the server.
screenBasis.game.json.Plugin 0.38.2
Sell game, app, music or video parts on your own studio's site, with your price and licence; another studio's AI can discover, pay for and install them.
shop connect --from-clipboard; you only handle Stripe's sign-in, verification and approval prompts. Live Base also needs your CDP facilitator credentials. The guide distinguishes this setup from the one-approval keyless default.0015_purchases.sql and 0016_purchase_facts.sql, configures private storage, and uploads and verifies paid files when you deploy. Existing shop migrations stay unchanged. Keep paid files and the seller's signing key backed up.Plugin 0.38.1
Your AI carries first setup through with defaults you can change by asking.
Plugin 0.38.0
A studio holds apps beside its games, with public player cards and a shop you can find.
apps/<id>/app.json, app new / app_make, one morphing screen with roles and parts, and a 3D welcome queue starter. Apps share game build, rooms, screen, shop, parts and standalone paths; their buttons say Open and Scan to join.dev --lan prints phone-reachable addresses.screen.shop to false to hide it; createShop().open() or .open(item) opens the same shop from your own button. Closed shops and experiences with nothing for sale show no control.Plugin 0.37.0
The build plays your rules game and names problems before you publish it.
NaN, an infinite number in a fraction or a vector, more entries than a list or a map declares, a text longer than declared. The message names the file, the line of the write and the handler, says what a live room does with the value, and how to repair it. Everything else is an info: line that never fails a build: how much was played, which handlers never ran, and how often a whole number was held to its range.homie-studio build --long-check plays eight times as much, for a release or a CI run.NaN becomes 0, a list is cut to its size, a whole number is held to its range (Infinity is the top of it, so it can stand for "never"). The build is where such a write is caught. -0 is now stored as 0, so a room divides the same way before and after a restart, and a map keeps its keys in the order they were added. The game skill's RULES.md has the table. Saved matches are written in a new form: a match saved by a build made before this change starts afresh once.room.host: "browser" to run the same rules in an elected player's browser. When that player leaves, another takes over with the saved seats, scores, round clock and AI companions. Server hosting remains the default.netplay/NETPLAY.md, section 29): the server as a host, input as steps stamped with the room's tick, explicit browser runtime output, and checkpoint handover. Nothing a game written before sends or receives has changed.Plugin 0.36.0
A tip with no minimum connects, and Stripe's own reason is shown when setup cannot finish.
Plugin 0.36.0
A shop with no Stripe key to find. You approve once in your browser, and your AI sets up the rest in your own Stripe account.
Plugin 0.35.0
A plain shop: nothing is imposed unless you write it. A shop is open to guests by default, the protective rules 0.33.0 started with are a preset you choose, and a player can put several items in a cart and pay once.
shop.add(item, quantity, amount?) and shop.checkout() build and pay for a cart; shop.buy(item) still buys one thing directly. Each line keeps the item as it was defined at the time of sale, grants exactly once, and can be refunded on its own in the office.checkoutMinutes in shop.json sets how long a checkout stays open, within Stripe's bounds of 30 to 1440 minutes.rk_) or a full secret (sk_) Stripe key. A preview you give its own database and both Stripe secrets can sell; previews normally have no database.shop init writes no policy."preset": "protective" or "preset": "adults-only". Stripe Tax and the withdrawal acknowledgement are optional too. The toolkit no longer scans your items' wording in any preset. Flood protection stays, with rates you can change.shop.json that names no preset was protective in 0.33.0 and is open in 0.34.0. To keep the account and age rules you had, write "policy": { "preset": "protective" } in shop.json. Settings you wrote yourself stay as written. The wording scans are gone in every preset."automaticTax": true. To count referrals for new players only, write "referralNewPlayersOnly": true. To keep the shorter checkout, write "checkoutMinutes": 31.0012_shop_lines.sql. It only adds: your orders become one-line orders, and nothing is removed, so the 0.33.0 Worker keeps working while you deploy and if you roll back. Until the step has run, owned items and office refunds work and checkout says which step is missing.homie-studio shop connect makes the webhook and stores the secret, or takes one you made yourself.Plugin 0.34.1
A fix for studios upgrading to 0.33.0, found by upgrading one of Homie's own.
src/rules.ts builds again. 0.33.0 treated any game with a file of that name as a game whose rules run on the server, checked it against those rules and refused the build. A game is written that way only when its game.json has a "room" object; every other game builds exactly as it did, whatever its files are called.Plugin 0.34.0
A game's rules can run on your own Cloudflare instead of in a player's browser. This is the first piece of it: the format, the server that runs it, and one example game. Your existing games are not touched.
site.twitterSite is optional.src/rules.ts, with the movement code in src/move.ts) say what is true in the game: who took which coin, every score, when a round ends. The view (src/view.ts) draws what it is told and sends what the player presses. @homie-rocks/studio/rules is the format (defineRules, defineMove, f for the type of every piece of state) and @homie-rocks/studio/rules/view is what a view uses (openRoom()).Math.sin that two machines may round differently, no state outside the declared fields). It then adds a guard, so a rule that never ends or grabs memory is stopped while the room carries on, and a room whose rules keep failing is closed and named in the log.world.ask) all behave in a server-hosted room as they do in a browser-hosted one. On a hybrid or beginner server the AI companions keep their reserved seats and their own names, and a guide in such a room follows the goals and lines in your agents.json.coin-dash, an example. Copy it with homie-studio game new <id> --from coin-dash to see the two halves. It is an example, not yet a starter the chat offers: see the upgrade notes.netplay/NETPLAY.md, section 29): the server as a host, input as steps stamped with the room's tick, and the life of such a room. Nothing a game written before sends or receives has changed.studio_request_grant and studio_grant_status are gone from the Homie MCP server.homie-studio-<version>.tgz. A studio pins the npm registry's exact version, as every studio made since 0.10.0 already does.homie-studio perf accepts a room with no browser host.site/src/worker.mjs hands the Worker the rules of its server-hosted games (site/src/rules/, written by every build and committed with the studio), and its wrangler.jsonc turns off code made from text while the Worker starts.constructor, toString and the like) is no longer taken for one of your vocabulary's. Before, an AI guide could be made to "say" such a line, which threw an error in every player's browser, in browser-hosted games too."capPerPlayerMonth": 5000 (monthly spending), "refundDays": 14 (self-service refunds), "min": 200, "max": 5000 on each tip, and "windowDays": 30, "capPerPlayer": 1000, "holdDays": 30, "minimumInvoice": 2500 inside referrals. Without them there is no monthly spending cap, no self-service refund window (buyers ask the studio), no tip range beyond provider currency units, no referral window or per-player referral cap, no hold and no minimum invoice. Older shop init wrote these amounts explicitly; hand-edited files may have omitted them. All amounts are minor units of your currency."capPerPlayerMonth": 2500.7 with the whole amount you intend, such as 2500. Every amount setting follows this rule; none is silently rounded. Decimal numeric strings remain accepted; padded strings, hexadecimal strings, lists and booleans now stop the build. Fractional days and refundDays retain their fraction, rounded to milliseconds, instead of being floored to whole days.purchaseAttemptsPerMinute is the account rate (6 by default); purchaseAttemptsPerAddressPerMinute is the separate address rate (600 by default, to allow households, schools and venues). Checkout, parent-link and parent-payment attempts have separate counts. Rotating addresses does not bypass the account rate. Referral statements retain a global rate of 30 per minute as well as 30 per address; both are settings in the site configuration; invalid values produce a named error. New guest buyers have a configurable address rate, guestBuyersPerAddressPerHour, defaulting to 600 an hour so venues and schools can share a connection; guest buyers and ordinary new players have separate counters.policy.withdrawalAcknowledgement is true in every preset; edit it only as a considered studio policy. Account and younger-player protections remain in the protective preset. policy.childAge and policy.adultAge default to 13 and 18 and can be edited.shop statements --send and the office button send all statements in one action, saving immutable pages and progress in D1. Keep the command or tab open; restart after closing to resume safely. Failed pages retry three times with backoff; persistent failures name the referrer and the rest continue. One CLI office key is renewed during a run. Signed continuation pages contain lines without repeating totals; a new statement replaces the old pages for that period and currency. Mark paid selects one currency and does not change an edition already being sent. Read-only statement views allocate no editions. Sends use Workers-compatible manual redirects and refuse every redirect response.0010_shop_reservations.sql and 0011_shop_statements.sql; missing schema reports not ready with the migration names.blurb. Three-decimal amounts using the smallest minor unit warn, without an undocumented divisible-by-ten refusal; Stripe's error is shown if it refuses them, with the failure note in the office order row. Free orders can be taken back without contacting Stripe. Stripe settlement minimums remain warnings.npm install in it fails until it is upgraded. Run npx -y @homie-rocks/studio@latest upgrade --apply, then npm install: the upgrade replaces the address with the registry's exact version. Nothing else about the studio changes.src/rules.ts builds and runs exactly as before, in a player's browser. The build says so in one line. Asking for the server on such a game ("room": { "host": "server" }) stops the build with the reason.coin-dash is offered as a starter only then.site/src/worker.mjs and the empty site/src/rules/index.mjs from homie-studio upgrade --apply (a Worker file you changed yourself is kept, and the upgrade shows the three lines to add). The next deploy writes the new wrangler.jsonc.Plugin 0.33.1
A standalone game can be put on your own iPhone or iPad with one command, and the guide says what has now been run on a real phone and corrects what an older site means for a copy.
homie-studio standalone run <game> --for ios --device builds the game for the one iPhone or iPad plugged in to your Mac, signs it for your Apple team, installs it over the cable, starts it, and then looks for it among the phone's running programs. It says the game is running only when it found it there. In chat it is game_standalone with device: true.--device is your yes to what that changes outside your computer. It adds the phone to your Apple team's list of development devices (a team may register a limited number a year, and a device stays on the list until the membership year renews) and lets Xcode make a development profile for the app. The app is signed for that phone only: a build to try, never one for the store.HOMIE_APPLE_TEAM, else the one team among your keychain's development identities; it says which it used. With none, or more than one, it stops and asks for HOMIE_APPLE_TEAM.setup status and standalone plan have a row for a phone to try a build on: which model is connected and whether its Developer Mode is on, or "could not check".--device for an Android phone yet: standalone run <game> --for android hands over to Capacitor, which asks which phone or emulator. That has been run on an emulator only.Plugin 0.33.0
A game can now be an app of its own: a desktop app for macOS, Windows and Linux and a phone app for iOS and Android, the same web game in a thin shell that still plays through your studio's own site.
homie-studio standalone build <game> makes the game you already have into a desktop app (Electron) for macOS, Windows and Linux, and a phone app (Capacitor) for iOS and Android. The app shows the same files your site serves, so the game is not ported or rewritten. It finds its rooms on your studio's own deployed site, so a player in the app and a player in a browser meet in the same room; with no connection it plays offline with its bots. In chat it is the game_standalone tool, and the plugin has a standalone skill.standalone/STANDALONE.md has the whole list, and what each store asks before you pay it anything.standalone plan <game> says, before anything is built or downloaded: which of the five this computer can build, what each of the others needs and how to get it, the address that will be built into every copy, and what a standalone copy does not have. It changes nothing. A row says "ok" only for what it looked at: a signing name in the environment is "set, checked later", and a keychain it could not read is "could not check".standalone ci <game> writes a GitHub workflow that builds all five on GitHub's own Windows, Linux and macOS machines when you start it by hand, for a target your computer cannot make. Its macOS and iOS builds are never releases: it has no Apple certificate.standalone steam <game> writes Steam's build file from the App ID and Depot IDs in game.json, prints the one steamcmd command to run yourself, and says the launch options to set in Steamworks (the Linux one needs --no-sandbox). standalone run <game> starts the built copy here.--release) is signed from environment variables you set yourself, never from a file or the chat: HOMIE_APPLE_IDENTITY and HOMIE_APPLE_NOTARY_PROFILE for macOS, HOMIE_APPLE_TEAM for iOS, and the four HOMIE_ANDROID_* for Android. Only the one tool that signs is given them. A macOS app is called notarized only when Apple's own tool confirms it on the finished app, and an Android bundle is called signed only when its signature is read back from it. A release and a build to try are kept in separate folders."standalone" block in a game's game.json: the app's id, version, build number, how a phone holds it, its icon, and Steam's numbers. With no icon the app wears the game's cover, or a tile with its first letter.homie-studio deploy and deploy --plan say when a deploy makes a different netplay version live than the standalone copies you built, and what that means for them.setup status lists what the standalone builds need (Xcode with its iOS platform, the Android SDK with its platform, a JDK, signing) in a studio where a game has a "standalone" block.HOMIE_NET.app): its lines about a newer version read "A new version is out. Update the app to play online." and a tap on one reloads nothing, because a reload cannot bring a newer build to an app. Nothing on the wire changed, and a game on the web behaves as before.game.json ("netplay": { "version": "1" }) and raise it with every change an older copy cannot play with. Older copies then keep playing with each other, and say "Update <Name> to play online with everyone." when they meet a newer one..studio/ folder, which is not committed. @homie-rocks/studio itself gained no dependency.Plugin 0.32.1
Fixes from two creators' notes on 0.31.0: Homie's holds run in Grok, publish --before publishes nothing, a page that loses its room is never stuck, a missing setting is never a silent zero, and a part's preview fits a phone.
@homie-rocks/camera/heading.js (camera 0.2.1): headingFrom({ zero: '+x', toward: '+z' }) converts your game's own heading into the camera's and back, and headingOfVector(dx, dz) does it from a forward vector. The package now says plainly which way its heading points (yaw 0 faces +Z, a positive yaw turns toward +X, in radians), with a picture in the README and in the types. In development the follow camera warns once when the subject keeps travelling one way while its heading says another, and names the adapter; mark reversing frames with reversing: true, or turn it off with followState({ headingCheck: false }).net.prefs.number, net.prefs.boolean and net.prefs.string read a setting with your fallback for a missing key, a null, a wrong type or a read before the prefs arrived, and say so once in the console. net.prefs.set refuses a NaN or anything else that would be kept as null.createRoom({ fallback }), seat or solo: 'solo' plays a private round with bots until the room has a body for the player, 'spectate' watches, and room.standing says where the player stands. NETPLAY.md section 28 is the recipe, and the late-join checklist has the slow-boot, mid-round join."aspect": "4:3" and, for phones, "phoneAspect": "3:4" in preview (whole numbers 1 to 32, no flatter than 3:1, no taller than 1:2; 16:9 if you say nothing). Every part preview has an "Open the preview" link that shows it in a tab of its own.deploy --own-route). When the routes cannot be read, it says so rather than saying all is well.setup status --client grok says whether the holds ran and how to turn them on.publish --before publishes nothing. It asks the directory whether you are listed and how many publishes are left today. In 0.31.0 the command line ignored the flag and published.deploy --dry-run was one such flag: it used to deploy.reconnectMaxMs) it plays on its own with bots, says so, and rejoins when the room answers. The line over the game says what is true: "Reconnecting…" only to a page that was connected, and a full room is said in words with a way to another room.grok plugin install homie-rocks/homie#plugins/homie --trust. From then on a deploy, a Cloudflare change and a paid call are held for your "proceed", as in Codex.publish --before from its own command line until it upgrades.net.prefs.get, move numbers to net.prefs.number(key, fallback): a null kept by an older build is now read as nothing kept.@homie-rocks/camera is 0.2.1.Plugin 0.32.0
Fixes from two creators' logs of building real studios: games now build on each other by sharing parts (remix is retired), a slow 3D game keeps its host, local play stays local, and synthesized bass plays at its written pitch.
parts_find looks for pieces other studios shared, part_add brings one into your studio (every file checked, the original credited, yours to tune from then on), part_new lifts a piece out of one of your games (the game still builds and plays the same), and part_share shares it under a licence you pick. A part is private until you share it, and live after your next deploy. Your studio lists what it shares at /.well-known/homie-parts.json; homie.rocks lists the shared parts of listed studios at /parts/. The packages a part builds on are installed by npm. The design is parts/PARTS.md.homie-studio preview <id>: one built game's files at an address on this computer, with no Wrangler and no rooms, for a capture or a script.homie-studio shoot <id>: a two-browser seat check, then frames taken on a stepped clock, so a 3D game can be captured without a GPU.homie-studio trailer <id>: films a game frame by frame on a virtual clock, rebuilds its sound from the game's own files, picks the shots from what the game played, and delivers 16:9, 1:1 and 9:16. Sound that does not go through the sound player (live-synthesized voices, speech) is not in the mix, and the result says so.homie-studio build --types checks your games' TypeScript before building. New studios come with TypeScript; an older one runs npm install --save-dev typescript.await import(): it becomes a file that loads when asked for, so a 3D game can load its later scenes late.netplay: stallMs (how long a host may go quiet, 1.5 to 10 s), version (after a deploy, old tabs and new tabs no longer share a room; an old tab is told to reload at its round's break), and params (your own names passed from /play?… to the game as net.params; debug and q always pass).net.link and a "Reconnecting…" line over the game say when a game is cut off from its room. net.offline and net.connected are documented against it, and net.reconnects counts.net.prefs keeps a game's settings and personal bests (16 KB a game). localStorage throws inside the game's frame on purpose, and the docs now say why.createRoom({ admit }) chooses which body a newcomer takes, for fresh joins and for a room revived from its checkpoint alike; createRoom({ ties: 'shared' }) gives equal scores the same place; features lets a host turn a new mechanic on only when every player's build has it. NETPLAY.md has a rollout recipe for changing a game's rules while rooms are open, and a late-join checklist that includes "everyone leaves, then a new visitor enters before the room expires".guardGestures() for a touch game: a long press never selects text or raises copy and paste. The play page and its frame refuse selection too. Try it on a real phone; a harness cannot.net.shell tells a game where the play page's own buttons sit, so a HUD stays clear of them.playtest.primary (a key or the mouse on a computer; a control or a region on a phone), and "scoring": "together" for a cooperative game."site": { "order": [...] } sets the order of your games everywhere they are listed. A Home of your own takes the generated hero with <!-- homie:home-hero -->."assets": { "budgets": { "triangles", "bytes" } }, read by the game, by assets check and by assets add.assets use <game> <asset> unused marks a file the game no longer draws. The lineup draws the inventory, the cast and the environment separately.collision_bake (in chat; homie-studio collision bake <game> <model.glb>) turns a model into something figures can stand on, tied to the model by a checksum; collision_check fails when the model changed since, or a bot cannot walk a route you authored. It uses @homie-rocks/heightfield, which your AI installs in the studio the first time.assets add --lo 0.2 also writes <asset>_lo.glb, the cheap copy for the far band of a prop drawn at two levels of detail.homie-studio shoot <id> --preview takes pictures of the built game with no site running, and names the build they are of.models.mjs import), and tells a missing local key apart from a connector's sign-in.@homie-rocks/camera); quality tiers, dynamic resolution that undoes a drop that did not help, and near/far instanced props (@homie-rocks/render); a ready-made post stack per tier (@homie-rocks/postfx); combo, hit-stop and bursts (@homie-rocks/fx); a per-sound limiter (@homie-rocks/audio); buildings with floors, doors and stairs, routes checked the way bots walk them, markers on every level, and grounded capture positions (@homie-rocks/heightfield); five bot personas and host-owned power-ups whose timers survive a host change (@homie-rocks/studio/personas, /powerups).game remix, the game_remix tool, the "Make a game like this" band, the office's Remixable switch and the Studio pane's Remix button are gone, and a studio no longer serves a game's source (its old address answers 410 and points to /parts/). A game that was a remix keeps its credit, "Based on <game> by <studio>"./.well-known/homie-studio.json.site/dist, so anything running from it keeps its files.dev keeps rooms local even when the studio has a custom domain: production routes are left out of the local configuration, and dev stops with a clear reason if a game would be handed a socket anywhere but this computer. A wrapper script is no longer needed for that.deploy keeps your custom-domain and exact-host routes, refuses to deploy a wildcard or catch-all route, and says which route to add when another Worker's wildcard answers your domain first. Only one deploy of a studio runs at a time.assets check calls its scene numbers an inventory estimate and lists what it cannot see without running the game. "First play" is now "shipped payload": the same number and budget, honestly named (firstPlayMB still works). perf reports what was really fetched before play and, when your game exposes them, the renderer's draw calls and triangles.check, perf, shoot, port check and the playtest say the same sentence when this computer cannot look a site up. perf reports the arrival mode and when the game itself said it was ready, and the playtest reports a HUD element sitting under one of the play page's own controls.publish says how many publishes are left today, and listing a studio again after a deploy is a re-read that does not count against the day.dev carry a time (--timestamps for every line).hero/wide.jpg (16:9), hero/tall.jpg (9:16), and wide.mp4 / tall.mp4.midi. A2 was written as 110 Hz and played as MIDI note 110 (4.7 kHz); the kick, the tom and several effects had the same fault. They sound different now: as written.homie-studio build and leaves the built site as it was.connectOpenMaxMs) or start the wait itself (net.start()).onTakeover, adopt). A player who joins while the host is briefly disconnected gets a body. A returning player's score is no longer reset.dev and dev --stop clean up after a server that was stopped another way, and a game added while dev runs is picked up."inGame": { "maps": "base" }) and leave the estimate.anim plan and anim preview show the ground speed each character's walk and run cover on its own rig.net.playable() that arrives after the automatic arrival warns: pass arrival: 'game'."remix", "share", landing.make and the licence words remix-with-credit, remix-freely and no-remix. The build says so once; delete them when convenient. Leave "remixOf" in a game that was a remix: it is the credit. Nothing is removed from your database."license" is now the SPDX licence it names for itself ("MIT"), shown in its credits.move row BLOCKED where it used to pass silently.@homie-rocks/camera, render, postfx, fx, audio and heightfield 0.2.0.Plugin 0.31.2
Fixes from first runs in Codex and Grok: a missing connector no longer stops a new studio, you are told when Homie's holds are off (in Grok they are), Grok has an install command, and a one-sentence studio gives you a Play link before it polishes.
homie-studio setup status --client codex (or --client grok) has a row, Homie's holds: on when the plugin's hooks ran in that app in the last ten minutes, off otherwise, with how to turn them on. Codex runs no plugin's hooks until you trust them in /hooks, and says nothing when it skips them, so a session where nothing was held looked the same as one where everything was. The hooks now leave a small dated mark each time they run (in .cache/homie-studio/holds/ of your home folder: the app, the time and which hook, nothing else), and the status reads it. When the holds are off, your AI says so in its first reply and asks you itself before a deploy, a Cloudflare change, a paid call or a model download. When they are on, nothing changes. In Grok the row is off (see Fixed).homie. If your Codex or Grok configuration already has a server of that name, that one keeps the name and the plugin's tools do not load. The connector row says so and gives the command that adds Homie's connector under its own name (codex mcp add homie-rocks --url https://homie.rocks/mcp), which your AI runs only with your yes. It reads only whether your entry is an address or a command, never the command itself.grok plugin install homie-rocks/homie#plugins/homie (checked on Grok Build 1.0.41). Grok asks whether to trust the plugin, and loads its skills, its MCP server and its hooks once you do.studio-setup skill said to stop when the Homie connector was not connected. A session that can run commands does not need it. Your AI now says in one line that the connector is not connected and what it would add, and makes the studio with the toolkit's own command (npx -y @homie-rocks/studio@latest new <folder> --name "<Name>"). It stops only when it has neither the connector nor a way to run a command, and then it says how to add the connector in that app. The setup status no longer calls the connector required.AGENTS.md and the studio-setup and game skills say that a studio in a folder beside yours is somebody else's work: your AI does not read it or copy from it unless you ask. In a test, an AI read the game next door as a model for its own.studio-setup and publish skills now say that listing in the homie.rocks directory is its own step, public, and yours to ask for: your AI lists a studio when you asked for it or said yes to its offer, never as part of a deploy./plugin install homie --marketplace homie-rocks/homie (2.1.275 or later). The Claude app: a link that opens "Add custom connector" with Homie filled in, so nobody types the address.studio-setup skill tells Grok to ask you before a deploy, a Cloudflare change, a paid call, a model download or an edit to a protected file. The hooks still ship, and the status turns on by itself with a Grok that runs them.homie-studio demo answered with the arcade's standing first pick, and your AI passed on that "the lookup couldn't reach the arcade". It now gives you the link as the live game it is: your browser opens it, not the session. The answer says reached: false and no longer blames the arcade for a network the session did not have.homie-studio publish reaches by itself./hooks and trust Homie's three hooks. setup status --client codex says whether they are on.upgrade --apply brings the new lines into the Rules section of its AGENTS.md when you have not changed that section. Nothing else in a studio changes.Plugin 0.31.1
Fixes from a filmed first run in the Claude desktop app: Claude tells you once to choose Always allow and what to do when a step sits on a spinner, the deploy plan's card fills in, and a starter is changed in a few large edits instead of twenty small ones.
file_edit (Homie for Claude Desktop, and any client of homie-studio mcp) takes every change to a file in one call: edits, a list of { old, new } applied in order, all of them or none. A miss says which edit it was and leaves the file as it was. One change with old and new works as before.HOMIE_STUDIO_EXTENSION=1): in Claude Code, Codex, Grok and other MCP clients it is not true, and nothing is said.desktop/README.md and the extension's install screen say the same in a sentence.game skill, the note above every guide in homie-studio mcp, game_make and game_plan ask the AI to read a file once and make every change to it in one call. A first build spent about twenty single edits on one starter file and ran into the app's limit of tool calls in a turn, so the person had to say "keep going".setup_status takes the name of a studio that is not made yet as studio: the card and the checklist are then the new studio's.studio_deploy with plan: true answers with a plan, not a build, and the build card knew only builds. A card whose tool answered with something else (a plan, a job still running, plain words) now shows that answer; "Loading" is only for a tool that has not answered yet.homie-studio.mcpb over the one you have. A studio needs no change.Plugin 0.31.0
Grok can set up a studio and run it with the same holds as Claude Code and Codex.
homie-studio setup attach <hs_…> --client grok and homie-studio handoff <hb_…> --client grok. A Grok Bot in the studio folder checks the repository in. The directory is told the chat is Grok. Claude and Codex pass --client claude or --client codex; with no --client the words stay "the chat".plugins/homie/.grok-plugin/plugin.json, hooks/grok.json, hooks/grok.mjs). They ask hooks/lib/holds.mjs, the module the Claude Code mod and the Codex hooks already ask, so the three hold the same calls with the same words. A held call waits for your own proceed <code>. Secrets are taken out of what Grok reads.plugin.json) name plugin 0.31.0 and say the same thing. plugins/homie/test/manifests.test.mjs checks the Grok manifest with the others.Plugin 0.30.0
The Lounge: a community room on your own studio, with play nights, moderators, live rooms and "show what you made" cards, and chat history you can turn on.
"lounge": true in studio.json gives your studio a community room at /lounge/, in your studio's own look: one column of talk on a phone with "What's on" a tap away, the talk beside a sidebar on a computer. It is room chat in a room of its own, on your own Cloudflare: reactions and quick lines for anyone, typing for players signed in with a passkey (Sign in and Make a passkey are on the page itself), and every typed line through the word list and your Workers AI review (Clef) before anyone sees it. Slow mode is 3 s to start with. chat/LOUNGE.md has the whole of it.homie-studio lounge night "<title>" --at <time>. Everyone sees the time in their own zone, a countdown, "On now", the game's Play, and Add to calendar (a small .ics the browser makes)."featured": "studio" keeps it to yours, "none" shows none).homie-studio lounge mod <player id>): from the Lounge page they take a line down, mute or kick its sender for up to an hour (their lines come down with them) and set slow mode, never on your lines or another moderator's. You have the same from the page, for up to a day, and everything else in the office's new Lounge section: its rules, play nights, moderators, last lines and reports.history, a number of days, 1 to 90). In the office, "Keep what is said" for the Lounge, or homie-studio lounge history <days>; for a game, "chat": { "history": 7 } or the office. What is kept, in your studio's own D1: typed lines, quick lines, cards and your own studio lines, the name shown, when, and for a signed-in sender their account id. Never a reaction, an address or a browser key. It is deleted after that many days; keeping fewer days (or none) deletes the rest at once. The room gives kept lines back when it opens ("Earlier messages" pages further), a report still finds an older line, and a mute or kick from a kept line holds its sender's account./account/ deletes every line it kept, and the account's download has them.homie-studio lounge (rules, play nights, moderators, last lines, reports), lounge night, lounge history, lounge rules, lounge mod and lounge remove. From your AI's office key, keeping more days, opening chat up, a new moderator, a mute or a kick only ASK (your one tap); a play night, slow mode, taking a line down and keeping less happen at once./lounge/api/now: the Lounge's public facts (its rules, play nights and live rooms) as JSON, and the studio's manifest names its Lounge. homie.rocks can show a Lounge live when its rules allow it (hub): a visitor's own browser opens the Lounge's socket, as for a room's card; they react there and type on your site. The sitemap and llms.txt list the Lounge's page; robots.txt keeps its socket and APIs out.history. It is 0 for every game and for the Lounge until an owner turns it on, and always 0 on a kids server, a beginner server and a kids Lounge, so nothing changes for a studio that does nothing: a room still keeps the last 50 lines of the last 15 minutes in memory and nothing else.card, mod, kept and, on a page's own copy, mine; a page that knows none of them shows the line's words. A watching page may send unsay for its own line. The room's facts count watching pages (counts.shells). The relay stays revision 8.homie-studio upgrade adds migration 0009_studio_lounge.sql (kept chat, play nights, moderators; all empty until you use them) and npm run deploy applies it. Nothing else changes until you add "lounge": true to studio.json and deploy. A game already called lounge keeps its page, and the build says the Lounge is off.chat/OWNERS.md: it says what is kept and what that means for children's data. The Lounge's page tells people what is kept, in its "How it works".Plugin 0.29.0
Tell Homie: when something confuses you or gets in your way, Claude can offer to send the people who make Homie a short note about it. You see the note word for word first, and nothing is sent without your yes.
homie_feedback, a new tool on both Homie MCP servers (the remote one at homie.rocks, and the local homie-studio mcp in Homie for Claude Desktop), with the same name and inputs on each: - draft (the default) sends nothing. It answers with the note exactly as it would go: its kind (stuck, confusing, idea, praise or bug), the words, and what goes with them (the step or skill, the studio's and the plugin's versions, the app, and whether Claude offered it or you asked). Keys, tokens, private links, code, home folders, email addresses, network addresses and your Cloudflare account's name are taken out first, and the note says what was taken out. - send sends only the note you were shown. It names the draft, and a note whose words or details changed since then is refused. - decline records your no. - A note goes only to homie.rocks: a studio.json can name Homie's own directory or this computer, nothing else./feedback <your words> shows your note in a Tell Homie pane with Send and Don't send. /feedback alone opens the pane to write one, or puts an ask for Claude to draft one in your prompt box. The Studio pane has a Tell Homie button (t). - Every send from Claude waits for Send in Claude Code's own question, with the note's exact words. Once you have sent or declined a note in a session, Claude cannot offer another. - A note is drawn in the transcript as a framed note.proceed <code>, with the note's exact words in the hold.AGENTS.md (a new "Telling Homie" section) tell Claude when to offer: after an error it could not fix, when you sound confused or frustrated, and at the end of your first studio setup or first publish. It offers at most once a session, never makes help wait on it, and takes no for an answer.homie-studio upgrade adds the "Telling Homie" section to the studio's AGENTS.md. The tool is on the Homie MCP for every app; in Claude Code, update the plugin for /feedback and the send hold. Notes are private; homie.rocks/privacy says what is kept.Plugin 0.28.0
Search engines and AI agents read a studio's site correctly: schema.org data on every page, a full VideoGame on every landing, and a sitemap, robots.txt and llms.txt made from what is public.
Organization (its name, address, logo, share picture and tagline) and its WebSite. - Each game's landing: a VideoGame (co-typed WebApplication, as Google asks) with its description and pitch, pictures and screenshots, genre, players (fewest and most), play modes, platforms, the studio as author and publisher, the source's licence (linked to its SPDX page when it names one), what it is based on (a remix's original page, a port's original), its trailer as a VideoObject, when it came out and last changed, a Play action and a free-to-play offer. - Music: MusicRecording (the studio as the artist, its length, its audio file, its cover, its key and date) and a MusicAlbum when the music manifest names one. Videos: VideoObject (poster, upload date, length, the file itself). Posts: BlogPosting and the studio's Blog. Games and Rooms: an ItemList of the public games. Every page but Home: a BreadcrumbList./robots.txt, /sitemap.xml, /llms.txt and /llms-full.txt, made from your public catalogue: - robots.txt lets crawlers read every public page, keeps them off your office, the APIs, accounts and each game's play, TV, watch and socket doors, and names the sitemap. A Preview asks not to be crawled. - The sitemap lists Home, Games and each landing, Music, Videos, Rooms, Posts and your own pages, with dates only where a real date says when each changed. - llms.txt tells an AI agent what your studio is: each game with its pitch, players, Play, Watch and big-screen links; which games are open to remix, with the licence, the source and the words to say to Claude Code or Codex with Homie; songs, videos, posts with their feeds, your own pages, and homie.rocks's llms.txt. llms-full.txt adds each game's whole description, how to play and credits, and every post's text. - A private or invite-only game is in none of them, and a game is offered for remixing only when its source is shared, your Remixable switch is on and its licence allows it."genre" (a word, or up to three), "released" (the day it came out) and "schema" (schema.org properties of your own on the game). studio.json takes "site": { "schema": { … } } for the studio, such as "sameAs" links to its other pages. Homie's own properties always win, and ratings, reviews and offers are refused (the build says so).games/<id>/screenshots/ (or game.json landing.screenshots), at most eight, get a band on the landing and go into its VideoGame. A game's genre shows with its room facts."date" in its manifest; without one, when it was made (made.at). Search engines show no video without an upload date, so the build says when a video has neither.<!-- homie:schema --> in the <head> of a page of your own (site/pages) puts there the structured data the generated page would carry.lib/schema-check.mjs checks every JSON-LD block of a page against schema.org's own vocabulary (types, properties, which type each property is for, value kinds, enumerations) and against what Google documents as required for VideoGame, VideoObject, BreadcrumbList, ItemList, BlogPosting, Organization and MusicRecording.@graph with the page's breadcrumbs.x-robots-tag: noindex.homie-studio upgrade and a deploy bring all of it. Give each game a "genre", put a few pictures of real play in games/<id>/screenshots/, give each video a "date" if it has no made.at, and add your studio's other pages to studio.json "site": { "schema": { "sameAs": [...] } }.robots.txt, sitemap.xml, llms.txt or llms-full.txt you already keep in site/public/ still wins over the made one. A landing or Home page of your own in site/pages/ is left exactly as it is; add <!-- homie:schema --> to its <head> to give it the structured data.Plugin 0.27.1
In Codex, Homie now holds what the Claude Code mod holds: protected files, deploys, Cloudflare changes, spending past the budget and model downloads wait for your own "proceed", and secrets come out of what Codex reads.
hooks/codex.json, hooks/codex.mjs). They hold and refuse the same calls as the Claude Code mod, with the same words: - Held: an edit to a file studio.json "protect" lists (an apply_patch, with its diff), a production deploy, a change to the studio's Cloudflare account outside its deploy (Wrangler or Cloudflare's MCP servers), a paid fal, ElevenLabs or Tripo call past the budget or whose cost cannot be read first, and a Clef model download. - Refused: a change to a locked art decision, an unlicensed asset in a public game's deploy, a file over 5 MB under games/ into git, and a Stripe write that would hand back a webhook's signing secret. - Secrets come out of every tool result before the model reads it.proceed H7K2 to let exactly that call through once, or cancel H7K2 to refuse it. - Only your own message counts; the model cannot answer for you. - In codex exec, codex exec resume <session> "proceed H7K2" answers a hold.node hooks/codex.mjs check -- <command> says what Homie would do with a command, and runs nothing.hooks/lib/holds.mjs. The Claude Code mod and the Codex hooks both ask it, so the two cannot drift. The mod holds exactly what it held before, with the same words.plugin.json no longer declares the Agent Plugins $schema. Codex 0.156.1 to 0.160.0 read a root manifest only when it declares that schema, and then run none of the plugin's hooks. Codex now reads .codex-plugin/plugin.json, which names the hooks, the skills and the Homie MCP server./hooks and trust Homie's three hooks. Until then nothing is held in Codex, and codex exec skips untrusted hooks without a word.Plugin 0.27.0
A game's first minute: Play never opens on a blank screen, a bright game gets a bright landing in its own palette, and in Hero Rush 3D a new player's first round is a race they are in.
landing.controls. It is drawn in the game's palette (style.json), else its landing's colours, else the studio's, and it fades the moment the game is playable. ?arrive=0 leaves it out.net.playable() (createNetplay({ arrival: 'game' })), with net.loading(fraction, 'the heroes') for the progress line. Nothing crosses the relay; the wire stays revision 8.homie-studio perf measures the time to the first meaningful frame (load.look: the arrival card on the screen), and its time to playable waits for the card to lift. The perf skill's goals include it ("it opens on a blank screen").landing.scheme or landing.theme of its own gets its landing in that palette: its paper as the page, its ink as the words, its accents, light or dark as its paper is, when the ink reads on the paper (4.5:1). Its footage keeps its colour, and the words sit on a soft panel of its paper. A bright game is no longer shown on the studio's dark page. A scheme or colours the owner set, a page of the studio's own and site/theme.css still win; a game without a style.json keeps the studio's look.arrival: 'game': the card lifts on your own hero in its real model, never a stand-in. Your own hero is asked for first, the moment your seat is known, then the other heroes, then the skeletons (on an emulated slow phone your real hero is drawn at about 1.4 s instead of 2.1 s, the same bytes), the in-game title card is gone (the arrival card has the title), the "×2" mark moves off your hero and the controls hint sits above the touch buttons.homie-studio upgrade brings the arrival card to every game, and a game built before 0.26.0 lifts it once it has a seat. A game whose world keeps loading after its first state can say when it is ready: createNetplay({ …, arrival: 'game' }), net.loading(p, 'what') while it loads, and net.playable() once its world and the player's own body are drawn. A game made from Hero Rush 3D before 0.26.0 keeps its own code: tell Claude "bring the starter's first-round bots and phone camera into my game" if you want them.Plugin 0.26.0
Animated characters for 3D games: free CC0 heroes or one generated and auto-rigged on your fal account, on one skeleton standard with the library's clips retargeted onto it, and a shared player that runs, jumps and swings with IK feet and springs.
lib/rig.mjs): a humanoid family with VRM 1.0 bone names, a mini family for one-piece limbs (Kenney's mini and blocky characters), a quadruped and a rigid "parts" family. A rig from Mixamo, KayKit, Blender, Unreal or Meshy is mapped onto it by name and by its hierarchy, and recorded with a skeleton id (humanoid-3fa2c1): characters with the same skeleton share one clip library.homie-studio assets add takes animated characters from the free library (KayKit's adventurers and skeletons, Kenney's mini and blocky characters, all CC0) and --file <model> --kind character --rigged for your own. The shipped character is phone-sized: joints renamed to the standard, helper bones dropped, skinned parts and the accessories you keep (--keep sword,shield) merged into one draw call, its clips moved out.public/anims/<skeleton>.glb holds one clip per verb (idle, walk, run, jump, fall, land, attack, cast, hit, die, ...), 30 frames a second, compressed, with where each clip came from. Clips are retargeted at build time from the library's CC0 sources onto any humanoid or mini skeleton (rest-pose alignment per bone, hips scaled by leg height, loops kept in place).homie-studio cast <id>: the characters, with their proportions, silhouette, palette, skeleton family and clips. homie-studio anim plan|add|preview <id>: each character's clips against the verbs the game needs, more verbs retargeted on, and looping previews (animated WebP) with a sheet.@homie-rocks/studio/animate: one shared three.js AnimationMixer player. loadCharacter finds a character's clip library from the model; createCharacter blends idle, walk and run by speed, plays upper-body actions while running, an additive hit flinch and hit-stop, jump, fall and land with squash and stretch on a spring, lean into turns, look-at, springs and two-bone IK feet, and a cheaper crowd mode past a dozen characters. ANIM_TUNING is what the Game Lab tunes.hero-rush-3d: knights, mages, rogues and barbarians race for coins in a clearing, jump, dodge and swing at each other, on a phone (Jump and Swing buttons) and a computer, multiplayer with skeleton bots in empty seats. Each round opens on a close-up of your own hero that pulls back to play, and the Game Lab has takes for the jump and the swing.character command makes an A-pose concept in the game's style (--like a library character's thumbnail), then Meshy 7.1 image-to-3D with its auto-rig (about US$1.40 with textures and the rig), then free: made phone-sized, mapped to the standard and given the library's clips. Both calls have receipts under the budget.cast_plan (the cast card), character_make (the lineup with a character beside the others), anim_plan, anim_add and anim_preview (an Animation card of looping clips: Add is free, Feel opens the Game Lab on that move, New against Today).animate skill: the skeleton standard, retargeting, clip rights (KayKit and Kenney CC0; Quaternius's own licence since 2026-08-28 is not CC0 and is not used; text-to-motion models are not offered, because the ones available are non-commercial in effect)./cast and /clips, and the Studio pane's Art tab shows the characters (skeleton, bones, clips) and the skinning cost on a phone.assets check checks skinned meshes: more than four bone influences per vertex, a character without its clip library or missing a verb the game needs, clip libraries over 1 MB (3 MB is a problem) or over 30 frames a second, and the skinning cost of every player's character at once against a phone's budget (skinned vertices and bones), with crowd mode past twelve characters.style init on a starter keeps what the starter already draws (its style.json: render, palette, materials, light, camera, fonts) as the automatic picks, and the clip decision lists the clips the game has.Plugin 0.25.5
Room chat keeps off your game's HUD: on a phone the Chat pill is a round icon, as the room button is, and your game can say where the strip of new lines sits, or keep new lines in the Chat sheet, so a game with a busy HUD keeps typed chat.
"screen": { "chat": … } says where room chat's strip of new lines sits on each screen: at (a corner, top-center or bottom-center), x / y to move it in from its side and its edge, and "lines": "sheet-only" to keep new lines in the Chat sheet while the pill counts them. desk, phone, sideways and tv (the big screen's corner of lines) each take their own, changing only what they name. A game whose HUD or controls sit where the strip shows no longer has to keep chat to emoji to stay clear. chat/CHAT.md has every field; the template's AGENTS.md and the game skill say when to use it.homie-studio build warns about a wrong field in screen.chat (the play page uses the default there), and says so when a place or "sheet-only" is written in game.json "chat" (the room's rules) instead.screen.share "label": false), it is a round icon with the count of new lines on its corner. On a computer it still says "Chat", unless the word would take the room button's band off the screen or into the middle third of its width, where games keep a clock or a title; then it stays the icon until the window changes size.screen.chat shows the strip where it did. If you kept a game's chat to emoji only so the strip stayed off its HUD, tell Claude: "Put room chat where my game has room, and let players type again." It places the strip with screen.chat and resets the game's chat rules (homie-studio chat rules <game> --reset).Plugin 0.25.4
Your AI guides think with Cloudflare's Clef decision model, which does what a player asks; Clef runs on your own computer while you build; and your games can ask it for their own decisions (tactics, a director's call, a turn) in about a quarter of a second.
@cf/cloudflare/clef-flash, Cloudflare's open-source decision model (Apache 2.0). It never writes text: each decision is asked as typed Choices of your agents.json (which goal, which quest or place or player, which line or none), and its answer is checked by the same rules as before. On 64 recorded Ember Vale moments it did what an open ask asked 36 times out of 40 by itself (the old Llama 3.1 8B: 0 of 40), and blind judges preferred its decisions in 51 of 64 (Llama's in none). In a live room it answered all 9 asks itself.homie-studio agents try <game> --view <file.json> [--ask ask_help:quest=king-slime --from 0] [--model <id>]: what your guides' brain would decide in one moment, with no seat taken: the decision, the brain's own pick before the fixed rules, how sure it was, how long it took and what it cost. Use it to test an agents.json or to compare a model before setting it.clef-flash on this computer, homie-studio dev runs the guides, chat review and your game's decisions on it: free, nothing sent to Cloudflare (--no-local-ai turns it off). homie-studio agents sit <game> --brain local (the MCP's agent_sit { brain: "local" }) seats a guide that thinks on your computer every few seconds. setup status has a "Clef on this computer" row. Nothing ever downloads the model by itself: ollama pull clef-flash is about 11 GB, and it is your call.net.decide(state, questions, { floor }) on the host, for a game whose game.json says "decide": true. Ask a Choice (2 to 26 options), a yes/no or a Score about your game's state; the room asks Clef and answers with option ids and numbers, within the same daily budget as the guides, at most one ask every 3 s per room. It always answers: with your own floor when there is no AI, no budget, or no answer in time. Measured: about a quarter of a second there and back, about 4 neurons for three questions. Ask per beat or per turn, never per frame."decide": true in its game.json): every 6 s the slimes' director picks how they hunt (rush, surround, gang up on the most hurt, regroup at the King), whether a wave comes and how hard to push, and every screen shows what the slimes are up to. On a kids server they never gang up on the most hurt and never push past steady.HOMIE_BRAIN_MODEL to @cf/meta/llama-3.1-8b-instruct-fp8-fast in wrangler.jsonc to keep the old model.npm run deploy after upgrading: guides on Workers AI switch to Clef at their next decision. Nothing else to do.ollama pull clef-flash; then npm run dev.Plugin 0.25.3
Set up your shop with Stripe's own tools for AI: your AI makes the products, checks tax, makes the webhook and answers "how are sales?"; you make the account, approve Stripe's pages and paste one key.
npm install -g @stripe/cli@latest && stripe agent setup: Stripe's own MCP server and skills for Claude Code and Codex, or Stripe's connector in the Claude app). It is set up when your studio starts selling, never before: setup status shows a Stripe row once shop.json exists. You sign in once on Stripe's page and give it a sandbox first.homie-studio shop catalog: your items as Products in Stripe, made by your AI through Stripe's MCP. It names the one read to make, then (--have <Stripe's answer>) exactly the writes still needed: a Product per item with a tax code eligible for Managed Payments and a default Price of shop.json's amount. A new price becomes a new default Price; an item you removed is archived, never deleted; products you made yourself are never touched. In sync, shop.json records "catalog": ["test"] and checkouts name each item's Product, so Stripe's Dashboard and reports see sales by product. shop.json's price is still what is charged.homie-studio shop connect now makes the webhook itself: you paste one restricted key (with Webhook Endpoints: Write added to its permissions), the page makes the endpoint with it, and Stripe's signing secret goes straight to your Worker without anyone seeing it. An older endpoint the kit made for the same address is turned off, not deleted. A key without that permission still works with a webhook secret you made yourself.homie-studio setup --via stripe-projects [--with elevenlabs] (a prototype): for a creator with no Cloudflare account, Stripe Projects makes or links one (and ElevenLabs) on their own Stripe sign-in, on free plans. It stops at each step that is yours (Stripe's sign-in, the providers' terms, Cloudflare's approval page), puts the account id in studio.json, keeps the token in Projects' vault and its git-ignored .env, and every Wrangler run in the studio uses it. npx wrangler login stays the default.whsec_…) out of tool output, as it does Stripe keys.providers.json lists Stripe: its agent plugin and MCP server for the shop skill, and Stripe Projects for studio-setup. The shop skill declares Stripe's MCP server for Codex. The Homie mod holds stripe projects upgrade, billing add / billing update and anything with --confirm-paid-service as paid calls whose cost cannot be read first..gitignore also keeps .env.*, .projects/vault/ and .projects/cache/ out of git; upgrade adds them to yours.homie-studio shop connect again. Afterwards you can set that permission back to None.Plugin 0.25.2
Homie's skills work through each provider's own CLI, plugin and MCP server, declared so they load only when a skill needs them, and the Homie mod holds the paid calls and Cloudflare changes those tools can make.
providers.json in the plugin: each provider's own CLI, plugin, MCP servers and skills, the skills that use them, and what stays Homie's (budgets and receipts, the kids rules, secrets never in the chat, the owner's one-tap asks, phone budgets, the rights notes). The plugin's plugin.json points at it (extensions["rocks.homie"].providers). Nothing installs by itself: a skill offers a provider's tool when the person wants what it unlocks, and the person approves the install and signs in on the provider's own page.metadata.providers, and compatibility in words: the Agent Skills fields). The art, video, models, style, publish and servers skills declare their provider's MCP server for Codex in agents/openai.yaml (fal's MCP server; Cloudflare's docs server, which needs no sign-in), so Codex can wire it when the skill is used.secret put, a version rolled out or back by hand, a migration or a writing query on the live database (--remote), and the same through Cloudflare's own MCP servers or a claude.ai Cloudflare connector (the API server's execute sending anything but a GET or a GraphQL read; a tool that deletes, updates or edits). The hold names the studio's own Worker, database or bucket when the change touches one. Creating something and reading are not held; guardDeploys: false turns it off.elevenlabs, fal api or fal run, genmedia run and tripo is held as a call whose cost cannot be read first, and so is a run on fal's, ElevenLabs' or Tripo's MCP server. Their help, dry runs, sign-ins, prices, listings and ElevenLabs' estimate_only are free.https://mcp.fal.ai/mcp-relay: the person signs in on fal's page, no key), with the commands that connect it in Claude Code and in Codex. Paid runs still go through the skills' scripts (priced, capped, receipted, resumable), never the MCP's run_model.cloudflare/skills or Claude's plugin directory; wrangler login --device where no browser can open) and says the studio's own Worker, database, storage and secrets change only through its deploy. The servers skill reads Cloudflare's model catalogue (wrangler ai models list --json) rather than memory.npx skills add elevenlabs/skills) and their hosted MCP server, which has no music tools, and prefers the CLI to a raw API call.: , which a strict YAML reader refuses.Plugin 0.25.0
Sell things in your games with your own Stripe account: a supporter pack, cosmetics, a pass, an unlock or a tip, in real money, with refunds from your office and the kids rules built in; Homie never sees the money.
shop.json at your studio's root lists what you sell (cosmetic, supporter, pass, unlock, tip), each in real money with the entitlement keys your game reads. homie-studio shop init --supporter writes a US$5 Supporter pack (a badge on the player's profile and beside their name in rooms, for a year) and SELLING.md, plain words on what selling makes you responsible for (refunds, disputes, tax, kids; not legal advice)."till": "stripe-managed". Stripe's receipt email is the receipt./api/shop/hook: Stripe's signature, within five minutes, each event once) is the only thing that marks an order paid, refunded or disputed. What a player owns is tied to their passkey account and follows them to every device.homie-studio shop connect: a page on your own computer where you paste the restricted key and the webhook secret. It says exactly what to make in Stripe, offers Managed Payments in plain words, and puts both straight into your Worker's secrets: never the chat, a file or a log. Test keys only unless --live.createShop() from @homie-rocks/studio/shop gives shop.has('skin:ember'), shop.entitlements(), shop.on('change'), shop.open(item) and shop.used(key). The play page has a store sheet (from the game, or Shop in the room sheet) that opens Stripe in a new tab while the game keeps running; on a television it shows only a code to buy on a phone.peer.badge, set by your Worker from what the account owns; a hello can never claim one), and their account page lists their purchases and badges./_studio/office/shop), and a player's own refund of an unused item within your refund window (at least 14 days). Your AI can only ask for a refund (homie-studio shop refund <order>), and you confirm it with one tap.?via= link from another site (another studio, or homie.rocks on the same terms) is remembered on a new player's first visit; a kept sale owes that referrer the rate in shop.json. homie-studio shop statements signs each referrer's monthly statement with your studio's key; the referrer checks it against your manifest and invoices you. Nothing moves through Homie.0008_studio_shop.sql: orders, entitlements, the age band, parent links, webhook events and referral books. No card, no address, no email.studio.json says "audience": "kids"."advantage": true items are not sold or counted there). shop check and every build refuse a shop.json that breaks these. A monthly cap per player (US$50 at most).homie-studio upgrade --apply, then npm run deploy applies migration 0008. Nothing is sold until you add shop.json and connect a key.Plugin 0.24.0
Room chat in every game: reactions that float up every screen, quick lines, typing where the rules allow, speech bubbles over characters, rules per game and server, moderation in your own Worker, and the owner's tools.
screen.share keeps clear of the game's HUD) and its sheet: the room's last minutes, the five reactions (fire, clap, laugh, heart, wow, in homie.rocks's order, plus up to three of the game's own), the game's quick lines, typing where the rules allow it (and why not where they do not), and Report on a line. New lines show for a moment where the status chip sits (game.json "screen": { "chat": … } moves them)./<game>/tv) shows the room's lines in a corner, and the watch page has a Chat button and panel. Measured in Chrome with four browsers in one room: a reaction is on the other screens within about 15 ms of the press locally.createBubbles and paintBubbles (beside createLabels), and the helper's net.on('say'). Gem Rush, Ember Vale and Gem Rush 3D draw what a player says over their name. Each player chooses "Show my messages over my character" and "Show chat on this screen"."chat" sets a game's defaults (off, emoji, quick lines or typing; who may type and who may react: anyone, signed in with a passkey, or members; slow mode, length, links, swears, the review, bubbles, watchers, homie.rocks), and the owner overrides them in the office or with homie-studio chat rules. A kids server and every beginner server keep chat to emoji and quick lines. By default emoji and quick lines are open to everyone and typing needs a signed-in player account.@cf/cloudflare/clef-flash), within a daily budget of 2,000 neurons (about 850 typed messages; inside the free allocation). Emoji and quick lines are never reviewed. When the review cannot answer, the word list decides alone. chat/CHAT.md says why Clef and what the alternatives cost.homie-studio chat (rules, rooms, reports), chat rules, chat remove, chat budget and chat words./api/rooms says which rooms let homie.rocks show their chat (chat: true), so homie.rocks's room cards can show a room's chat and emoji live from the room's own socket (the hub's side ships with homie.rocks). Turn it off per game or server with the hub rule.chat/OWNERS.md: a plain note for studio owners on what the chat tooling does, what is stored and for how long, and children's data (not legal advice).say and react frames up, line, react, lines, unline and held down, policy.chat, and the owner's unsay; the helper's net.say, net.sayLine, net.react, net.chatRules and on('chat' | 'say' | 'unchat' | 'held').homie-studio deploy binds Workers AI when a game lets its players type (the review), not only when an AI guide thinks with it.homie-studio dev --remote-ai works again: Wrangler's --local turned every remote binding off.homie-studio upgrade --apply (or the next deploy) adds migration 0007_studio_chat.sql: the owner's chat rules and players' reports. The chat itself is never stored."chat" or use homie-studio chat rules.Plugin 0.23.0
Your game's look as decisions you can steer and lock, a style board the engine draws for free, free CC0 3D models, props made on your own fal account, and every asset licensed and checked for phones.
homie-studio style: your game's look as about thirty decisions (render style, palette, shape, proportions, materials, light, camera, fonts, effects; the cast, its library family, scale and phone budgets; rigs and animation for later). style init <game> --prompt "…" picks each from your words, the codex and the genre, with a one-line why, and the Game Codex's Art direction tab draws them. style steer nudges one in your words ("warmer", "closer", "golden hour"), style lock freezes one for you, and the first model built on an automatic decision pins it.homie-studio style board <game>: three coherent directions, each drawn by the game's own engine (its palette, light, camera, material model, fonts and proportions, with the starter library's pieces re-tinted into its palette). Free, in about 20 seconds. Pick one, mix rows from several, steer, lock. A painted mood image per direction is optional and paid, on your own fal account, and labelled a target.style blast): every model made under it that would go stale, what remaking each would cost, and what a free palette re-tint fixes. Nothing is ever remade by itself.homie-studio assets: every model, texture and sky a game ships is recorded in games/<id>/assets/manifest.json with where it came from, each step that made it, its licence and what a remix gets. assets rights writes RIGHTS.md in plain words, credits go on the game's landing, and assets remove takes a model out with the copy the game ships.assets find "pine tree" searches it and assets add <game> <item> copies one into the game (never hot-linked). It is served from homie.rocks; HOMIE_LIBRARY points at another copy.assets add <game> --file <model> --license <kind>: your own models, checked first (a file that loads anything from an address, or is too big, is refused), made phone-sized (meshopt geometry, WebP pictures, the pivot at the bottom centre, scaled to metres) and recorded. The raw file stays in art/<slug>/raw/, which git ignores, and assets redo <game> <asset> makes it again from there for free. Unless the game's render style is pbr, models are made non-metal: metal with nothing to reflect draws black on a phone.assets check <game>: every model against phone budgets (triangles, draw calls, picture memory, the first-play download), the Khronos glTF-Validator, its licence, and whether a decision it was made under has changed. assets lineup <game> draws them side by side at true scale on a 1 m grid, with their silhouettes and how far their colours drift from the palette. The first-play download counts one file per sound (a browser fetches the .ogg or its .wav fallback, never both).@homie-rocks/studio/assets: one model loader for three.js games. It refuses unsafe or oversized files before three.js reads them, decodes meshopt, clones skinned models properly, and says in development when a model is over its budget. stylize draws a model in the game's material model and ink outline from style.json, the way the style board drew it.game new <id> --from gem-rush-3d is Gem Rush's rules drawn with three.js and dressed with models from the starter library. game new fetches them, checked by SHA-256 (the repository holds no model file), and a game you already planned keeps its decisions, its style.json and its own models. Its light, ground and materials follow the style board: faceted low-poly ground and grass in the palette's greens, every model drawn in the style's materials and outline, the gem in the palette's gold, the animals' colours pulled toward the palette, and the sun's real shadows on a computer (soft discs on a phone). The camera looks past the clearing into the woods; a phone held upright follows its player from closer and lower, so the action fills it. The game opens on a short title card with its name, and its HUD, results and name labels share one paper-and-ink look that reads in any palette. The meadow is a clearing with a campfire at its heart and a few solid rocks, bushes and a tree players move round; game.json "scoring": "together" turns the ranking into one total the room fills, for a cozy game. assets lineup draws each model at the height and in the colours the game gives it./games/<id>/assets.json, and game remix fetches every model its licence lets a remix carry, checked by SHA-256, with a grey placeholder of the same size for the rest. It adds three.js when the game needs it, and no other package by itself.style_explore, style_board, decision_set, assets_plan, assets_find, asset_add, asset_make, asset_check, asset_lineup and asset_rights, with style board, look decision, cast, lineup and rights cards.style skill (decisions, the board, locks and the blast radius) and the models skill (the starter library, your own models, and generated props: a concept in the locked style, then Tripo P1 image-to-3D, on your own fal account under a budget with a receipt per call, about US$0.54 a prop). The plan asks whether you want to steer the look and what art budget you have./look, /lock, /assets, /lineup and /rights; it refuses a hand edit to a locked decision, a deploy that ships an unlicensed model, and a commit of a big binary under games/, and holds a paid prop past the budget.games/<id>/style.json: the palette, fonts, light and camera a game draws with. Its landing takes its accents from it, and the video skill's title cards (card --game <id>) wear its palette and font.style.json), so they match its HUD.publish refuses to list a studio while a public game ships a model with no licence record, or one whose licence forbids it.check refuses a game with a binary over 5 MB committed under games/ (it belongs in R2).codex/ folder (its decisions and style board), like CODEX.md.@homie-rocks/studio now depends on three.js, @gltf-transform, meshoptimizer, sharp and the Khronos glTF-Validator (about 60 MB more in a studio's node_modules).homie-studio upgrade --apply adds the art section to AGENTS.md and .gitignore lines for raw 3D files (art/**/raw/, *.blend, *.fbx). Commit no raw model file: move any already committed into art/<slug>/raw/.assets find says so, and HOMIE_LIBRARY can point at a local copy.Plugin 0.22.0
The Homie mod for Claude Code: your studio, its rooms and a real seat in a live game beside the chat, with a look before protected files, deploys and spending, and keys kept out of what Claude reads.
/studio) opens by itself when a build starts, on a wide enough terminal. Build has the live Plan, Build, Checks, Deploy feed and the latest check frame, or a live Watch of a room of the game being built. Rooms lists who is playing and the AI players, with Watch and Join links; Announce, Mute and Kick go through the office, and Mute and Kick are only ever asked for, so you still confirm them with one tap. Games has launch states and the remix switch; Stats and Codex link to the rest. Lab shows each game's last Game Lab check (New's phases beside Today's, whether the replays match) and the lab's link while it runs./arcade). Take a real seat in a public room of a Homie game (Homie Arcade's, or your studio's own) and play it in the pane with w/a/s/d or the arrow keys while Claude works. It runs in one headless Chrome on your computer at the lowest priority, about 8 frames a second in a terminal, pauses while the pane is hidden and stops when you leave.parallel skill: each part, its last step, and the merge waiting for all of them./play, /watch [room], /rooms, /build, /codex, /deploy-status, /perf-numbers, /parts, /arcade. They print links or open a pane; nothing opens a browser."protect" (globs, such as "games/*/game.json") shows the diff and waits for Proceed or Cancel. So does a deploy (where it goes, what it creates, the commits and files since the last one, the checks) and a paid fal or ElevenLabs run that would pass studio.json "budget".homie-studio office mute <game> <room> <seat | name> [--minutes 10] [--off], asked for like office kick./config, or pluginConfigs in settings.json). Codex installs the plugin as before; it does not run plugin hooks, so there it is the skills and tools you had.homie-studio upgrade --apply adds office mute and the protect and budget lines to AGENTS.md.Plugin 0.21.0
A Game Lab: tune how one move of your game feels (a jump, a hit, a dash), your new version beside your last commit, frame by frame.
lab skill. Say "iterate on the jump", "make the hit feel punchier" or "tune the drift". Claude first teaches your game to tell the lab about that move (its phases, the numbers that shape it) without changing how it plays, and commits that. Then it proposes the change as named phases and numbers, shows it to you New beside Today, keeps only what you like, and can record a side-by-side clip to share.homie-studio lab <game>: the Game Lab, a page on your own computer. One short take of your game plays in New (your working copy, rebuilt every time a file is saved) beside Today (your last commit), on one clock, with the same presses on the same frames. Slow it to a quarter or a tenth, step a frame at a time, try 30, 15 or 12 frames a second, or switch to a phone-sized screen; the frames are the same frames at any speed.tunables.json. Press REC and play a move to make a new take; both versions get your presses.homie-studio lab check <game>: the same take with no window. How long each phase lasts in each version, the peaks of what the game tracks, whether a replay landed on exactly the same frames, a contact sheet and a still. homie-studio lab set <game> name=value writes a number into tunables.json; homie-studio lab --stop stops the lab.homie-studio mcp): game_lab opens the lab and answers with a card: a still of both versions at the move's busiest moment, their phases side by side, and Open.@homie-rocks/studio/lab: lab.tunables, lab.phase, lab.track, lab.camera, lab.overlay, lab.stage (a training dummy for one move) and lab.random (dice for sparks and shake). Every call does nothing outside the lab, so the calls stay in your game.try --measure measures a change you keep for how it feels and says what it costs, without reverting it (try on its own reverts anything that is not faster).tunables.json and a take in lab.json, which homie-studio game new copies with the game. A new studio's AGENTS.md names both files and the lab command.homie-studio game new). To tune a move of your own game, tell Claude "build a Game Lab for <the move>": it adds the lab's calls and a take, and commits that first..studio/lab/, which git already ignores.Plugin 0.20.2
Release notes: this changelog, on every GitHub release, inside the npm package, and at the top of homie-studio upgrade.
CHANGELOG.md: every release since 0.1.0, written for the people who make studios. It ships inside @homie-rocks/studio, and each GitHub release's notes are now its version's section, with the Claude Desktop extension still attached.homie-studio upgrade starts with what's new between the version your studio pins and the one you are moving to, in the plan and again after --apply: one line per version, then the upgrade notes, anything you have to do yourself. It reads the new version's own CHANGELOG.md, so it needs no network beyond npm. --json carries it as whatsNew.homie-studio mcp) says when a studio pins an older toolkit, what's new since, and what to say to see the upgrade.studio_run ["upgrade"] runs the extension's own newer toolkit when the studio is behind. It ran the studio's pinned copy, which knows nothing newer than itself, so it never offered an upgrade.npx -y @homie-rocks/studio@<version> upgrade --apply), not the studio's own older copy.@homie-rocks/studio's version must add that version's section to CHANGELOG.md (CI says exactly what to write), and a release stops before npm without one. A later edit to CHANGELOG.md alone never needs a new version.Plugin 0.20.1
The perf skill measures games whose studio Worker adds its own script to the game page, and reads whether code is minified from the code itself.
HOMIE_PERF_SERVE_WAIT_MS: how long the perf skill waits for a dev server to serve a new build (60 s by default).HOMIE_NET, say). Its "is the site serving this build?" check never passed for such a game. Now the served page must hold the build's own scripts and markup exactly and in order; any other script is the site's, and BASELINE.md and the report list it. A Worker that changes in the middle of a loop stops the loop.perf sizes tells a minified script from source by reading its code (whitespace, comments, short names), not by how well it gzips. Minified three.js bundles were told to "ship minified"; they now read as minified, with how much of them is GLSL shader source in strings.Plugin 0.20.0
A perf skill that makes a game faster one measured change at a time, and homie-studio perf to measure it.
perf skill. Say "make my game run faster on phones" or "find out why it stutters": it takes a baseline, profiles, tries one change at a time, and keeps a change only when it is faster beyond the noise and the game still passes its own check. Every try says whether the game should look and play the same, and the screenshots are compared. It ends with perf/<id>/README.md: the numbers, and the game before and after.homie-studio perf: two real Chromes (a host and a replica) in a room of their own, as a computer or an emulated phone, measuring frame times, JavaScript and main-thread time per frame, time to playable, downloads, memory and netplay traffic. Every run records how busy the computer was, and a software-rendered run is marked blocked instead of judged.perf --profile names the hottest functions by your own file and line (build --maps keeps the source map out of the site), perf compare judges a change against the noise (side-by-side runs as pairs), and perf sizes lists every built file, raw and gzipped.homie-studio upgrade --apply adds the perf/ row and the command to AGENTS.md, and .perf/ to .gitignore.Plugin 0.19.2
upgrade reads the Homie Arcade studio's own sections right, and Ember Vale shows heroes' names and spreads out their spawns.
homie-studio upgrade no longer mistakes an untouched AGENTS.md section for one you edited when the template's own words name your studio (the Commands section's "on Homie Arcade", read by the Homie Arcade studio). That studio now takes the template's newer text like every other; words you changed are still kept.createRoom gives a player who joins mid-round a free spawn spot instead of spot 0, so several heroes no longer appear on one spot. The spot is kept in the room's checkpoint.Plugin 0.19.1
Games fill a phone held upright, players' names never pile up, and doctor checks the AI guides' Workers AI model.
fitView shows the whole world where it fits (a computer, a TV) and elsewhere fills the screen and follows the player, never past the world's edge; createLabels places players' names so yours is never covered and the others never overlap or flicker.homie-studio doctor: when a server's AI guides think with Workers AI, one tiny call checks the model on your account and says plainly when it needs Workers Paid, is gone, is private or wants its licence accepted, and what to do. It never prints a token or an account id.createLabels.fitView and createLabels are in the port kit for any game to use.Plugin 0.19.0
Big songs and videos live in the studio's own R2 once it has storage, at the same addresses, and the video skill records a page while a script drives it.
media.r2Over), or that git leaves out, moves into the studio's R2: homie-studio media move [--dry-run] [--verify], and every deploy of a studio with storage does it first. Each file is uploaded, read back and checked by SHA-256 before the site stops carrying it. Your local file is never changed, and the addresses stay the same, with seeking, caching and HEAD.media list shows where each file is served from and what would move. A deploy from a checkout without the media (another computer, Workers Builds) keeps every file already moved.video.mjs record <slug> --steps steps.json): clicks, taps, drags, keys, typing, scrolling and waits, on the page or inside the game, as a computer (16:9) or a phone (9:16), with captions at each step's second. Real time and honest frames: held frames are counted, never blended.media move warns past 10 GB and refuses a file over 300 MiB.deploy moves the big files to R2; run homie-studio media move --dry-run first to see which. upgrade lists your big media and this step, and never moves a file itself.Plugin 0.18.0
AI guides that talk in your game's own words: on a beginner server they pick goals and lines from the game's vocabulary, and your own Claude can take a guide's seat.
games/<id>/agents.json, a game's vocabulary: goals, lines, and the asks a player taps ("Help me with King Slime", "No thanks"). The build checks it.agent:view and acts through agent:do. It may only say the vocabulary's lines, and only on a server whose AI may talk; the relay drops everything else, including a line a host tries to put in an AI's mouth (NETPLAY.md v1 revision 7, section 18).@homie-rocks/studio/agents (useAgents) for the host: views, a scripted floor, goals for your bot code, asks as buttons and lines rendered from the vocabulary.agent_sit, agent_look, agent_do and agent_stand (and homie-studio agents sit) seat it as "Claude · AI".agents/GUIDES.md is a short path for an existing RPG.homie-studio dev keeps guides scripted unless you pass --remote-ai. homie-studio agents brain key takes your key on a one-use page on your own computer; it is never printed or pasted into a chat.Plugin 0.17.1
Servers polish: an opaque vote card, the server pill beside the room button, and a New server form that explains itself.
Plugin 0.17.0
Servers and AI seats: named pools of rooms with their own rules, every AI seat labelled as AI, and a skill dial the party votes on.
/<game>/servers/ and a page per server; the play page's server pill, vote card and AI pills. The office manages servers, agent passes and AI levels, and anything that narrows a server is an ask you confirm with one tap.homie-studio servers, agents pass|passes|revoke|brain and office invite --server. Plugin: the servers skill.net.policy, net.skill, net.vote(), net.agents() and more in the netplay helper, all of it done by the port kit's createRoom, and a skill option for BotBrain (NETPLAY.md v1 revision 6, section 17).0006_studio_servers.sql: upgrade, deploy and dev add it.Plugin 0.16.0
Watch any player: anyone can watch a live room from any player's view, on every studio, with nothing streamed.
/<game>/watch?room=<room> shows a live room like a broadcast: a band above the game (live, the round's clock, how many are watching, Play into this room) and a dock below with each player, Auto and the whole room. Tap, or use keys 1 to 9, A, O, the arrows and F. It works on phones, computers and TV-sized screens; with no room given it finds the busiest public one./api/rooms rows carry watch; watches count in your stats, and the play page says how many are watching."watch": "overview" shows only the whole room (for hidden hands or roles), and "watch": false turns watching off. Private and invite-only games are watched only by people they let in, and a kick also keeps that browser from watching.net.watching, net.viewSeat, net.follow(), net.spotlight(), on('view') and PALETTE; the port kit adds room.viewSeat() and room.viewBody(). Gem Rush and Ember Vale follow a player.net.viewSeat (or listen for view) and draw that player's camera and HUD.Plugin 0.15.4
Remix credit and licence: a game's shared source says who made it and what its owner allows, and a remix credits its original.
"license": "remix-with-credit" (the default: a remix says "Remix of <game> by <studio>" with a link back), "remix-freely", or "no-remix" (the source can be read, and the remix flow refuses it). An SPDX id such as "MIT" can be named too.source.json carries credit and license, and a remix's game.json gets remixOf: the credit and the original's name, studio, page and licence (and its own original, for a remix of a remix).license and remixOf."license" in a game's game.json for anything else.Plugin 0.15.3
Fixes from a first full run in Claude Desktop: links are yours to open, an earlier attempt can be folded in, log lines cut cleanly, and every answer fits Claude Desktop's 1 MB limit.
studio_fold: when a folder with your studio's name already exists and is not a studio, the AI asks you first, then copies its notes into notes/earlier/<folder>/ for the plan to use; with a second yes it moves the old folder to the Trash (on a Mac). It never touches any other folder. If the name is taken in the studios folder, the new studio goes in <name>-studio.game_demo and preview_run, the AI hands you the Play link or the card's button instead of opening a browser itself (a permission prompt once sat unanswered for minutes).file_read comes back as a smaller JPEG copy (your file is never changed), and one guard trims pictures first, then text, and says what it left out.Plugin 0.15.2
Homie for Claude Desktop turns itself on as it installs.
.mcpb.Plugin 0.15.1
Rooms re-check a game's launch state as they open, the plugin gets a Codex manifest, and its skills read cleanly to skill scanners.
Three changes landed without a version of their own (#12 to #14), and #15 gave them 0.14.1. The first publish run for the 0.14.1 tag stopped before anything reached npm: #12 had also renamed a constant in @homie-rocks/render without giving render a new version, and a release refuses that. #16 put render back exactly as published, the tag was moved to that commit, and the run there published 0.14.1. The render rename did not ship; it waits for render's next version.
.codex-plugin/plugin.json) with an icon, and a plugin README and SECURITY.md, for plugin catalogs.Plugin 0.15.0
One chat: a new studio starts with no game, the toolkit runs as a local MCP server, Homie for Claude Desktop, and a one-line hand-off from a phone.
homie-studio mcp: the same tools as a local MCP server (setup, studios, games, build, preview, check, playtest, deploy, progress, files that never leave the studio, and the plugin's guides), named and shaped like the remote Homie MCP's where they overlap. studio_open clones a studio made on a phone from GitHub with the computer's own sign-in.homie-studio demo (and game_demo) points at a live game on Homie Arcade to try first.homie-studio codex new <id> starts a game with only its Game Codex; game new <id> later makes the game around it.HANDOFF.md and homie-studio handoff hb_…: "Continue building <Studio>" in a Claude Code session takes the build the chat opened.new, the Deploy to Cloudflare template and the Claude app's setup make a home that says "First game coming soon", and a starter (gem-rush, or ember-vale) is copied in only when you ask. dev and deploy work with no game.upgrade keeps two new AGENTS.md sections in the template's order (it used to swap them).upgrade --apply adds HANDOFF.md and the AGENTS.md section about continuing a build..mcpb is not signed yet, and Claude says so as it installs it.Plugin 0.14.0
The studio's back office: live rooms, kick, mute, announce, launch states and invites, and the owner recognised in their own game.
/_studio/office, the owner's private page: every live room of every game and who is in it, refreshed every 3 s. Kick (for as long as you choose), mute, announce to a room, a game or the whole studio, close a room, and per game: its launch state, remix switch, players per room and invites.private (only you), invite (an invite-only beta with XXXX-XXXX codes and links) and public (the default). A game that is not public is in no list and refuses anyone without access. Narrowing never cuts a round short: each room finishes its round, then re-gates. game.json "launch" keeps a new game private from its first deploy.net.pickPlayer(seat).homie-studio office key): it can look, announce and invite, and a kick, mute, close or launch change becomes an ask you confirm with one tap. No key can confirm.homie-studio office [link|key|announce|invite|launch|kick|close|revoke]. Plugin: the office skill.announce and mute frames, and kicked and room-closed refusals./ (the office carries an older /_studio/ one over), and the owner's passkey account from 0.12.0 counts as the owner everywhere.0005_studio_office.sql: upgrade, deploy and dev add it.say, chat or emote.Plugin 0.13.1
The toolkit works through a proxy, as in a Claude Code cloud session, a failed request says what actually failed, and the hand-off opens the studio's own repository.
HOMIE_REPO, studio.json github or the git remote, and setup attach refuses without one. deploy passes it to the Worker, which tells the directory (never in the public manifest), so a hand-off opens the session in your studio's repository.HTTPS_PROXY, as a cloud session has), the CLI uses it. Node's fetch() went around it, failed to find homie.rocks, and the session wrongly blamed its network settings.setup status no longer calls a failed request a missing connector.Plugin 0.13.0
Player accounts and cloud saves: persistent games whose characters last for days and follow a player to every device.
@homie-rocks/studio/saves (also on window.HomiePort): per player and per game, versioned, so a stale copy is a conflict and never a silent overwrite, and offline-tolerant with a local outbox. Lifetime stats, and a hall of the fallen for hardcore games (saves.fall() writes a memorial and wipes the saves in one step).homie-studio game new <id> --from ember-vale./account/: your name, passkeys, recovery email, and download or delete everything. No IP address is stored and no third-party script or cookie is used; the owner sees counts (homie-studio players), never a passkey or an email.0004_players.sql: deploy and dev add it to an older studio, and so does upgrade. account is now a reserved game id and site path."saves": true.Plugin 0.12.0
A new creator's first hour: setup status, a checklist that never jumps ahead, the Game Codex, parallel agents, and the build's progress under your prompt.
homie-studio setup status (also doctor): one checklist of Node, the Homie connector, Cloudflare (signed in, email verified), Chrome, ffmpeg, the optional GitHub, ElevenLabs and fal, and Claude Code's status line. Each row says what it unlocks and the exact fix; optional rows never block, and nothing private is printed.games/<id>/CODEX.md in plain Markdown, and homie-studio codex <id>, which draws it as a page in the game's own look (cards, controls, milestones, decisions, open questions) with a live Build status tab. --artifact makes a self-contained copy; on the site it is owner-only, at /_studio/codex/<id>/.homie-studio statusline: Claude Code's status line shows the build's stage, a bar, its checks and spend. statusline --install writes it into .claude/settings.local.json, never over one you have, and --project is for when Claude Code started in the folder above the studio.plan skill's short interview (two or three questions a message, each with a pick) becomes the Game Codex; the parallel skill offers one agent or several, with the trade-off said plainly.setup status --homie falls back to homie.rocks when what it is given is not an address.Plugin 0.11.0
A studio from the Claude app with no terminal: Deploy to Cloudflare makes it, Workers Builds deploys every push with a Preview per branch, and the site lists itself.
template/: the public Deploy to Cloudflare template, made by homie-studio new --template and checked on every pull request.WORKERS_CI=1, or --ci), npm run deploy only applies D1 migrations and deploys; it creates and writes nothing else.d1 execute. It never claims from a Preview, or when studio.json says homie.directory: false.setup attach <hs_…>, progress attach <hb_…>, progress change and progress pr --url …, so the chat's cards follow the build and say Live once the site lists the change.homie-studio chrome install: Chrome for Testing for the checks on a Linux machine with no GPU. check reports each browser's frame rate and renderer, and never judges a software frame rate.HOMIE_DIRECTORY points one build at another directory.wrangler.jsonc at the studio's root, where Workers Builds reads it, and pin the toolkit from registry.npmjs.org by exact version.global_fetch_strictly_public, so a site whose directory is on the same zone can reach it.site/wrangler.jsonc; every command finds either, and upgrade never moves it. A studio pinned to a homie.rocks tarball keeps that kind of pin when it upgrades.Plugin 0.10.0
homie-studio upgrade, which brings an older studio up to the newest template without touching what you changed, and template polish from studios moving to 0.7.0.
homie-studio upgrade [--apply] [--diff]: what this version's template adds to an existing studio (AGENTS.md sections, READMEs, .gitignore lines, D1 migrations, package.json scripts and the pin), as a plan with diffs. A file or section is replaced only when it is exactly an older template's text; anything you changed is kept, and --diff shows how it differs.screen.share places the room button per device (top-left, top-center, top-right, bottom-left, bottom-right, with offsets, or as a small icon).landing.scheme: "light", for a white or cream game's landing./__homie/* check with not-a-homie, as each game's own path already did, so a studio no longer needs a wrapper Worker for it."rooms": { "share": false }, and /api/rooms cached for 15 s.capture-game.mjs --scale renders a heavy game smaller and scales it up to the film's size.hero/wide.jpg, else a trailer's poster, else the cover). A song's cover falls back to the album's, then its game's landing still, then the studio's share picture.check waits 90 s for pages and seats, for busy computers.check on a busy computer: a browser the relay dropped for being quiet no longer fails the round. A round counts when each browser has a seat in its results, and a failure says which seat was left out, whether a browser lost its connection, and how busy the computer was.capture-game.mjs advises half size or more, and says when the computer is too busy to capture well.Plugin 0.9.0
A build you can watch: the progress feed behind the Claude app's build card.
.studio/progress/<build>.json): its stages and checks, a picture and the address to play, spend against a budget, a song's waveform, a video's shots, the latest log lines, and a Stop button.build, check, port check and deploy report into an open feed by themselves. check reports its four steps live, with pictures, and a deploy with every check green ends the build with the live Play address.homie-studio progress stage|check|spend|preview|shot|song|log|end|show for what only the AI knows, and --share so the Claude app's card can show the feed for 24 hours. The write key stays on your computer and is never printed.Plugin 0.8.0
Studio sites get the same sections as homie.rocks, and every game gets an epic landing page.
/<game>/, made from its own files: footage or its cover in the hero, the pitch, a big Play button into a public room with who is playing, the devices and join codes, how to play, credits with licences, and "Make a game like this". game.json landing sets the words, footage, credits and an accent.posts/*.md, rendered with a safe Markdown subset, with Atom and JSON feeds.site/ wins: theme.json (each new studio starts from one of eight palettes), theme.css, partials, whole pages and public files. A page can never take over the rooms, the game files or the API.homie-studio look: pictures of the site's pages on a computer, a phone and a phone turned sideways, with what is wrong on each.no-transform, and the referrer policy shares only your site's address, never a path.?room= the relay cannot use is refused with a way into a public room, never silently swapped.public/ folder is found, look judges Play only on Home and landings, a band partial that is its own <section> stands alone, and new studios keep .checks/ screenshots out of git.site/ changes.Plugin 0.6.0, then 0.7.0
Rooms of up to 32, and the studio's own stats, read only by its owner.
netplay, or netplay.json), up to 32 seats. One address may hold every seat plus four more, for a party on one Wi-Fi with a TV. The relay's caps double for rooms of 17 to 32 (NETPLAY.md revision 3).homie-studio stats, a read key, or a one-time sign-in to /_studio/stats. Nothing follows a visitor.sound skill (effects and synthesized scores made on your computer, measured, wired into the game), an art skill (covers from real frames, and fal images under a budget), a playtest skill (real browsers on a computer and a phone, then a blind review), and delivery checks for the video skill.deploy keeps the workers.dev address, which names your Cloudflare account, in .studio/local.json (ignored by git) and never in studio.json..studio/ to .gitignore. Stats need D1 migration 0002_studio_stats.sql, which deploy and dev add.Plugin 0.5.0
Song and video pages on your studio's site, with no storage needed.
/music/<slug>/ (a player, words, loops and stems to download, and the rights line) and /videos/<slug>/ (a player that plays the 9:16 cut on an upright phone, with poster, captions and credits), listed on Home, at /music/ and /videos/, and for the directory. media/MEDIA.md is the manifest contract.homie-studio media list (what the site will show, and why anything is left out) and media put (a file in R2).music skill (songs, themes and game scores with ElevenLabs Music on your own account, within a credit cap you set, with receipts) and the video skill (gameplay trailers captured from your game, and music videos from fal under a budget).music, videos and posts are reserved: they are page addresses, not game ids.Plugin 0.4.0
A studio with no credit card: deploy creates only what Cloudflare's free Workers plan gives a new account.
deploy --plan says what deploy creates and what it costs, and calls nothing. The first deploy says it again before it creates anything, and a new account's first deploy names its next step (verify the email, pick a workers.dev address).homie-studio storage add: R2 as its own later step, which stops with Cloudflare's dashboard link until the account has R2 turned on (Cloudflare asks for a payment method first).homie-studio dev --stop stops exactly this studio's dev server, and nothing else on the computer.deploy creates one Worker, one D1 database and the SQLite-backed Table and Lobby Durable Objects, and never creates or binds R2.never on npm: served only as a tarball on homie.rocks, before this repository's releases. Everything in it is also in 0.5.0.
Plugin 0.3.0
The port kit: make an existing single-player web game multiplayer.
@homie-rocks/studio/port (and window.HomiePort for static games): createRoom with bots, join in progress, rounds, host migration and snapshots; a touch kit (a floating stick, buttons, key synthesis, swipes); camera rules; a HUD; and shims that make storage, cookies and gamepads work inside the game's sandboxed frame.homie-studio port plan|import|check: grade a game (easy, medium, hard, not a fit), import it, and prove the port with real keys and touches on Android Chrome and iPhone WebKit, two browsers finishing a round, a killed host, a late joiner and the big screen.build takes static and command-built games beside bundled ones, and the site gains /<game>/tv, a big screen with a QR code into its room.port skill.Plugin 0.2.0
@homie-rocks/studio on npm, open source under Apache-2.0, in this repository.
@homie-rocks game engine packages (arcade, audio, brush, bus, camera, device, diagnostics, film, fx, geom, heightfield, input, loop, noise, postfx, props, render, scatter, scores, ui, ui-world and walk) were first published at 0.1.0 the same day, and none has needed a new version since.@homie-rocks/studio, under Apache-2.0 and on npm (0.1.0 had another name, in an npm scope Homie does not own). The plugin is Apache-2.0 too.new installs the pinned dependencies itself, and every command runs the studio's own copy (npm run …, npx --no-install homie-studio).check counts only a round that finishes after both browsers are seated and in its results, and exits even when Chrome's pipes outlive it.@homie-rocks/studio 0.2.0 instead.Plugin 0.1.0
The first studio toolkit: a studio in one folder, a multiplayer starter, and deploys to your own Cloudflare.
homie-studio new: a studio in a new or empty folder (AGENTS.md, games/, music/, videos/, posts/ and site/), listing every file it writes.build (esbuild); dev (the site and its rooms on your computer); and check (two fresh Chromes must share a room and finish a round)./.well-known/homie-studio.json.deploy through Wrangler on your own Cloudflare account, refusing any Worker, database or bucket it did not create, and publish to the homie.rocks directory.studio-setup, game and publish skills, and the remote Homie MCP.before this repository, and never on npm: served only as a tarball on homie.rocks, under the old package name, and withdrawn when 0.2.0 came out.
This page is the CHANGELOG.md inside @homie-rocks/studio 0.58.19 on npm, the same file as CHANGELOG.md on GitHub. Each GitHub release’s notes are its section, with Homie for Claude Desktop attached. Something wrong or missing? Open an issue.