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.
- 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.
- Open Studio — a VS Code-style workbench with a live preview. Press
Ctrl+Shift+Pfor the command palette. - Build something — write HTML/CSS/JS by hand, import existing files or a whole folder, or bring a Scratch game across.
- 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
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.
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.
The gallery
Browse, search, play, comment, like and remix. Every published game gets a permanent page with its card art and credits.
Creator race
Every unique player who plays one of your games is a point, every week. Top three bank coins and titles at /race.
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
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 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.
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 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.
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.
Project tree
A tree of your files. Right-click a file for commands, and drag in files to import.
Tabs & palette
Full editor with syntax highlighting, find & replace, and every command in Ctrl+Shift+P.
Live page
The real thing, updating on Run. The console at the bottom catches errors and console.log output.
AI panel
Chat with a model about your project. Apply code suggestions straight into files. See Cudic AI.
Commands
| Command | What it does |
|---|---|
Save project Ctrl+S | Saves the workspace to your Cudic account (needs a sign-in). |
| Insert icon | Browse 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 files | Pull a set of files into the workspace, merging over what's there. |
| Import folder | Same, for a whole folder — relative paths are kept. |
| Open from GitHub | Reads a public repo (or one folder of it) into the workspace as a project — see below. |
| Import Scratch project | Turn a .sb3 or a shared Scratch link into a playable Cudic project. See below. |
| Export project as zip | Downloads the whole workspace as a zip. |
| Publish / Unpublish | Puts your project in the gallery, or takes it back out. |
| Set thumbnail | Upload an image, capture the preview, or clear it — that's the card art in the gallery. |
| Open Preview / Run | Runs the project in the preview pane. A .py file runs with Python. |
| Add package / Install Python package | Adds 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
| Command | What it does |
|---|---|
Save project Ctrl+S | Saves the workspace to your Cudic account. |
| Import files / Import folder | Pulls files or a whole folder into the workspace, merging over what's there. |
| Open from GitHub | Reads a public GitHub repo — or one folder of it — into the workspace. |
| Import Scratch project | Turns a .sb3 or shared Scratch link into a playable project. |
| Export project as zip | Downloads the workspace. |
| Publish project / Unpublish project | Puts the project in the gallery, or takes it back out. |
| Set thumbnail | Upload, capture or clear the gallery card art. Games without one get a default Cudic cover, so a card is never blank. |
| Start from template | Drops a starter game (snake, pong, breakout) into the workspace to build from. |
| Delete project | Permanently 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.
| Command | What it does |
|---|---|
| Source control | Opens the repository: status, commit box, branches and history. |
| Save snapshot | Stages 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 version | Picks a snapshot and puts its files back. |
Collab
| Command | What it does |
|---|---|
| Start collab session | Opens a shared room for the current project — see Collab editing. |
| Join collab session… | Asks for a room code and joins that room. |
| Leave collab session | Exits the room and clears the saved code. |
Run & packages
| Command | What it does |
|---|---|
| Open Cudic Preview / Run active file | Runs the project in the preview; a .py active file runs with Python instead. |
| Run Python file | Runs the open .py file in the preview (Pyodide, no real Python needed). |
| Add npm package | Inserts the https://esm.sh import line for a package. |
| Install Python package | Inserts the micropip.install() lines for a package. |
| Insert asset | Browses 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
| Command | What it does |
|---|---|
| Toggle sidebar | Collapse or open the file Explorer column. |
| Leave Studio | Back to the website. |
| Cudic AI: Open chat | Opens the AI panel along the bottom. |
Project files
A project is just a folder of files, and the browser is the only machine:
index.htmlis 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 anindex.html.- Local
.cssand.jssiblings 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.htmlpins 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
.pyfiles 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/.tsxfile to a sibling.jswith a// generated from …header, and pointsindex.htmlat the build output. Edit the source: a.jsyou wrote yourself is never replaced, and the preview builds in memory so you do not have to save first. - A
.d.tsfile is never compiled, socudic.d.tsstays a declaration. - Cudic: Run project tests runs files named
*.test.js(or anything undertests/) in a sandboxed frame. Usetest('name', fn),assert(cond, 'why')andassert.equal(a, b, 'why'); async tests are awaited, and results land in theCudic testsoutput 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.shURLs. Pin a version withpkg@1.2.0if 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
.sb3you've downloaded from Scratch. This is the most reliable route. - Link or id — paste a shared link like
https://scratch.mit.edu/projects/123456789or just the number. You'll be asked to confirm the project is your own or one marked "See inside".
What lands in the workspace
| File | What it is |
|---|---|
index.html | A tiny player page. There's no game code in here. |
scratch.js | The fixed loader that boots the Scratch runtime and plays the project. |
project.json | The editable source. Every sprite, costume, sound and block lives here. |
assets.js | A 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
.sb3file 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 paste | What opens |
|---|---|
owner/repo | That repo's default branch. |
https://github.com/owner/repo | The same thing — full link, with or without .git. |
…/tree/main/games/snake | Just that folder. Use this for a repo holding several games, or one too big for the CDN. |
…/blob/main/games/snake/index.html | The folder that holds the file. |
/studio?github=owner/repo | The 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/…/subfolderlink 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.htmlis 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.comsigns in once and keeps a refreshable token in~/.cudic/config.json. Agents that should not store credentials can setCUDIC_TOKEN=<supabase access token>for a single run instead.- Passwords and email codes:
cudic password reset --email you@example.commails 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-gamescaffoldsindex.html,style.cssandgame.js.cudic push my-gamesaves the folder as a project (creating it the first time, updating it after), andcudic publish my-game --tags puzzleputs it in the gallery.- The project id is written to
.cudic.jsonin the folder, so later pushes and publishes don't need it.cudic listshows your projects;cudic openprints 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 gamesbrowses the gallery,cudic get <id>downloads a game's source (files plus any uploaded assets) with aCUDIC.mdcredit note,cudic forumsandcudic thread <id>read the forums,cudic docs [section]prints these docs as plain text, andcudic shop/cudic shop buy|equiphandle the cosmetics shop. Gallery, forums and docs work signed out. - Studio's snapshots are available too:
cudic snapshotsaves the folder as a project revision,cudic revisionslists them andcudic 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 diffshows what changed since the newest snapshot (or any revision, with--against prev/--against <rev>): added, removed and changed files with sizes.--jsongives 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 pullbrings the saved copy down (keeping a backup of what you had),cudic lslists the files,cudic cat <path>prints one file's code, andcudic pushsends your edits back up.cudic unpublishhides a published project again andcudic rm --yesdeletes it (a plainrmonly tells you what it would delete). - Every
push,pullandrecoversaves the version it is about to overwrite into.cudic-backups/in the folder (newest 10 kept).cudic backupslists them andcudic recover latestputs one back on disk — that's your undo when a push goes wrong. - Profiles are editable from the terminal too:
cudic profileshows your name, bio, follower counts and awards, andcudic profile set --name "..." --bio "..." --interests art,musicupdates 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 printedcudic_…value is the only time it is shown;cudic key listshows creation, last use and revocation, andcudic 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 withoutprojects:writegets a 403 when it tries to save. - Use it as
CUDIC_API_KEY=cudic_…orcudic 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.mjsspeaks 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 withCUDIC_API_KEYin its env. Tools:cudic_list_projects,cudic_get_game,cudic_push_project,cudic_publish_project,cudic_search. - Keys live in the
api_keystable (migrationmigration/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_SECRETinvalidates 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,
jandk(or the arrow keys) move a visible selection through the cards,Enteropens the one you are on,/jumps to the search box andEscapedrops 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, withtype=games|threads|peopleto narrow it, andcudic 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/activitywith 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 (viacudic-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')(viacudic-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. Checkresult.firstto 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"(orCudicTouch.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-touchvalue:auto:A=Space,B=z,D=wasdsets the action buttons and switches the D-pad to WASD.dpad=falseskips it for click-only games. Full options plus theCudicTouch.mount()/hide()/unmount()API are in the platformer guide. - Games need no changes: a press sends one
keydown, a release onekeyup(withkey,codeandkeyCode), 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].pressedand.valueare standard Gamepad API values.- Events:
CudicPad.on('buttondown', fn)/'buttonup'/'axischanged'/'connect'/'disconnect'.CudicPad.start()/stop()control the polling loop;CudicPad.supportedis 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.
Your spaces
Create a server from Servers and pick its starting channels — add more later. A server can post rules members acknowledge once.
Owner · admin · member
Admins manage channels and members; members chat. Owners carry the keys.
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.
- Open a game from the gallery. Games that support it show a live strip with the head-count and how to join.
- Pick a room code if the game offers one; the default room everyone lands in is
main. - 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.
Players per room
The room cap per game — a server keeps any third player list honest.
Message size cap
Small packets only, so a game can't flood a room with data.
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.
- 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. - 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. - 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 sessionis the real exit.
People per room
A WebRTC mesh — every peer is in your browser, not on a relay server.
Server load
The public signaling servers only broker each handshake; nothing after that flows through Cudic.
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.
- 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.
- Follow. The button flips to Following ✓; unfollowing is one click and silent — nobody finds out either way.
- Watch the feed. The Activity card shows the latest 60 moves from you and everyone you follow, with dates and links to their pages.
Follow ≠ friend
Friends are mutual and approved. Follows are silent subscriptions — no request, no notification.
Feed depth
The feed keeps the newest 60 events. Publishes and awards you earned stay; rooms and chats never appear here.
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.
- 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.
- Build and publish anything made in Studio that fits the theme — mark it with the theme tag so it shows up as an entry.
- 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.
Votes
One vote per person each week (server-enforced). You can swap it until the week ends.
Roll over
A new theme is picked Monday automatically — none repeated from the week before.
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.
- 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.
- 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.
- 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.
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.
Weekly clock
Monday 00:00 UTC reset, prizes bank through the coins ledger (reason race:<week>), titles and badges land as normal awards.
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.
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.
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).
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.
- 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.
- Click to equip. Equipped cells get the lime ring and show up instantly in the profile preview on the right.
- 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
- Open the builder on Themes — pick colours, fonts, icon style, motion level and a scene. Changes preview as you make them.
- Advanced — paste a
.ctheme(a small text language for packs), plus your own CSS and HTML for the really specific bits. - 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
- Browse on /shop. Every item shows its price, and the balance in the header updates as you spend.
- 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.
- 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).
- 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
/modeto 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
/mcpscreen, 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
/reviewbefore 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 —
/sessionlists, creates, renames and deletes chats, each keeping its own transcript; you're signed in, they sync to your account automatically./modelis a searchable picker over the providers you've connected, and/connectlists 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.jsonalone 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.