›Getting started

Docs

Everything Cudic can do, in the order you'll probably need it. Build in Studio, publish to the gallery, play with other people in real time, chat in servers, and restyle the app with theme packs. Want longer, step-by-step tutorials? The Cookbook walks you through building real games, one pasteable page at a time.

Getting started

Cudic is a place to hang out and a place to build. Servers and direct messages for chat, a gallery of games anyone can play, a Studio for making your own, theme packs that restyle the app, and coins that buy the packs. Everything runs in the browser — nothing to install, nothing to build. If you would rather follow a path than read a reference, Start here is the five-step version of this page.

  1. Sign in — email + password (we email you a short code to verify the address), GitHub, or continue as a guest to look around. Saving, publishing, coins and saved progress need an account.
  2. Open Studio — a VS Code-style workbench with a live preview. Press Ctrl+Shift+P for the command palette.
  3. Build something — write HTML/CSS/JS by hand, import existing files or a whole folder, or bring a Scratch game across.
  4. Save, then Publish — saving keeps the project in your account; publishing puts it in the gallery with its own playable page.

Install Cudic — in a desktop browser use Install, on a phone use Add to Home Screen, and Cudic opens in its own window with its own icon instead of a tab. It is the live site in a standalone frame, not an offline copy: the service worker only handles push, so every page still comes from the network and a deploy can never leave you on a stale one.

What's on Cudic

THE RAIL

One nav everywhere

Most pages share a rail on the left — Chat, Servers, Games, Themes and your account at the bottom. The rail follows whatever theme pack you've bought; these docs use their own list on the left instead.

CHAT

Servers & DMs

Public servers with channels, servers you make yourself, and private direct messages. Your servers live in the rail so switching is one click.

GAMES

The gallery

Browse, search, play, comment, like and remix. Every published game gets a permanent page with its card art and credits.

RACE

Creator race

Every unique player who plays one of your games is a point, every week. Top three bank coins and titles at /race.

THEMES

Theme packs

Full app restyles: colours, fonts, rail icons, motion and a live background scene. The landing page keeps its own look. Try any pack for free before spending coins.

Getting found

ARCADE

Every game, one page

/arcade lists every published game as real HTML with a real link per card, so search engines can follow it. The gallery loads its cards in JavaScript and shows a crawler an empty page, which is why this one exists. It is rebuilt on every deploy, so nothing needs adding by hand.

SHARE

Share cards

Every game page has Share, Post on X and Copy link. They point at /g/<slug>, which serves that game's own title, description and card art to Discord, Slack and X before a human clicks. An embedded game's "Made in Cudic" chip links back to the same page.

DAILY

One game a day

/daily picks one published game by hashing the UTC date, so everyone on a given day gets the same game and nothing needs scheduling. It carries a share card and a streak kept in the browser — no sign-up, nothing uploaded.

FIVE

Five worth five minutes

/five names five games instead of showing a grid. It reads the most-played published games, so it improves as people play and needs no curation.

MEASURE

Funnel events

GTM receives cudic_page_view, game_view, play_start, share_click, signup_start and signup_complete. After a publish, call window.cudicTrack('game_publish', { game_id }) from Studio so publishing lands in the same funnel.

Guests can play games and read chat. Progress isn't stored for a guest — the first time you play a game with saving, it offers a sign-in, and your bests attach to the account you pick.

Studio

CIDE is what the editor is called — Cudic + IDE, and the title bar's top-left corner shows Cudic's mark next to the name. Studio chrome carries the site, not VS Code's colours: the activity bar uses Cudic's dark ground and lime accent, Preview/Save/Exit sit in the top bar, and the Collab and Source Control tabs are spaced by the workbench like every other tab instead of floating over the account avatar. Those three buttons are live: they ride in the workbench's own title-bar cluster, so a click there does what it says. The Collab and Source Control panels are overlays on the sidebar, so selecting Explorer, Search or any other activity-bar tab hides them and shows that view. Cudic's two tabs sit in their own strip directly under the workbench's icons rather than inside its icon list, so the workbench rebuilding that list never removes them.

Studio is a VS Code-style workbench in the browser: the file Explorer on the left, editor tabs in the middle, the live Preview on the right, and the Cudic AI panel along the bottom bar. Nothing is compiled — the preview assembles your files into a real web page and runs it.

Projects in the title bar is the project switcher: open another project, start a new one from a template, rename a project in place, or duplicate it as a draft copy. Switching or starting a new project saves the open one first, so nothing is dropped silently.

EXPLORER

Project tree

A tree of your files. Right-click a file for commands, and drag in files to import.

EDITOR

Tabs & palette

Full editor with syntax highlighting, find & replace, and every command in Ctrl+Shift+P.

PREVIEW

Live page

The real thing, updating on Run. The console at the bottom catches errors and console.log output.

CUDIC AI

AI panel

Chat with a model about your project. Apply code suggestions straight into files. See Cudic AI.

Commands

CommandWhat it does
Save project Ctrl+SSaves the workspace to your Cudic account (needs a sign-in).
Insert iconBrowse a library of 670+ ready-made game and board-game icons. Picking one drops the file into your project and an <img> at your cursor.
Import filesPull a set of files into the workspace, merging over what's there.
Import folderSame, for a whole folder — relative paths are kept.
Open from GitHubReads a public repo (or one folder of it) into the workspace as a project — see below.
Import Scratch projectTurn a .sb3 or a shared Scratch link into a playable Cudic project. See below.
Export project as zipDownloads the whole workspace as a zip.
Publish / UnpublishPuts your project in the gallery, or takes it back out.
Set thumbnailUpload an image, capture the preview, or clear it — that's the card art in the gallery.
Open Preview / RunRuns the project in the preview pane. A .py file runs with Python.
Add package / Install Python packageAdds the import line for an npm or Python package to the open file.

The import and export commands live in the palette, the File menu, and the right-click menu in the Explorer or the editor — all three routes do the same thing.

Command palette

Press Ctrl+Shift+P in Studio — every Cudic command lives there, grouped here by what it's for. Most also appear in the File menu or the right-click menu in the Explorer and the editor.

Project

CommandWhat it does
Save project Ctrl+SSaves the workspace to your Cudic account.
Import files / Import folderPulls files or a whole folder into the workspace, merging over what's there.
Open from GitHubReads a public GitHub repo — or one folder of it — into the workspace.
Import Scratch projectTurns a .sb3 or shared Scratch link into a playable project.
Export project as zipDownloads the workspace.
Publish project / Unpublish projectPuts the project in the gallery, or takes it back out.
Set thumbnailUpload, capture or clear the gallery card art. Games without one get a default Cudic cover, so a card is never blank.
Start from templateDrops a starter game (snake, pong, breakout) into the workspace to build from.
Delete projectPermanently removes the project from your account.

Version history

Source Control (the branch icon in the activity bar, above Collab) is a real Git repository for the open project, kept in this browser. Files are compared with HEAD and marked U new, M changed or D gone; type a message and press Commit to write a real commit — SHA-1, parent and all — into that repository. The branch chip switches branches and creates them, and checking one out replaces the workspace files with that commit's tree. The repository is keyed to the project, not to its title, so renaming a project changes nothing; a project imported from GitHub gets origin from the import automatically, otherwise use Set GitHub remote…. Signed in, that repository is also stored with the project itself, so opening the project in another browser or on another machine restores its history, branches and refs instead of asking you to initialise again; signed out it stays in this browser only, and an unsaved draft has no project to store it with. Initialise local repository creates that browser-side repository and touches nothing on GitHub; Create GitHub repository… is the separate step that makes a remote on your connected account and immediately pushes the first commit, so the new repository is never left on GitHub's empty setup page; later changes go out with Push to GitHub, which writes these files there as a real commit — blobs, tree, commit and ref — fast-forward only, so a branch that moved on GitHub is refused rather than overwritten. Commit and Push ask different questions: Commit is greyed when the working tree matches HEAD, and Push is greyed once the remote already holds the commit HEAD points at, so neither button offers a write that would change nothing. The Changes list re-reads on every save, and a push also records the files it published as a commit in the local repository, so the history is never empty after a successful push. A repository created on GitHub and left empty has no commits at all, and GitHub refuses git writes to it, so the first push creates that first commit itself rather than stopping with an error. Push only adds and updates: files this project does not carry are left alone, which is what keeps an imported subfolder from wiping the rest of a repository.

