From the legacy engines to ck-exec

ck-exec replaced four legacy engines of the game API, which no longer serves them: game models (containers, typed properties and functions in an expression language), automations (schedules, triggers and timers over the same functions), compute modules (studio WASM run inside the game API) and player code (grid-scoped player modules and their browser client modules, player models and automations). Their pages are gone, and an old link to one of them lands on its section here. This page maps what you used to what you use now, and links the page that explains it. For a worked example, see port a compute module.

Running your logic

Legacy	ck-exec	Page
Game-model functions (mutations, returnExpression)	Hub handlers in Rust with ckx-sdk; a hub runs one handler at a time	Overview
Container types with typed properties, visibility, edges	The hub's own types, or ckx_sdk::model for typed containers, edges and per-property visibility	Builds
Authority rules on the caller (owner_of_self, is_host, is_current_turn, …)	Checks in your handler against the caller (call.player(), call.developer())	Overview
Authority rules on platform data (tier_feature, group_permission, grid_permission)	players.features, players.check_permission, grids.check_permission	World and platform data
Compute modules (compute*)	Hubs (stateful) and spokes (stateless, scaled out)	Overview
Compute templates, engines and Game Kit blueprints	Starter packs (execStarters): world-tick, matchmaker, session, npc-mobs	Builds
Sessions (gameModelCreateSession, turns, host transfer)	A hub per session (the session starter), its state on a topic	Builds
emit_event, model_invoke, automation actions, cascades	Calls between instances (ctx.call, ctx.send) and topics (ctx.publish, ctx.subscribe)	Timers, subscriptions and presence
Expression lint and quarantine, circuit breakers	The Rust compiler and the manifest checks; a crash-looping instance is held back and placed again	Operations

Calling it from clients

Legacy	ck-exec	Page
gameModelInvoke, computeInvoke, playerComputeInvoke	execConnect, then calls over the host's WebSocket gateway	Connect from a game
CrowdyJS gameModel, compute, playerCompute; their CrowdyCPP twins	CrowdyJS client.exec, CrowdyCPP client.exec()	Connect from a game
State reads (gameModelContainerState, gameModelTraverse, session reads, events)	Endpoints that return state	Connect from a game
gameModelContainerChanged, gameModelSessionChanged	Topics a client subscribes to	Connect from a game
gameModelActivePlayerCount	The root hub hears presence and publishes the count on a topic	Timers, subscriptions and presence
The invoke limit (120 calls per 10 s per player and app)	The same numbers at the gateway, per host, refused Busy ("rate limited")	Operations

State

Legacy	ck-exec	Page
Containers and properties, committed on every invoke	Hub memory, snapshotted every 5 to 60 seconds and when it stops	Overview
Data that needed every write kept	ctx.persist_now()	Timers, subscriptions and presence
A module's state blob (state_get / state_set)	Hub memory, snapshots up to 8 MiB	Overview
user_state, avatar_state	players.state, players.set_state, players.avatar_state	World and platform data
grid_state	A hub keyed by the grid	World and platform data
gameModelSeed	The type's spawn seed in the manifest	Overview
Redeploys that change the shape of state	load(snapshot, from_version) migrates	Overview

Timers and triggers

