The recommended way. One Claude Code plugin carries the skill and the MCP
server, machine-wide:
```bash
claude plugin marketplace add thrixel/build-world
claude plugin install thrixel@thrixel
```
Confirm both pieces landed:
```bash
claude plugin list # thrixel@thrixel -> enabled
claude mcp list # plugin:thrixel:thrixel -> Connected
```
Then start a session. Run this wherever you keep projects - Claude makes the
project folder itself:
```bash
claude --permission-mode auto
```
Into Claude Code, not the terminal:
```bash title="In Claude Code"
# [!code word:/thrixel\:build-world]
/thrixel:build-world build a submarine exploration game in three.js set in a bright,
vibrant tropical sea with coral and fish
```
Updates are off by default for third-party plugins. Turn them on once: type
`/plugin`, open **Marketplaces** > **thrixel**, choose **Enable auto-update**.
If you skip this, the skill notices a newer version and tells you to run
`/plugin update thrixel@thrixel`.
Prefer to install the two pieces yourself?
Skip the plugin and register each half directly. The start command is the same
either way.
```bash
# macOS, Linux, WSL
# 1. The connector. --scope user covers EVERY project, not just this folder.
claude mcp add --scope user thrixel -- uvx thrixel-mcp@latest
# 2. The skill. Clone rather than download, so it can update itself later.
git clone https://github.com/thrixel/build-world ~/.claude/skills/thrixel
```
```bash
# Windows PowerShell
# The path is quoted because ~ is not expanded when PowerShell hands it to git,
# and a skill that lands anywhere else is invisible to Claude.
claude mcp add --scope user thrixel -- uvx thrixel-mcp@latest
git clone https://github.com/thrixel/build-world "$HOME\.claude\skills\thrixel"
```
Confirm:
```bash
claude mcp list # thrixel -> Connected
ls ~/.claude/skills/ # thrixel listed
```
Update the skill later with:
```bash
git -C ~/.claude/skills/thrixel pull
```
Switching from a manual install? Remove the old copies
The plugin carries both pieces, so an earlier manual install is now a duplicate
and the two collide. Remove it once.
```bash
# macOS, Linux, WSL
claude mcp remove thrixel
rm -rf ~/.claude/skills/build-world ~/.claude/skills/goal-to-game ~/.claude/skills/thrixel
```
```bash
# Windows PowerShell
claude mcp remove thrixel
Remove-Item -Recurse -Force "$HOME\.claude\skills\build-world","$HOME\.claude\skills\goal-to-game","$HOME\.claude\skills\thrixel"
```
Codex reads Claude Code plugins natively, so the install mirrors Claude Code:
```bash
codex plugin marketplace add thrixel/build-world
codex plugin add thrixel@thrixel
```
Confirm both pieces landed. `codex plugin list` also prints OpenAI's curated
catalog, so read the `Marketplace thrixel` block at the top rather than the long
list under it:
```bash
codex plugin list # thrixel@thrixel -> installed, enabled
codex mcp list # thrixel -> enabled
```
The plugin reports its version as `local`, which is expected: it is versioned by
commit rather than by a version number.
Start a **new** Codex session - a plugin installed mid-session is not picked
up. Run this wherever you keep projects:
```bash
codex --sandbox workspace-write --ask-for-approval never
```
That lets Codex work without a prompt on every step while keeping its sandbox
on. Plain `codex` prompts per action, which stalls a long build.
Then start the line with `$build-world` and describe the game:
```bash title="In Codex"
# [!code word:$build-world]
$build-world build a submarine exploration game in three.js set in a bright,
vibrant tropical sea with coral and fish
```
Insert the skill, do not paste it
Type `$build` and press **Enter** to pick `build-world` from the list, then write
the description after it. Pasting the whole line at once does not run the skill:
Codex only treats it as one when it is inserted from that picker, and the
giveaway is the colour - an inserted skill turns blue, pasted text stays plain.
Codex asks before every Thrixel call? Approve the server once
Codex gates MCP tools separately from the commands it runs itself, so the launch
flags above do not reach them. **Always allow** approves one tool at a time, and
Thrixel ships dozens. This covers the whole server in one go:
```bash
grep -q 'thrixel@thrixel".mcp_servers' ~/.codex/config.toml || printf '\n[plugins."thrixel@thrixel".mcp_servers.thrixel]\ndefault_tools_approval_mode = "approve"\n' >> ~/.codex/config.toml
```
The `grep` guard matters: appending the same table twice is a TOML duplicate key,
and Codex then refuses to start at all rather than ignoring the second copy.
Check it landed with `codex mcp get thrixel`, and run it again after any
`codex plugin remove` / `add` cycle - reinstalling the plugin rewrites that part
of the config and drops the setting. Skip the setting and a headless
`codex exec` run does not even prompt: the call is cancelled and the agent
carries on without Thrixel.
Prefer to install the two pieces yourself?
Also the path to take on a Codex build without plugin support. The command is the
same either way: `$build-world`.
```bash
# 1. The connector, then two settings on it: a startup timeout that survives a
# uvx cold start (Codex allows 10s), and no approval prompt per tool call.
codex mcp add thrixel -- uvx thrixel-mcp@latest
grep -q startup_timeout_sec ~/.codex/config.toml || printf '\nstartup_timeout_sec = 60\ndefault_tools_approval_mode = "approve"\n' >> ~/.codex/config.toml
# 2. The skill, linked where Codex looks for it.
git clone https://github.com/thrixel/build-world ~/.thrixel/build-world
mkdir -p ~/.agents/skills
ln -s ~/.thrixel/build-world/skills/build-world ~/.agents/skills/build-world
```
Confirm:
```bash
codex mcp list # thrixel listed
ls ~/.agents/skills/ # build-world listed
```
Update the skill later with:
```bash
git -C ~/.thrixel/build-world pull
```
Cursor has no CLI for either piece, so both are files you write once. It reads
the same `SKILL.md` the agents above use.
```bash
# 1. The connector. This writes the file only if you do not have one. If you
# already have ~/.cursor/mcp.json, add the "thrixel" entry to your own
# "mcpServers" instead - the guard below is silent, not an error.
mkdir -p ~/.cursor
[ -f ~/.cursor/mcp.json ] || cat > ~/.cursor/mcp.json <<'JSON'
{
"mcpServers": {
"thrixel": {
"type": "stdio",
"command": "uvx",
"args": ["thrixel-mcp@latest"]
}
}
}
JSON
# 2. The skill.
git clone https://github.com/thrixel/build-world ~/.thrixel/build-world
mkdir -p ~/.cursor/skills
ln -s ~/.thrixel/build-world/skills/build-world ~/.cursor/skills/build-world
```
Restart Cursor. Type `/` in the Agent chat and `build-world` should be in the
list; the connector appears under **Settings** > **MCP** as `thrixel`.
Then pick `build-world` and describe the game:
```bash title="In Cursor"
# [!code word:/build-world]
/build-world build a submarine exploration game in three.js set in a bright,
vibrant tropical sea with coral and fish
```
On Windows, without WSL
Same two steps in PowerShell. Step 2 uses a junction rather than a symlink
because symlinks need Developer Mode and junctions do not.
```powershell
# 1. The connector. Merge the entry by hand if you already have this file.
New-Item -ItemType Directory -Force "$HOME\.cursor" | Out-Null
if (-not (Test-Path "$HOME\.cursor\mcp.json")) {
'{"mcpServers":{"thrixel":{"type":"stdio","command":"uvx","args":["thrixel-mcp@latest"]}}}' | Set-Content "$HOME\.cursor\mcp.json"
}
# 2. The skill.
git clone https://github.com/thrixel/build-world "$HOME\.thrixel\build-world"
New-Item -ItemType Directory -Force "$HOME\.cursor\skills" | Out-Null
New-Item -ItemType Junction -Path "$HOME\.cursor\skills\build-world" -Target "$HOME\.thrixel\build-world\skills\build-world"
```
Already set up for Claude Code or Codex?
Cursor also reads `~/.claude/skills/` and `~/.agents/skills/`, so a skill you
installed for either agent is already visible here. Only step 1 is left to do.
Cloud Agents and remote SSH need a project install
Cursor does not carry user-level skills into a Cloud Agent or a remote SSH
session, so an install under your home directory is invisible there. Put the
skill in the repository instead, and commit it:
```bash
mkdir -p .cursor/skills
git clone --depth 1 https://github.com/thrixel/build-world /tmp/build-world
cp -R /tmp/build-world/skills/build-world .cursor/skills/build-world
rm -rf /tmp/build-world
```
The connector goes in `.cursor/mcp.json` in that same repository, with the JSON
from step 1.
Updating the skill
```bash
git -C ~/.thrixel/build-world pull
```
Gemini CLI reads the same skill format and can install it straight from the
repository:
```bash
# 1. Register the MCP server for every project. --trust means Gemini runs the
# Thrixel tools without asking for confirmation on every call.
gemini mcp add -s user --trust thrixel uvx -- thrixel-mcp@latest
# 2. Install the skill from the repo.
gemini skills install https://github.com/thrixel/build-world --path skills/build-world
```
Start a new session wherever you keep projects:
```bash
gemini --approval-mode=yolo
```
Gemini asks whether to trust the folder the first time it opens one. Say yes: in
an untrusted folder it quietly downgrades `--approval-mode=yolo` back to
prompting on every tool call.
That auto-approves tool calls for the whole session. `--approval-mode=auto_edit`
is the middle ground: file edits go through, shell commands still ask.
Confirm both pieces from inside it:
```text
/mcp # thrixel listed
/skills list # build-world listed
```
An installed skill registers as its own slash command, so start with
`/build-world` and approve it when Gemini asks:
```bash title="In Gemini CLI"
# [!code word:/build-world]
/build-world build a submarine exploration game in three.js set in a bright,
vibrant tropical sea with coral and fish
```
Gemini also activates skills from their description, so if the command does not
appear, describe the game and name `build-world` in the sentence instead.
Any agent that speaks MCP can run it. The connector is a plain stdio server and
the skill is a folder with a `SKILL.md`, so both go in by hand.
First the connector. Add it to your agent's MCP settings; most agents take this
JSON as it is. If you already have servers, merge the `thrixel` entry into them.
```json
{
"mcpServers": {
"thrixel": {
"type": "stdio",
"command": "uvx",
"args": ["thrixel-mcp@latest"]
}
}
}
```
Then the skill. `~/.agents/skills` is the shared folder many agents read.
```bash
git clone https://github.com/thrixel/build-world ~/.thrixel/build-world
mkdir -p ~/.agents/skills
ln -s ~/.thrixel/build-world/skills/build-world ~/.agents/skills/build-world
```
Restart the agent so it loads both. If it lists skills, start with
`build-world`. If it has no skill support, name the file instead; that works in
any agent:
```bash title="In your agent"
Read ~/.thrixel/build-world/skills/build-world/SKILL.md and follow it to build
a submarine exploration game in three.js set in a bright, vibrant tropical sea
with coral and fish
```
Update the skill later with:
```bash
git -C ~/.thrixel/build-world pull
```
### The command
| agent | command |
|---|---|
| Claude Code | `/thrixel:build-world` |
| Codex | `$build-world` |
| Cursor | `/build-world` |
| Gemini CLI | `/build-world` |
## What happens next
Your agent checks your Thrixel account, plans the assets the game needs, and
starts building. Keep talking to it in plain English to change things.
Give it the most capable model you have access to, with reasoning effort set to
high or above. In Claude Code that is `/model` set to Opus 5 or better; every
other agent has the same picker in its chat panel. Planning a coherent asset
list and wiring a scene together is where a weaker model shows.
## Manage your assets
Assets appear in your [Thrixel workspace](https://thrixel.com/create) as they
generate, so you can view, edit, and reuse them across projects and engines.
## Usage and credits
You can test this workflow using the free Thrixel Cubes included with your
Starter account. However, building a full-scale game generally requires a wider
variety of assets and rapid iteration that usually exceeds Starter limits.
Upgrading to a [Paid Plan](https://thrixel.com/create/#upgrade) unlocks higher
parallel job processing capacity and higher generation limits, allowing you to
bring your most ambitious ideas to life. You can keep track of your remaining
Cubes anytime in
[Account Settings](https://thrixel.com/create/#settings/billing).
---
# CLI
Source: https://docs.thrixel.com/cli
import { Callout } from 'fumadocs-ui/components/callout';
import { Accordion, Accordions } from 'fumadocs-ui/components/accordion';
`thrixel` makes 3D models from a terminal. One command takes a description to a
finished model on disk, and every tool the [MCP server](/mcp) gives an agent is
one `thrixel run` away. It ships in the same package as the MCP server and
shares its sign-in.
```bash
thrixel make "a mossy stone frog statue, squat, cracked grey stone" -o frog.glb
```
## Install
Requires [uv](https://docs.astral.sh/uv/getting-started/installation/).
```bash
uv tool install thrixel-mcp
```
| Task | Command |
|---|---|
| Update | `uv tool upgrade thrixel-mcp` |
| Uninstall | `uv tool uninstall thrixel-mcp` |
| Check the version | `thrixel --version` |
| Run once without installing | `uvx --from thrixel-mcp@latest thrixel