CommandWhat it does
Source controlOpens the repository: status, commit box, branches and history.
Save snapshotStages this session's changes into version history: shows what changed since the last snapshot, and you can uncheck any file you don't want included (unchecked files keep their previous snapshot's copy — the snapshot is "the last one + what you checked"). The last 20 are kept.
Restore snapshot… / Restore a previous versionPicks a snapshot and puts its files back.

Collab

CommandWhat it does
Start collab sessionOpens a shared room for the current project — see Collab editing.
Join collab session…Asks for a room code and joins that room.
Leave collab sessionExits the room and clears the saved code.

Run & packages

CommandWhat it does
Open Cudic Preview / Run active fileRuns the project in the preview; a .py active file runs with Python instead.
Run Python fileRuns the open .py file in the preview (Pyodide, no real Python needed).
Add npm packageInserts the https://esm.sh import line for a package.
Install Python packageInserts the micropip.install() lines for a package.
Insert assetBrowses the Kenney library and drops an <img> at the cursor. Images are linked — the CC0 file is served from the site or its CDN, so it costs your project nothing — while 3D models are copied in, because a model loads its textures from its own folder.

Window & AI

CommandWhat it does
Toggle sidebarCollapse or open the file Explorer column.
Leave StudioBack to the website.
Cudic AI: Open chatOpens the AI panel along the bottom.

Project files

A project is just a folder of files, and the browser is the only machine:

  • index.html is the entry point. If your project doesn't have one, the preview won't run. Legacy single-file games (from the old editor) are still served, but new projects should start with an index.html.
  • Local .css and .js siblings are inlined into the preview automatically, so you can keep styles and scripts in separate files and still get one working page.
  • Files can import each other. A relative import './helpers.js' inside your own project works in the preview and in the published game — the platform wires each file up under an internal id.
  • Images, audio and other binaries are uploaded separately from your text files, so big media doesn't slow saves down.
  • Bare imports like import confetti from 'canvas-confetti' are resolved from a public CDN, and publishing uses the same URLs — a published game needs no build step.
  • An importmap in your index.html pins a package to a version or path; anything you pin yourself is left alone.

If a text file you imported shows up as a binary file in the editor, it was probably saved as UTF-16 (old Windows Notepad does this by default). Re-save it as UTF-8 and import again.

Python

Running a .py file (with Run, or via Cudic: Run Python) executes it with Pyodide — CPython compiled to WebAssembly — inside the preview pane. micropip is preloaded, so package installs are one line:

import micropip
await micropip.install("cowsay")

import cowsay
cowsay.cow("hello from Cudic")

Install Python package writes that snippet to the top of the open file for you.

Good to know

  • The first run downloads roughly 10 MB of the Python runtime, so give it a second. After that it's cached and fast.
  • It's a browser runtime: no filesystem, no servers listening on ports, no system packages. Pure-Python and WASM wheels only.
  • Each run starts fresh — variables from a previous run don't carry over.
  • Run in Studio routes .py files here automatically; you don't have to change anything.

npm packages

Write a normal import and it works in the preview and in the published game:

import confetti from 'canvas-confetti'
confetti({ particleCount: 120 })

Add package inserts a fully-qualified import (optionally with a pinned version) so the file also works when someone else opens it.

Pin a whole project in a package.json at the project root. Every dependencies entry becomes an import-map entry on esm.sh at the version you wrote — "react": "^18.3.1" loads react@18.3.1, in the preview and in the published game, and react-dom/client resolves through the same pin. Ranges that cannot be pinned, like "*" or "latest", fall back to the CDN default. An importmap you wrote yourself always wins over the file.

Types for the in-game APIs ship at /cudic.d.ts. Every new project gets that file automatically, so CudicSave and CudicMulti have real signatures, event names and JSDoc in the editor instead of any.

TypeScript and tests

  • Save compiles every .ts / .tsx file to a sibling .js with a // generated from … header, and points index.html at the build output. Edit the source: a .js you wrote yourself is never replaced, and the preview builds in memory so you do not have to save first.
  • A .d.ts file is never compiled, so cudic.d.ts stays a declaration.
  • Cudic: Run project tests runs files named *.test.js (or anything under tests/) in a sandboxed frame. Use test('name', fn), assert(cond, 'why') and assert.equal(a, b, 'why'); async tests are awaited, and results land in the Cudic tests output channel.

The rules

  • import 'pkg/style.css' is lifted into a stylesheet link automatically.
  • A dynamic import('pkg/style.css') can't be rewritten — load styles statically instead.
  • No build scripts, no native binaries and no Node built-ins (fs, net, child_process): those don't exist in a browser.
  • The preview rewrites bare imports to esm.sh URLs. Pin a version with pkg@1.2.0 if the latest won't do.

Importing Scratch projects

Cudic: Import Scratch project (palette, File menu, or right-click) takes a Scratch game and turns it into a Cudic project you can edit and publish.

Two ways in

  • File — pick a .sb3 you've downloaded from Scratch. This is the most reliable route.
  • Link or id — paste a shared link like https://scratch.mit.edu/projects/123456789 or just the number. You'll be asked to confirm the project is your own or one marked "See inside".

What lands in the workspace

FileWhat it is
index.htmlA tiny player page. There's no game code in here.
scratch.jsThe fixed loader that boots the Scratch runtime and plays the project.
project.jsonThe editable source. Every sprite, costume, sound and block lives here.
assets.jsA short map from each asset to its file.
assets/The costumes and sounds themselves, as normal files you can save and publish.

Scratch blocks are data, not JavaScript, so index.html looks almost empty and the real project sits in project.json. If you edit project.json, the running copy in assets.js doesn't change until you re-import or sync the two by hand.

Good to know

  • Scratch blocks are not converted to hand-written JS. You get the original project, editable as blocks-as-data.
  • Cloud variables are kept per player in that browser instead of being synced.
  • Text to speech and translate blocks need service keys, so they stay silent.
  • Video sensing needs a camera; the game sandbox doesn't allow it.
  • Projects that use music load a bigger runtime the first time they run.
  • Scratch rate-limits downloads and sometimes won't hand over a link at all — if a link fails, import the .sb3 file instead. Heavy projects (lots of costumes or sounds) take longer to save.

Opening a project from GitHub

Cudic: Open from GitHub reads a public GitHub repository into Studio as a normal project — palette, File menu, or right-click a file in the Explorer or editor. No sign-in and no GitHub connection: nothing is authorised, because nothing is written back.

Push to deploy. Once a project has pushed to a repository from Source Control, that repository is remembered for the project — and a later push to it becomes the next release, using the commit subject as the notes and the commit sha as the source. It only fires when the game is published, the push targets the branch that was pushed to, and the pusher is the same GitHub login, so a fork or a pull request cannot release under your name. This is for projects that want GitHub to be the source of truth; projects edited in Studio only are unaffected. A repository does not have to be pushed from Studio to be connected: save a project that was imported from GitHub and the project records that repository, its default branch and its owner, so the repo's next commit deploys even if you never push. The link is verified with your GitHub token first, so a repository you cannot read is never recorded.

What you can paste

You pasteWhat opens
owner/repoThat repo's default branch.
https://github.com/owner/repoThe same thing — full link, with or without .git.
…/tree/main/games/snakeJust that folder. Use this for a repo holding several games, or one too big for the CDN.
…/blob/main/games/snake/index.htmlThe folder that holds the file.
/studio?github=owner/repoThe same import, from a link you can put in a README.

What happens to the files

  • Text files arrive editable; images, models and audio arrive as real binary files — the same as Import folder.
  • More than one game in the repo? Cudic reads the file list first and asks which folder to open — every folder with its own index.html, root included. One folder means no question, and a /tree/…/subfolder link already answers it. Without this, a monorepo silently opened whichever demo sat closest to the top. The confirmation names the one it opened (e.g. owner/repo@main → games/snake).
  • Pick one or type a path — each row shows how many files the folder holds. A path that is not in the list gets the nearest real folder suggested instead of an import that quietly found nothing.
  • It's a snapshot. Nothing is pushed back to GitHub. Save project stores your own Cudic copy, and your edits live here.
  • A repo isn't a project, so the folder holding the shallowest index.html is preferred, then code, then media.
  • Limits match Import files: 400 files, 8MB each, 25MB in total. node_modules, dot-folders and lockfiles are skipped.

Private repositories need a GitHub connection (below). Once one is connected, the same Cudic: Open from GitHub command opens a picker of that account's repositories, private ones listed first, with Paste a link instead… (any public repo) still at the bottom — that is the path to a repo you do not own, and it needs no connection at all. Importing one works like this: Cudic's server reads the repo with your token, because jsDelivr only serves public code and GitHub's own API allows 60 requests an hour per IP. Your token never reaches the browser — Studio receives file paths and file bytes only.

Connecting GitHub

Repo access is a separate grant from signing in. Signing in with GitHub proves who you are; connecting grants read access to your repositories, private ones included. Start at Profile → Connections → Connect GitHub and approve the request on GitHub.

  • Signed in with GitHub already? Then the identity exists and there is nothing to link — Cudic asks GitHub for repo access again on the same consent screen, and the card switches to Connected as … as soon as the token is stored. A guest session cannot hold a connection, so it is asked to sign in first.
  • The token is stored encrypted on the server and never comes back to a browser — Cudic shows only the GitHub username and the scopes you granted.
  • Disconnect GitHub deletes the stored token. Revoke it on GitHub too if you want the grant gone from their side.
  • Public repos never need any of this: Cudic: Open from GitHub works signed out.

Building from a terminal (CLI)

Everything Studio does with projects — create, save files, publish — runs through the same HTTP API, so a terminal or an AI agent can make Cudic projects without a browser. cli/cudic.mjs wraps that API; it needs Node 18+ and nothing installed.

Installing it: npm i -g cudic-cli puts both cudic and cudic-mcp on your PATH. The package is called cudic-cli because npm reserves the bare name cudic (too close to an existing package) — the command you type is still cudic. Try it with npx cudic-cli games, or from a clone with npm i -g ./cli. Two dependency-free files, nothing to audit — and npx -y --package cudic-cli cudic-mcp is the whole setup for an MCP client.

  • cudic login --email you@example.com signs in once and keeps a refreshable token in ~/.cudic/config.json. Agents that should not store credentials can set CUDIC_TOKEN=<supabase access token> for a single run instead.
  • Passwords and email codes: cudic password reset --email you@example.com mails a 6-digit code (10 minutes, 5 tries, burned on use); rerun it with --code 123456 --password <new> to set the password. Already signed in? cudic password change --password <new> skips the code. cudic verify --email you@example.com [--code 123456] sends or enters a signup confirmation code.
  • cudic new my-game scaffolds index.html, style.css and game.js. cudic push my-game saves the folder as a project (creating it the first time, updating it after), and cudic publish my-game --tags puzzle puts it in the gallery.
  • The project id is written to .cudic.json in the folder, so later pushes and publishes don't need it. cudic list shows your projects; cudic open prints the play link (or the Studio link with --studio).
  • Files travel as text (html, css, js, json, svg, md). Binary assets and thumbnails still go through Studio, and the account needs a verified email like every other publishing path.
  • Reading Cudic without the browser: cudic games browses the gallery, cudic get <id> downloads a game's source (files plus any uploaded assets) with a CUDIC.md credit note, cudic forums and cudic thread <id> read the forums, cudic docs [section] prints these docs as plain text, and cudic shop / cudic shop buy|equip handle the cosmetics shop. Gallery, forums and docs work signed out.
  • Studio's snapshots are available too: cudic snapshot saves the folder as a project revision, cudic revisions lists them and cudic restore <revision id> puts one back. History keeps up to 100 snapshots and is content-addressed — each distinct file body is stored once, so a one-line edit costs a few bytes, not a second copy of the project.
  • cudic diff shows what changed since the newest snapshot (or any revision, with --against prev / --against <rev>): added, removed and changed files with sizes. --json gives the raw list, and the API's ?file= parameter hands back both versions of one file when you want the actual lines.
  • Editing an existing project round-trips: cudic pull brings the saved copy down (keeping a backup of what you had), cudic ls lists the files, cudic cat <path> prints one file's code, and cudic push sends your edits back up. cudic unpublish hides a published project again and cudic rm --yes deletes it (a plain rm only tells you what it would delete).
  • Every push, pull and recover saves the version it is about to overwrite into .cudic-backups/ in the folder (newest 10 kept). cudic backups lists them and cudic recover latest puts one back on disk — that's your undo when a push goes wrong.
  • Profiles are editable from the terminal too: cudic profile shows your name, bio, follower counts and awards, and cudic profile set --name "..." --bio "..." --interests art,music updates them. Avatars must already live in your Cudic avatar storage (the site's uploader is still the way to add one).

Agents & API keys

Anything an agent can do with a browser session it can do with a scoped API key — a durable credential that does not expire, can be revoked, and only carries the permissions you grant. Keys are shown once and stored hashed.

  • Create one from a signed-in terminal: cudic key create "my agent" --scopes projects:read,projects:write. The printed cudic_… value is the only time it is shown; cudic key list shows creation, last use and revocation, and cudic key revoke <id> kills one immediately.
  • Scopes: projects:read (list and open projects, including your drafts), projects:write (create, save, publish, delete), profile:read (name, bio, email for the account). A key without projects:write gets a 403 when it tries to save.
  • Use it as CUDIC_API_KEY=cudic_… or cudic login --key cudic_…. Keys can never mint other keys, so a leaked key cannot escalate to a full session; revoke it and make a new one.
  • MCP server: node cli/cudic-mcp.mjs speaks the Model Context Protocol over stdio, so Claude Desktop, Cursor, Cline and other MCP clients can drive Cudic directly — point the client at that command with CUDIC_API_KEY in its env. Tools: cudic_list_projects, cudic_get_game, cudic_push_project, cudic_publish_project, cudic_search.
  • Keys live in the api_keys table (migration migration/api_keys.sql), compared by sha256 hash, never stored in plain text, and capped at 12 active keys per account.

Publishing & the gallery

  • Your stats live on your own creator page (/creator?id=<you>): all-time plays, signed-in players, players in the last seven days, likes, comments and forks, plus your five best-performing games. Only you see the card. A daily history and an average session are not recorded yet, so they are not shown — the numbers there are measured, not estimated.
  • Publish makes your project playable at its own page and lists it in the gallery. Unpublish keeps the project but hides it — absolutely no one else can load an unpublished game.
  • Publishing a release, not a switch. Each publish snapshots the files into a release (v1, v2, …) with the notes you typed, and the game page serves that snapshot — so saving afterwards edits a draft and players stay on the build you shipped. The page shows the version, when it updated and the notes. Studio's Ship does save, publish and hand you the link in one step; Publish project stays available when you only want to ship. Games published before releases existed keep serving their saved files until their next publish. Publishing runs the project's tests first: a failing test, or a test file that will not load, stops the release and says which ones, and the server refuses a publish that reports failures. A project with no tests publishes as before, and each release records the counts it shipped with.
  • Set a title, a description, up to 3 tags, and a thumbnail. Tags (platformer, puzzle, horror…) put your game in the gallery's tag filter and on the "More like this" shelf of similar games — editors show one-tap suggestion chips. Upload an image, or capture the preview with one click — usually the fastest route to a decent card. Images are shrunk to fit the gallery, so any reasonable size works. Skip it and the game shows the shared Cudic cover until you upload your own.
  • Gallery cards show the thumbnail, title, author, playing-now count and comment count; comments are open on each game's page.
  • Comments thread now: hit Reply under a comment and your answer nests directly beneath it, one level deep — so a maker can answer "how does the double jump work?" in place instead of leaving it in the wall. The person you replied to gets a notification, deleting a comment takes its replies with it, and a reply to a reply stays under the same top comment so the thread never marches off the right edge.
  • The top of a game page shows a live strip with how many people are in the game's multiplayer rooms right now.
  • Games play in a sandboxed frame, so nothing in your game can reach your Cudic session. That's why saved progress is handled by Cudic rather than the game (see Cloud saves).

Playtest links

  • On your game page, Playtest link → Create 7-day link gives you a signed URL for the draft. Anyone with it can play; the game never appears in the gallery, search or your profile.
  • Links expire (1–30 days) and old links stop working then. Make a new one whenever you want; changing PLAYTEST_SECRET invalidates every existing link.
  • Testers get a feedback box on the page. Their notes land in the game's devlog card, marked Playtest feedback — only you see that section; it is never part of the public devlog.

Finding games

  • The search box matches names and descriptions, and the filter lives in the page address so a search can be shared. The sort menu flips between newest, trending, oldest and A–Z.
  • Keyboard browsing: on the gallery, j and k (or the arrow keys) move a visible selection through the cards, Enter opens the one you are on, / jumps to the search box and Escape drops the selection. Each card is a Tab stop too, and keys are never stolen while you are typing in search.
  • Trending sorts by how many times games have actually been played. One play per person per game per hour, so refreshing doesn't inflate it.
  • The heart on a card or a game page saves it to your account. Liked games collect on your profile.
  • Tags are set when you publish (the publish modal in the editor, or the prompt when Studio publishes) and can be changed later — the gallery's tag chips and the "More like this" shelf both read them.
  • Ranked search: names, descriptions and tags are indexed with Postgres full-text search, so results are relevance-ordered (then by plays) instead of arbitrary. One endpoint covers everything — /api/search?q= returns games, forum threads and creators together, with type=games|threads|people to narrow it, and cudic search "<text>" gives the same list in a terminal.
  • Notifications that reach you: the bell already had an inbox; it now also sends real browser push. Hit Enable push on the notifications page once and comments, replies, friend requests and awards show up on your desktop or phone with the tab closed. Subscriptions are per-browser, dead ones are pruned automatically, and the signing keypair lives in the database — no setup. There is also a small public feed at /api/activity with what creators recently shipped.
  • An ops console: moderators get /ops, one page with uptime, memory, database latency, live socket count, rate-limit pressure and row counts (users, games, snapshots, keys, push devices). It reads a single endpoint, GET /api/ops/status, so you can curl the same numbers in a terminal or keep it open on a second monitor — it refreshes itself every 15 seconds.

Remixing

Remix on any published game copies it into your own projects so you can change it. The copy is a normal project — edit every file, publish under your own name when you're ready.

See inside is the read half of that: it opens a published game's code in Studio with the preview working, and nothing you change is saved. There is no save, publish or delete in that view — fork when you want to keep an edit. Drafts never open to anyone but their owner.

Credits are permanent

  • The game you came from is credited forever: your copy keeps a line back to its parent and to the original, all the way up the chain.
  • The original page keeps crediting the parent too, so remixed games are visible from everywhere they were copied.
  • Credits are part of the game record. Editing or unpublishing your remix doesn't remove the link upstream.

Cloud saves

Signed in, your progress follows your account: sign in on another device and your bests and saved state are there.

  • The gallery opens with a Continue playing shelf: the last eight games you opened, newest first, each card stamped with how long ago you played it. It is account-bound like a save, so it follows you to another device, and it stays hidden for guests.
  • Games opt in — the ones in the gallery already do. Your own game can use the same helper if you want saves.
  • Want a public leaderboard? CudicScores.submit(score) after each run keeps every player's best (via cudic-scores.js), and the game page shows the top 10 with names — all time or just this week (the tabs on the board).
  • Finishing a game should never dead-end: the game page shows More from this creator and More like this shelves, built from the maker's other published games plus games that share a tag or read alike — closest match first, with the most played games topping up the strip so no game dead-ends on an empty shelf. Nothing to set up — tag your game well and it shows up on the shelves of games like it.
  • Want a soundtrack? Beats are made in the Music Lab. In Studio, open the Music tab (command palette → “Cudic Music: Open library”) to pick your track — or anyone's — and the game plays it with one line: <script src="/cudic-music.js"></script> + CudicMusic.play('<trackId>').
  • Typical shape: best scores and a small amount of state. A clicker-style game can save its whole board; a platformer saves a level and a best.
  • Each save is capped at 100 KB. If something doesn't fit, save a summary instead of the full board.
  • Writing your own game? Do it through cudic-save.js — the game frame never holds your account session, Cudic passes the save through. That's what keeps games sandboxed.
  • Last write wins, so finishing on two devices at once keeps whichever was later. Mid-run boards don't sync — only bests and finished state.
  • The game page has backup and restore next to the save, so a bad click doesn't lose a save forever.
  • Guests play normally, but nothing is stored — a sign-in prompt appears once per game.
  • Achievements are in too: CudicAch.unlock('speedrun') (via cudic-ach.js) records each player's first unlock per game, and earned ones show on the player's profile. Call it the same way as the score submit — right after the moment the player earns it. Check result.first to reward them in-game.

Find anything (Ctrl+K)

Press Ctrl+K (or ⌘K) on any main page — including this one — for a search box over games, creators, forum threads and pages. Type, use ↑/↓, press Enter to open, Esc to close. It is the fastest way to jump to a page or a game without going back to the rail.

Touch controls for phones

Most players who tap your game link are on a phone, where the keyboard doesn't exist. cudic-touch.js adds an on-screen D-pad and actions button that turn taps into ordinary key events:

  • One line in your index.html: <script src="/cudic-touch.js?v=2" data-cudic-touch="auto"></script>. On phones you get an arrow D-pad plus an A button mapped to Space; on desktop nothing shows at all — the pad only mounts on touch-first screens.
  • Prefer an analog feel? data-cudic-touch="auto:J=on" (or CudicTouch.mount({ joystick: true })) swaps the D-pad for a drag-anywhere joystick: hold anywhere in the base and steer — 8 compass sectors map to key pairs, so diagonals work. Releasing always lets the keys go, so nothing sticks.
  • Customize keys with the data-cudic-touch value: auto:A=Space,B=z,D=wasd sets the action buttons and switches the D-pad to WASD. dpad=false skips it for click-only games. Full options plus the CudicTouch.mount()/hide()/unmount() API are in the platformer guide.
  • Games need no changes: a press sends one keydown, a release one keyup (with key, code and keyCode), so any game listening to arrows, WASD or Space plays unedited.
  • Multitouch support: hold two D-pad directions for diagonals.

Gamepad support

Controllers work in the player with no extra tag: cudic-pad.js is injected into every game frame. Read it from your game's code:

  • CudicPad.get() returns { id, axes, buttons } for the first connected pad (or pass an index). Poll it in your game loop; buttons[i].pressed and .value are standard Gamepad API values.
  • Events: CudicPad.on('buttondown', fn) / 'buttonup' / 'axischanged' / 'connect' / 'disconnect'. CudicPad.start()/stop() control the polling loop; CudicPad.supported is false on browsers without the API.
  • Standard mapping: 0 A, 1 B, 2 X, 3 Y, 4 LB, 5 RB, 6 LT, 7 RT, 8 Back, 9 Start, 10/11 stick clicks, 12–15 D-pad; axes 0/1 are the left stick, 2/3 the right. Analog axes respect CudicPad.deadzone (0.18).
  • Nothing is stored or sent: the shim only reads navigator.getGamepads() inside the sandboxed game frame.

Update log & RSS

/updlog lists what shipped, newest first. Every entry also has an anchor, and the whole log is an RSS 2.0 feed at /updlog.xml — paste it into any reader to follow releases without an account.

Share clips

Any game with a canvas can be turned into a short video without screen-recording software: on a game page press Clip. Cudic records about eight seconds of play, draws the game's title, creator and your last score over it, and drops the finished file on the page.

What you get

  • 8 seconds, 30fps, capped at 1280px on the long edge — small enough to post straight to YouTube Shorts, TikTok or Discord.
  • Overlay included: the game's title, its creator's name, the Cudic address, a score chip when the game reports scores through CudicScores, and a lime progress bar so viewers know it's a clip.
  • Formats: WebM in Chrome, Edge and Firefox; MP4 where the browser can encode it (Safari). The download button is named after the game.

How it works (and what it never does)

  • The recording is made inside the game's own frame by the platform, so it works even though games are sandboxed away from the page — no game needs to change a line of code.
  • Nothing is uploaded. The video exists only in your browser until you save it; closing the page throws it away.
  • No audio track: the file is video only. Add music or voice in your editor.
  • Click-only games that draw with DOM elements instead of a <canvas> have nothing to capture, so the Clip button simply doesn't appear.

If you post a clip of someone else's game, credit the creator — their name is already in the video, and the game page is the best link to share alongside it.

Chat & servers

A server holds channels; a channel holds messages. You can also message people directly. Chat history is permanent — messages stay unless a moderator removes them.

SERVERS

Your spaces

Create a server from Servers and pick its starting channels — add more later. A server can post rules members acknowledge once.

ROLES

Owner · admin · member

Admins manage channels and members; members chat. Owners carry the keys.

DMs

Direct messages

Friends can DM one-on-one: add someone, they accept, then you talk.

  • Typing indicators, unread badges and read receipts are all live — no refreshing needed.
  • Your servers are listed in the left rail so jumping between them is one click.
  • The Find a conversation box filters your message list as you type. Inside a conversation, Search looks back through that conversation's history for a word or phrase.
  • Sending very fast is briefly rate-limited — that's the flood guard keeping bots out of the rooms.
  • Something wrong in a message? See Reports.

Chat extras

Open Extras in a conversation for the personal controls. They are private to your account and never change what anyone else sees in the room.

  • Status — an emoji and 60 characters, saved on your profile and shown next to a DM.
  • Read receipts — turn sharing off and both sides stop seeing seen ticks; sent ticks remain.
  • Private notes — a note about the person in a DM, visible only to you. Included in your account export.
  • Reminders — Remind on any message, pick a time, and get an inbox notification with a link back.
  • Personal pins — Keep a DM message for yourself, separately from room-wide pins.
  • Mutual interests — shared profile interests are listed in the DM panel.
  • Channel badges — unread counts now appear on the server's channel list, not just the conversation list.
  • Sound — an optional quiet tone for incoming messages, generated in the browser (no audio files).

Organise and profiles

Organise sits beside Extras in a conversation. It is a private view over your own list — nobody else sees your folders or notes.

  • DM folders — create up to 12 folders, file the open DM into one, and filter the conversation list with a folder chip. All DMs restores the full list.
  • Peer card — open a DM's profile card for their public bio, status, shared interests, mutual servers and published games without leaving the conversation.
  • Search filters — the message search adds sender, after/before dates and a links only switch. Results still come only from the conversation you can open.
  • Typing previews — in server channels the typing line can show your first few words. DMs never carry a preview, and the profile switch turns it off everywhere.

Friend activity

The Friends page has a Friend activity shelf: recent public activity from accepted friends. It is opt-in — share yours from Profile → Share my public activity with friends; off is the default and nobody can see it until you turn it on.

Channel templates and server tools

Owners and mods get a Tools button on a server. Owners can edit the open channel's description, save its topic/description/privacy/slow-mode as a Channel template, and create a new channel from that template. Mods can read the audit log; owners can export a server backup as JSON and restore channels, roles and bans into the same server.

Servers also celebrate milestones once: 100 members, a first birthday and 10,000 messages each post a system line and award the owner a badge. The milestone table makes them one-time even across restarts.

Scheduled messages and edits

Plan beside Organise schedules a message for any conversation. Owners can tick announcement in a server channel; the server re-checks membership and ownership when it fires. A schedule can be cancelled before it sends, and a failed send records why.

Your own messages have Edit and History actions. Editing is author-only, limited to 24 hours, and every previous version is kept (the newest ten) with its timestamp.

Message collections

Collect on any message saves a snapshot into a named private collection. Collections survive the original message being deleted, and can be opened, browsed or deleted from the Plan panel. Each account keeps up to 12.

Server events

Owners and mods can add a Server event from Tools: a title, start time and optional channel. Members RSVP Going, see the count, and download an .ics calendar file. The channel header shows the next event, and going members get inbox reminders 15 minutes and 1 minute before it starts.

Server HQ

HQ is a member-visible panel beside Tools. It shows members, channels, messages in the last seven days, active channels, and a 30-day leaderboard built from the messages the server already holds. The numbers are a reading aid, not a scoreboard: a busy channel can outrank a useful one.

  • Introductions — every member can save one short introduction for this server. It is visible to members of that server, not a global profile field.
  • Temporary channels — owners can create a channel that expires after 1–168 hours. Expired channels stop appearing in the channel list; their rows are left in place rather than deleting history.
  • Bulk edit — owners can select several channels and change their topic, slow mode or privacy in one action. The server checks every id belongs to the server before writing.

Channel dashboard, catch-up and code

The top of a channel carries a compact dashboard: the next event with its calendar download, the pinned-message count, and the expiry of a temporary channel. The server sidebar adds a Catch up shelf with the channels that have unread messages, so the noisiest room is one click away.

Fenced code blocks now render with a language label and a Copy button in chat and server messages. Right-click any message and choose Add to Calendar to download an .ics with the message text and a link; the date and time are yours to confirm. Ctrl/⌘+K also lists the channels and conversations on the page under Jump to.

Quiet hours and introductions

Profile has an Introduction (shown on your peer card) and Quiet hours in UTC. During quiet hours the inbox still receives the notification; only the push is held. Notifications are never dropped.

Customization Studio

Customize is one account-wide page for the look of Cudic. Pick an interface font, text size and line height, switch between comfortable and compact density, choose icon / expanded / floating rail modes, turn on glass panels, reduce motion, and pick a list, compact or grid channel layout. Every choice saves to the account and follows you between devices.

The studio also holds a layout editor (conversation list before or after the message pane, with named layouts), per-type notification sounds for DMs, mentions, events and invites, and a theme pack creator that publishes a validated colour/wallpaper/font manifest to the store. A private conversation theme can give one DM or channel its own accent and background.

Profile extras

Add up to twelve profile widgets (text, https link, achievement code or latest games), set a banner focal point, allow an animated banner and give your public page its own theme pack. Those widgets and your custom badges appear on /creator without changing anyone else’s profile.

Server appearance

Owner tools open a server customisation page: accent and banner, two-level channel folders (drag-free filing, channels stay usable when unfiled), custom badges granted to members, a three-step welcome flow, and declarative /commands with a cooldown. Commands are data, never JavaScript, and all writes are owner/mod gated.

Playing together

With other members on Cudic in the same published game: many games run live rooms over Cudic's connection, so you play the real thing together — no extra downloads, no accounts at other services.

  1. Open a game from the gallery. Games that support it show a live strip with the head-count and how to join.
  2. Pick a room code if the game offers one; the default room everyone lands in is main.
  3. Play. Positions, moves and chat-style messages move in real time while you stay on the page.

Who sees what

  • Names come from Cudic, not the game. Signed-in players appear with their account name; everyone else is a Guest. A client can't fake a name or clone someone's session.
  • Rooms are anonymous on purpose — guests must be able to play along, so joining a room never requires an account.
  • The game itself can only send small messages through the room; it never sees your session or your saves.
32

Players per room

The room cap per game — a server keeps any third player list honest.

8 KB

Message size cap

Small packets only, so a game can't flood a room with data.

~200 / 10s

Send limit

Generous for play, harsh for abuse: per-connection caps on messages and joins.

Building multiplayer into your game

Your game uses cudic-multi.js — CudicMulti.join('code') gives you net.send(obj), net.on('msg'), the peer list and net.leave(), and the platform does the connecting for you. Games running in the Studio preview get their own preview rooms so testing never collides with the published game's rooms.

Nothing in a room is stored, so a room's chat isn't reviewable after the fact. Report a player from the game page's live strip (by account); guests have no account to report — report the game and describe what happened in the note.

Collab editing

Build together, Live Share-style. Everyone in a collab room sees the project's files in their own Studio, and edits merge live — even when two people type in the same file. Connections are peer-to-peer (browser → browser), so a room barely touches Cudic's servers.

  1. Start a session — in Studio, click the people icon on the left icon rail, or run Cudic: Start collab session. A room code appears in the panel header.
  2. Share the code — the copy button puts it on the clipboard. Others run Cudic: Join collab session…, paste it, and their Studio joins the same room.
  3. Build. Text files merge as everyone types, each person's cursor shows with their name on it, and the session panel carries the room's chat.

Names, chat and rejoining

  • Names come from Cudic. Signed-in builders appear with their display name; guests get a temporary alias of two random words (cosmic otter, zippy puffin…) that sticks until they sign in.
  • The people-icon panel holds the chat, the in-room list, the room code and a connection dot — green ● means the room is live.
  • Reloading rejoins — a reload or crash recovery returns you to the same room with chat and peers intact. Cudic: Leave collab session is the real exit.
~20

People per room

A WebRTC mesh — every peer is in your browser, not on a relay server.

P2P

Server load

The public signaling servers only broker each handshake; nothing after that flows through Cudic.

TEXT

What syncs

Text files merge live. Images and audio stay local — a snapshot sent alongside carries bigger assets.

Handing someone the room code shares that session's files, not ownership of the project. If a playtest goes wrong, the owner has version history as a safety net — save a snapshot before starting a big collab.

Following & activity

Following someone puts their news on your feed: when they publish a game or earn a badge or title, it lands in Activity on the Friends page. Following is one-way — you decide who you see, and friendship isn't required.

  1. Find their page — follow from a creator's profile, from the byline of any game they've published (the button sits right next to their name), or paste their profile id on the Friends page.
  2. Follow. The button flips to Following ✓; unfollowing is one click and silent — nobody finds out either way.
  3. Watch the feed. The Activity card shows the latest 60 moves from you and everyone you follow, with dates and links to their pages.
ONE-WAY

Follow ≠ friend

Friends are mutual and approved. Follows are silent subscriptions — no request, no notification.

60

Feed depth

The feed keeps the newest 60 events. Publishes and awards you earned stay; rooms and chats never appear here.

30/h

Follow limit

Thirty follows an hour — generous for people, harsh for bots.

Game jams

Every week Cudic runs a jam. A theme is picked Monday, you have the week to build and publish a game around it, and players vote for their favourite. Winners get coins, a badge, and a spot on the homepage.

  1. See the theme — the current jam theme is shown on the homepage and on a game's page when it matches. Games join the gallery under that theme tag.
  2. Build and publish anything made in Studio that fits the theme — mark it with the theme tag so it shows up as an entry.
  3. Vote — each signed-in player gets one vote per week; tap Vote on a jam game's page and it flips to Voted. Tap again to take it back, or vote for a different entry and your vote simply moves — it never counts twice.

The homepage shows this week's standings and the previous week's winners, so finished jams stay visible — the “winner spotlight” shelf swaps in when the week rolls over.

1/WEEK

Votes

One vote per person each week (server-enforced). You can swap it until the week ends.

MON

Roll over

A new theme is picked Monday automatically — none repeated from the week before.

TOP 3

Rewards

The three most-voted games earn their makers coins and a Jam Winner badge, and stay pinned on the homepage until the next jam.

Moderators can set the weekly theme manually on purpose (e.g. for a seasonal jam); otherwise it rotates on its own.

Creator race

The weekly creator race runs at /race. It measures the thing jams don't: whether people keep playing what you ship. Every unique player who starts one of your published games during the week — signed in or not — is one point for you. Nothing to enter: publishing a game puts you in the race.

  1. Play scoring — one point per unique player per game per week. Replays from the same person don't stack, and the play counter still dedupes per browser per hour.
  2. Watch the week end — the countdown on /race runs to Monday, the same clock the jam and the weekly digest email use. Scores reset at the rollover.
  3. Collect — winners are paid automatically when the week settles: #1 banks 500 coins, #2 — 300, #3 — 150. #1 also gets the Race Champion title, #2/#3 the Race Podium badge, and everyone gets a notification + a line in the weekly digest.
1 POINT

Per unique player

Unique players only — the same viewer replaying the same game inside one week counts once, so sharing the link is the real scoring move.

MON

Weekly clock

Monday 00:00 UTC reset, prizes bank through the coins ledger (reason race:<week>), titles and badges land as normal awards.

DIGEST

Your stats, mailed

The Monday digest email now also tells you how your games did last week — race points, new hearts, remixes — plus the race winners.

Privacy note: race dedupe uses a salted hash of the viewer's IP — no account or IP is stored, and one point per household per week is the accepted bias.

Badges, flairs & titles

Awards are the three ways you show off on Cudic. They appear next to your name on your public page and in your profile preview.

FLAIRS

Free to get

Six of them — spark, check, heart, cube, bolt, gem. Use the site and they arrive: join, confirm your email, like a game, build something, import from Scratch, rate a game.

BADGES

Long-time or hard

First Game (publish your first project), Host (create a server), Settler (30 days on Cudic), Veteran (a whole year), Viral (one of your games reaches 100 plays).

TITLES

The rare ones

Worldbuilder (publish five games) and Renowned (a game hits 100 plays). Titles are shown beside your name everywhere your profile is read.

  1. Open Profile → Awards to see everything you own. Locked awards stay visible with a hint on how to earn them — flairs are free, so nothing is hidden behind grind.
  2. Click to equip. Equipped cells get the lime ring and show up instantly in the profile preview on the right.
  3. Save awards. Caps: 5 badges, 10 flairs, 2 titles at once — the server checks ownership and caps, so nobody can equip what they haven't earned.

Every badge and title you earn is announced on your followers' feed. Flairs stay quiet — they're for you.

Theme packs

A theme pack restyles Cudic's app pages — colours, fonts, rail icons, rail background art, motion, and a live background scene. The landing page is deliberately left alone, so a visitor's installed pack never repaints the front door. Anyone can try one instantly, and buying with coins keeps it — even if the author later changes the price.

Using packs

  • Open Themes, preview any pack live-on-the-spot, then install or buy.
  • Installed packs apply everywhere (rail included) and survive reloads — turn it off from your profile or the pack page.
  • The store ships with its first pack, anime city night — a neon rail scene.

Build and sell a pack

  1. Open the builder on Themes — pick colours, fonts, icon style, motion level and a scene. Changes preview as you make them.
  2. Advanced — paste a .ctheme (a small text language for packs), plus your own CSS and HTML for the really specific bits.
  3. Set a price in coins (including free), then publish to the store. Sellers earn coins on every sale.

Anyone can report a pack — see Reports. Prefer plain CSS? You don't need a pack: any project you publish can include its own stylesheet.

Shop — cosmetics

Coins do something besides theme packs: the Shop sells looks for your profile. Nothing here changes gameplay, gives you an advantage, or costs real money — it's the place your quest, streak and jam coins go once you own the packs you want.

Six slots

  • Frame — a ring around your avatar (Leaf, Ice, Ember, Void, Circuit, Holo, Champion gold).
  • Banner — the wash behind your profile header (Blueprint, Terminal, Aurora, Sunset, Starfield, Prism).
  • Profile effect — motion over your whole card (Scanlines, Bubbles, Sparks, Orbit, Drift).
  • Name effect — your username itself (Mono, Glow, Typing, Gradient, Glitch).
  • Title — a line under your name (Maker, Tinkerer, Speedrunner, Game Jammer, Architect, Legend). Earned award titles share the same two title slots.
  • Emoji pack — ten extra chat emojis each (Classic Mix, Cozy, Spooky, Space) that your account can type in servers and DMs.

Buying and wearing

  1. Browse on /shop. Every item shows its price, and the balance in the header updates as you spend.
  2. Buy once, keep forever. A purchase is recorded against your account; the same item can't be charged twice, and prices are set by the server so the page can't be tricked.
  3. Wear it on your profile → Cosmetics. Frame, banner, effect, name style and emoji pack are one-at-a-time; titles hold two (5 badges and 10 flairs still cap the awards).
  4. Unequip any slot to go back to plain. Everything stays owned.

Your profile preview updates live before you save, and the same renderer draws your public creator page — so what you pick here is exactly what visitors see. Everything stops under prefers-reduced-motion.

Spending is capped per day and per hour, so a stolen account can't drain a balance in one go.

Coins

Coins are Cudic's own currency — there is no real money and no cash-out, ever. You earn them for being around and making things, and spend them on theme packs and profile cosmetics.

  • Daily claim on your profile's Earn panel.
  • Quests — small tasks like publishing a game or joining a server.
  • Activity — chatting counts toward a small daily trickle.
  • Bonus from ads — watch an ad for coins on top, with a weekly cap.
  • Selling packs earns coins every time someone buys one.
  • Cosmetics in the Shop are the other sink — frames, banners, effects, name styles, titles and emoji packs.
  • Login streak — being signed in on Cudic counts a day automatically (no button to press). Each new day pays bonus coins — the longer your chain, the bigger the bonus, up to 25 — and your current streak is shown on your profile. Miss a day and the chain restarts at 1.
  • Verified by email? You also get the Cudic weekly — one email every Monday with the new jam theme, last week's winners, and the newest games from creators you follow. That's the only marketing email we ever send.

Your balance and every transaction are listed in the same panel, so you can always see where coins came from and went.

Reports

Published games, theme packs, chat messages, players in multiplayer rooms, and users can all be reported: pick the reason and add what's going on. Packs can include a screenshot. Reports go to the moderators, not to the person who made the thing.

  • Messages — the report button arms on every message you can see, and a report must say where you saw it.
  • Players — reported from the game page's live strip, by account. Guests are anonymous, so put what happened in the note and report the game if a guest is the problem.
  • Users — you can't report yourself, by design.
  • Rate — up to 20 reports an hour per person, which is plenty.
  • Moderators work the queue at /moderate: review, dismiss or act, and act on a report can unpublish a game or delete a message.

Cudic AI panel

The ✦ button in the title bar (or the palette command Cudic AI: Open chat) opens a chat panel along the bottom of Studio. It works with the model provider of your choice.

  • Bring your own key. Add a provider once, then pick any model it lists — including local Ollama / LM Studio models running on your own machine. Keys are stored in this browser and are sent only to the provider you chose.
  • Browse whole catalogs. Many providers list every model they have — expand the company row and the lineup renders inline. Catalogs auto-refresh in the background.
  • Streaming answers with code blocks that have Apply and Copy, so a suggestion becomes an edit in one click.
  • Agent mode (default). It can list and search your project, rewrite files, delete or rename them, checkpoint a snapshot before risky rewrites, open or reload the Preview when finished (even if no Preview tab is open yet — it opens one for you), and ask you a question mid-task if the work genuinely branches. Type /mode to dial it back: edit (file writes only) or ask (chat, no tools).
  • System prompt addendum. Open the options screen, write what you want (tone, formatting, project conventions like "always use vanilla JS and comment like a senior"), hit save — the agent and the coding autocomplete both follow it next message.
  • MCP servers. Plug external tool servers into the agent over Streamable HTTP: open the /mcp screen, paste a server URL (optional bearer token), and its tools list straight into the agent's toolbox — up to 6 servers, 20 tools each. Chips in the composer show what's connected; tool results are flattened to text the agent can reason over.
  • Tools. Every file change shows as a compact diff card in the chat, so you can read what it did.
  • AI playtester. Type /review before you publish: the agent runs your game in the Preview, reads every runtime error it throws (uncaught errors, failed loads, console errors), and reports a checklist — what breaks, what's unwired, and a ready to publish or fix first verdict. It never edits your files during a review.
  • Slash commands for the everyday actions (new chat, clear, help, model, keys), and skills — reusable prompt packs you switch on and off. One teaches it Cudic's conventions; another adds a design sensibility pass.
  • Multiple sessions — /session lists, creates, renames and deletes chats, each keeping its own transcript; you're signed in, they sync to your account automatically. /model is a searchable picker over the providers you've connected, and /connect lists only the providers you haven't set up yet, with every screen having a search bar.
  • Ghost-text autocomplete in the editor works when a key is saved for the model it's using.

It needs to know what you're working on to be useful — open the file you're editing or mention it, and it'll answer about that instead of in generalities.

Account

Your profile at /profile holds the things that follow you: display name, avatar, a short bio, a few interests, accent colour and light/dark preference. Theme, accent and reduced-motion settings are remembered in this browser and applied on every page. Games you've liked are listed there too.

Verifying your email

Email signups get a code by mail and confirm it once. An email account still unverified after 24 hours gets removed automatically with its profile — nothing to chase. GitHub accounts are already verified through GitHub.

One live session

Signing in on a second device takes over the session there — the older device pauses and offers a Take over button to claim it back. In the same browser, your tabs share the seat quietly instead of fighting over it.

Onboarding & leaving

  • The first sign-in walks a short wizard: username, then style — non-skippable, so new accounts always have a name people can find.
  • Sign out from the account row at the bottom of the rail.
  • Delete your account from profile → Security: type a random code and hold the button to confirm. Your profile, projects, saves and the auth user go together.

Bot check

Signing up, resending a code, resetting a password and deleting an account all confirm you are a person first. The check (Cloudflare Turnstile) is invisible for most people — it only asks for a click if Cloudflare is unsure, and it never runs on playing, browsing or browsing games. A server without the keys simply skips it.

FAQ

Why is index.html almost empty after a Scratch import?

It is just the player page. The project is project.json, and scratch.js runs it.

It says I can't save.

You need to be signed in. If a single file is enormous (tens of megabytes on one line), that's usually the problem — keep big media as real files instead of pasting it into text.

My preview is blank.

Check the console panel in the bottom bar. The most common causes are a missing index.html, a typo in a script tag, or an import that couldn't resolve.

The camera/microphone blocks in my game don't work.

Games run sandboxed, so hardware access is off. It's the same reason a game can't read your account.

Studio feels slow the first time.

The workbench is a large download on first visit. After that it's cached and normal.

Are coins real money?

No — they're Cudic's own currency for theme packs. You can't buy them with money or cash them out; you earn them.

Someone is being a problem in a game.

Report the player from the live strip on the game page (signed-in players are reported by account). Guests can't be reported by account — describe what happened in the note and report the game.

Is there something for teachers and parents?

Yes — /parents is a landing page written for teachers and parents: what Cudic costs (nothing), how Classroom laptops handle it, Scratch import for existing lessons, and what moderation looks like. The Cookbook guides double as lesson material.

Limits & known gaps

  • It's a browser: no terminal, no native binaries, no installing system software. Python runs in WebAssembly, npm packages come from a CDN.
  • Scratch blocks aren't translated to hand-written JS — the original project comes across as-is.
  • Guest progress isn't stored, and cloud saves are opt-in per game.
  • Text-to-speech and translate blocks are silent; video sensing is blocked.
  • Editing a Scratch project.json alone doesn't change what's running until you re-import or sync.
  • Dynamic CSS imports (import('pkg/style.css')) can't be lifted — load styles statically.
  • Multiplayer rooms cap at 32 players and 8 KB per message.
  • Imports cap at 25 MB and each cloud save at 100 KB.

Something missing or wrong? Tell us in a server, or report the game or pack and we'll take a look.

Credits

  • Art — Kenney's CC0 game and board-game icon assets, shipped inside Studio's Insert-icon library and used across the site. If the upstream library can't be reached, the picker falls back to the icons shipped with the site.
  • Storage — 250MB per account, counted once per shared file, so a fork of your game costs nothing extra. A save that would go over the budget is refused with the numbers rather than failing quietly.
  • Type — Geist and Geist Mono (Vercel) carry every page.
  • Scratch runtime — TurboWarp's Scaffolding loader, so imported Scratch projects play as themselves.
  • Editor — Studio's workbench is built on the VS Code core (monaco), wired up in the browser.

And to everyone who publishes, remixes, sells packs and reports problems: that's the site. Keep making things.

Server tools

A second owner-and-member toolkit, spread across the server page, its settings pane and /events. Channel types and bookmarks change how a channel behaves; polls, answered questions and the mod overview change what a room can do; backups keep an owner's setup recoverable.

Channel types

Announcement channels let the owner and mods post while everyone else reads; the composer disappears for members. Q&A channels put an Answer action on every message — the asker or a mod marks one resolved, it carries an answered badge, and the channel's answered shelf keeps the resolutions at the top. Chat is the normal room. The type is set per channel in Server settings.

Polls

Owners and mods post a poll into any channel: a question and two to six options. Every member gets one vote, changing it replaces the old one, and an anonymous poll hides who voted while still counting each member once. A poll closes on its date or when a mod closes it, and the bars show counts and percentages. No response ever names another voter.

Bookmarks and the game card

The star in the channel bar saves a channel to a private Bookmarks group at the top of the sidebar — separate from favourites, and only ever visible to you. A server's game card (address and note) appears under its name with a copy button.

Join questions

An owner can ask up to three short questions before someone joins. The invite page shows them above the Join button, every answer is required, and owners and mods read the answers in the moderation overview. Answers are deleted with the membership.

Game feeds

A server can follow a game. When that game publishes an update, one post lands in the chosen channel with a play link. Feeds are owner/mod-managed and capped, so a publish fans out once rather than per member.

Moderation dashboard

/moderate now has a Server moderation section: one card per server you own or moderate, with member and mod counts, warnings (seen and unseen), bans, slow channels, recent audited actions and the latest join answers. It reads reports and server rows only — never a DM.

Backups

Owners can Back up now or turn on a weekly backup. A backup is one JSON file with the server identity, channels, member roles, events, presets, nights, LFG posts, suggestions and prompts; the last four are kept and each is downloadable from Server settings. Restoring is an import, so a backup never overwrites a live server by itself.

Public events and directory artwork

/events lists every upcoming public game night and event across public servers, grouped by day in your timezone. Directory cards show a server's featured artwork when the owner sets one and fall back to the banner otherwise, plus the next public event.

Community pack

Everything a server needs to feel like a place rather than a channel list, on one page: /server-community?sid=…. Members write their own card; owners get prompts, titles, spotlights, warnings and an inactivity read. Nothing here creates a second copy of chat — the roster, votes and nights are their own small tables.

Member cards

Each member can set a nickname, a short status and an intro card with up to four tags, scoped to that server. Nicknames replace the account name on the server's messages. Owners can grant a title, which sits beside the name, and the roster shows how long each person has been a member — including a quiet “anniversary today” on the date they joined. One spotlight per server puts a member and a short blurb at the top of the page.

Prompts and suggestions

Owners set a daily prompt and a weekly topic; both render in the overview with the date they cover. Any member can post a suggestion and vote once on anyone's; owners and mods move each one between open, planned, done and declined.

LFG and nights

LFG posts carry a game, a note, a slot count and an optional start time, and can be removed by their author or a mod. Game nights are scheduled by owners and mods; a night marked public is also a public event, shown on the invite page and on the server's public preview at /preview/<id>.

Warnings, labels and inactivity

An owner can issue a warning with a reason; the member sees it as a banner until they acknowledge it, and the API keeps the record. Content labels on a channel (spoiler, NSFW, art, build, event) show as chips in the sidebar, and a spoiler channel asks before it opens. The inactivity read lists members with no message in 30–180 days; nobody is removed automatically.

Server Kit

Owner tools that change how a server looks and reads, gathered on one pane of Server settings. Every write is owner-only and re-checks the ids against the server, so a channel from somewhere else can never be renamed, reordered or refiled.

Channels

Each channel can carry a four-character icon, up to three tags and a welcome line. The icon replaces the # in the channel list; the welcome line is a quiet system message at the top of the channel, above history, so it never looks like something a member said. The up and down buttons reorder channels and Save channels writes the whole order in one pass. Categories take an icon too.

Server identity

Server tags (up to five) sit under the member count, and the game card adds an address and a short note — play.example.net, “Season 4, whitelist on”. The interface font choice switches the server page to a sans, mono, serif or rounded stack; no webfont is downloaded, so it works offline and adds no third-party request.

Theme presets

A preset stores an accent, a background image and a font under a name, up to eight per server. Apply replaces the server theme; members keep their own cosmetic pack, and the preset never touches their account.

Invite page

Every server has a code, and /join/<code> is a public page with the name, description, tags, member count and rules, plus one Join button. Signing in first is the only requirement to join; the rules gate still applies afterwards. The invite page reads only those fields — member lists and channels are never public.

Inbox, search and home

Three pages read across Cudic without opening each surface one by one. All three are scoped to what you can already open: a search never returns a channel you could not read, and the inbox never lists a DM you are not part of.

Inbox

/inbox puts unread DMs beside every notification kind — mentions, replies, friend requests, invites, event reminders and moderation notices. DMs are unread until you open them in chat; notices stay after being read so the list is still a history. Mark all read clears both the notification rows and your DM read state.

Search

/search looks through messages in your conversations and the public channels of servers you belong to, plus people, public servers and published games. Filter by type with the tabs, or narrow the URL with ?q=. Two characters minimum; results link straight to the conversation or page.

Home

/home is five cards: unread, your servers, upcoming events, your games and what friends are making. Hide on a card remembers that choice on your account, and Show all cards brings it back. Nothing on the dashboard is a new data store — it is the same rows the rest of the site reads.