Legacy	ck-exec	Page
Compute ticks (tickHz)	ctx.timer_every	Timers
Automation schedules: interval	ctx.timer_every	Timers
Automation schedules: cron	ctx.timer_cron with ckx_sdk::cron, the same syntax	Cron schedules
One-shot timers (gameModelScheduleInvoke, a function's timers, dedupeKey)	ctx.timer_after; the timer's name is its dedupe key	Timers
player_joined, player_left, player_count_changed	on_presence on the root hub	Presence
A player joining or leaving what they play	on_session	Sessions
function_invoked, property_changed, container_created	The hub knows when it changes; others subscribe to its topics	Subscriptions between hubs
grid_actor_changed, grid_voxel_changed	A grid's world events, delivered to its mods (on_world)	Mods
Manual runs (gameModelRunAutomation) and admin calls	execConnectAsDeveloper, then call the endpoint as a developer	Operations

World and platform data

Legacy host call	ck-exec	Page
chunk_get, voxels_list, voxel_set	world.chunk, world.voxels, world.set_voxels	World and platform data
actors_list, actors_list_radius	world.actors, world.actors_radius	World and platform data
grid_permission_check, grid_at, grid_contains, …	grids.get, grids.check_permission	World and platform data
Permission effects	permissions.grant, permissions.revoke	World and platform data
Wallets and the ledger	Not offered on ck-exec for now

Realtime

Legacy	ck-exec	Page
Function notifications, emit_spatial, emit_channel	ctx.emit_spatial, ctx.emit_channel	Realtime events
Server-driven actors (NPC and mob poses)	ctx.emit_actor, on the same wire	Realtime events
client_event from a module	Not offered: send what a client needs on a topic or as an event	Realtime events

Build and deploy

Legacy	ck-exec	Page
computeDeployVersion (compile on the server)	execBuild, then execDeploy with the build	Builds
Uploading built modules	execDeploy with the WASM	Builds
Module versions and rollback	execVersions, execActivateVersion	Operations
computeSetModuleEnabled, automation enabled, the policy kill switch	execSetEnabled for the app or one node type	Operations
The crowdy-compute CLI	execBuild and execDeploy, or from a script CrowdyJS client.exec.build and deploy. ck-exec's own CLI is not published	Deploying from a script

Operations

Legacy	ck-exec	Page
computeModuleLogs, playerComputeLogs	execLogs	Logs
Runs, stats and diagnostics	execInstances, execEndpointStats, execLogs	Operations
gameModelFlow	execLogs(flow:): every line one call chain logged	Following one call
Policy and ceilings (fuel, memory, run time, tick rate)	Manifest limits, within the platform's bounds	Overview
Metering and appComputeBudget	Per-minute usage in compute units; an enforced budget pauses the app	Usage and budgets

Player code

Legacy	ck-exec	Page
Player server modules (playerComputeDeploy, run as the grid owner)	Mods: execModBuild, execModDeploy, in the owner's own sandbox, confined to the grid	Mods
Player-code templates	The mod starter (execModStarter, the grid-mod crate)	Mods
Player client modules (browser WASM, playerComputeDeploy with the CLIENT target)	A mod's CLIENT half: one crowdy-client-sdk crate, built with execModClientBuild and attached with execModClientDeploy. Legacy client modules are not migrated: build each one again as a CLIENT half	CLIENT halves
Grid-attached client mods (gridClientMods, consentGridClientMod, trustGridAuthor, playerCodeClientArtifact)	execGridClientMods, execConsentClientMod, execTrustAuthor, execModClientArtifact; CrowdyJS ExecClientHalves runs a grid's	CLIENT halves
A server module that requires a client module (playerComputeSetRequires)	Nothing to pair: a CLIENT half belongs to its mod	Mods
Player models and player automations	A mod's own state and timers, and its grid's world events	Mods
publishPlayerCode, acquirePlayerCode, installPlayerCode, bundled listings	execModPublish, execModListings, execModInstall (no payments yet); a listing carries the mod's CLIENT half	Mods
Crowdy Studio deploying a SERVER target	The SERVER target as a mod (ck-exec, Crowdy Studio's only engine since CrowdyJS 18)	Mods
Crowdy Studio deploying a CLIENT target	The CLIENT target as that mod's CLIENT half (CrowdyJS 17.14.0)	CLIENT halves

Tools

Legacy	ck-exec
CK Studio's Compute and Automations tabs	CK Studio's ck-exec tab on the app page: status, node types, versions and rollback, instances, calls per endpoint, logs (with a flow filter)
The Unreal SDK's game models: containers and attributes, Effects, sessions, pre-seeding and their authoring in the editor	The Unreal SDK's Server Objects, which you use from Blueprint or C++: see What a Server Object is and Move from Game Models. The SDK's Game Model API is deprecated, and a later release removes it. From C++ you can also call your app's ck-exec code directly with CrowdyCPP's client.exec() (see connect from a game); engine integration describes building CrowdyCPP into an Unreal plugin