wellingfeng/UltraGameStudio

In a game engine, code is only a small part of the work. The rest is assets and pipeline — materials, blueprints, terrain, sky, UI, skeletal animation, packaging, performance. UltraGameStudio is a Claude Code / Codex / Gemini style agent rebuilt around that reality: it understands game-engine concepts, generates the full range of game assets (images, 3D models, 2D sprite animation, atlases, audio, rigging, video), and routes routine work through free or low-cost channels so premium quota goes where it matters.

English  ·  中文  ·  Français  ·  Deutsch  ·  Español  ·  Português  ·  Русский  ·  日本語  ·  한국어  ·  हिन्दी  ·  العربية  ·  Discord  ·  QQ Group: 149523963

Thanks to API NODE for sponsoring this project! API NODE is an AI API gateway that provides stable, cost-effective relay access to Claude Code, Codex, Gemini, and other leading models through a single endpoint — a great fit for routing UltraGameStudio requests through one reliable provider. Register via this link.

One-click Unreal Engine UMG interface

One-click 3D model generation

Image, sprite, mesh, audio, rigging, and video — all managed through one coding agent

Game-asset generation in the same session as your code

AI is now good enough to write most of the code on its own. In practice the programmer's role is shifting toward describing intent, verifying output, and orchestrating agents. But a game is not just code. A game engine is full of materials, blueprints, terrain, sky, UI, skeletal animation, packaging, and performance tuning — and most general coding agents have no idea what any of that means.

UltraGameStudio takes a Claude Code / Codex / Gemini style agent and customizes it deeply for game development:

• Speaks game-engine language. The agent is primed with game-development concepts so it can reason about materials, blueprints, terrain, lighting, UI (UMG and others), skeletal animation, build/packaging, and performance optimization — not just generic source files.
• Generates every asset type a game needs. Images, 3D models, 2D sprite animation, sprite atlases, audio, skeletal rigging, and video are all produced from the same chat surface and managed through one coding-agent workflow.
• Built-in game-dev expert roster. 40+ specialist roles (technical director, gameplay/AI/network/tools programmer, level/economy designer, art and audio directors, QA, release manager, and more) span Unity, Unreal, Godot, and Web engines.
• Keeps premium quota for what matters. Route routine work through free, trial-credit, or low-cost channels, and keep keys, settings, and history local.

• Ask for gameplay code, engine integration, shader/material logic, build scripts, bug investigation, refactors, tests, and release notes.
• Work against Unity, Unreal, Godot, or Web engine projects — the agent reasons about engine concepts, not just files.
• Attach file paths or drag files into the composer.
• Review streamed assistant output, command logs, file references, and generated summaries in one chat surface.
• Continue with follow-up requests in the same session.

Every asset type a game needs can be generated from the same chat surface and applied to your project, then handed back to the coding model — all in one session history. Each generator runs through your configured provider.

The agent first polishes your prompt, sends it to the configured provider, and shows the result in the chat stream with the prompt and provider details. Leave any mode with its matching *-mode-end command.

UltraGameStudio ships a roster of 40+ game-development specialists that the agent can draw on automatically based on the task:

• Engine specialists for Unity, Unreal, Godot (GDScript / C# / GDExtension / shaders), and Web.
• Programming roles: technical director, lead/engine/gameplay/AI/network/tools/UI programmers.
• Design roles: game, level, economy, live-ops, and narrative designers.
• Art & audio directors and specialists, VFX, sound design, and audio direction.
• Production, quality, and release: producer, QA lead/tester, devops, security, localization, and release manager.

Configure the active engine, council mode, and which experts are enabled in Settings.

• 20+ remote channels plus local runtimes: NVIDIA NIM, OpenRouter, GitHub Models, Hugging Face Router, SambaNova Cloud, Together AI, Google Gemini, DeepSeek, Mistral, Mistral Codestral, OpenCode, Wafer, Kimi, Cerebras, Groq, Fireworks, Z.ai, LLM7, Kilo Gateway, plus local runtimes such as Ollama, LM Studio, and llama.cpp.- Keyless experimental routes: LLM7 and Kilo Gateway can be tried without an API key, but should only be used for non-sensitive coding prompts.
• Official free/trial-credit routes: GitHub Models, Hugging Face Router, SambaNova Cloud, Together AI, Gemini, Groq, Cerebras, NVIDIA NIM, OpenRouter, Mistral/Codestral, DeepSeek, Kimi, Z.ai, OpenCode, Wafer, and Fireworks use provider keys kept locally in the app.
• Local Rust proxy translates between Anthropic and OpenAI-compatible protocols.
• Claude Code can route through configured free channels without changing the chat UI.
• Provider keys, model overrides, and local model settings are managed from the app settings.

Free channel routing

Current default coding-oriented models:

For complex multi-step coding tasks, /studio <task> generates a purpose-built execution harness on the fly and runs it immediately — no visual canvas needed.

• Describe the task in natural language. The planner builds a harness with parallel subagents, adversarial verification, and acceptance gates.
• Six internal strategies are chosen automatically: classify-and-act, fan-out-and-synthesize, adversarial-verification, generate-and-filter, tournament, and loop-until-done.
• Every run is fully logged under .ugs-run/<run-id>/ with a task ledger, events, verdict, and final result.
• Run from the desktop app or the CLI: ugs studio "<task>" --json --interactive --cwd <workspace>.
• Zero config — reuses local claude CLI login credentials.

The Auto channel (freecc:auto in the Channel menu) routes each request through the best currently available free channel without manual switching.

• Rotates through all configured free channels, automatically skipping channels that hit rate limits (429) or return upstream errors (5xx).
• Tracks per-channel cooldowns with backoff: when a channel returns an error, it is paused for a cooling period before being retried.
• Supports an optional model override so all auto-routed requests use the same model regardless of which channel handles them.
• If all channels are exhausted, returns a 503 with the failure log so you can diagnose the outage.

When using /studio, the harness can chain multiple providers across plan steps automatically. A typical pattern: let DeepSeek produce responsive drafts with low cost, then let CodeX pick up and refine the output for final quality.

• The Dynamic Harness plan supports per-step model overrides — assign DeepSeek to brainstorming/classification steps and CodeX/Gemini to implementation/verification steps.
• cc-switch compatibility: UltraGameStudio reads cc-switch CLI config so any provider already configured for Claude Code routing is immediately available for studio steps.
• Fan-out-and-synthesize strategy parallelizes DeepSeek workers across independent subtasks, then a consensus gate (CodeX) synthesizes and verifies the results.

The free proxy auto channel prioritizes channels based on real-world availability signals:

• Rate-limit awareness: Channels returning 429 are cooling for 30+ seconds before retry, preventing wasted attempts on saturated upstreams.
• Fail-fast on errors: Non-retryable errors (4xx auth failures, 5xx upstream down) are tracked per-channel with cooldowns; the auto router skips them for the current request.
• Connection-time budget: Each channel attempt is subject to the upstream's timeout; the auto router cycles through candidates without blocking on a single slow upstream.
• Natural ordering by responsiveness: Channels that succeed leave the cooldown registry empty and are naturally tried first; channels with errors are deferred to the end of the candidate list.

These features work together so /studio harness runs stay resilient even when individual free providers are slow, rate-limited, or temporarily unavailable.

• Sessions, favorites, scheduled prompts, API keys, and workspace history are stored locally.
• No hosted UltraGameStudio server is required.
• The desktop app can use local CLI credentials and local model runtimes already available on your machine.

Run the web app from app/:

cd app
npm install
npm run dev

Vite starts at http://localhost:5173.

Run the desktop app:

cd app
npm run desktop

Build a production desktop package:

cd app
npm run package

From the repository root:

./run.sh        # macOS/Linux: rebuild if needed, then launch
./package.sh    # macOS/Linux: build native bundles (.dmg on macOS)
run.bat         # Windows: rebuild if needed, then launch
build.bat       # Windows: package the NSIS installer

1. Open the bottom Channel menu and choose a free channel with a warning mark, for example Free · OpenRouter.

1. In the API key dialog, click Open registration site.

1. Create a new API key on the provider page, then copy it.

1. Paste the key back into UltraGameStudio and click Save and Use. After saving, the warning mark disappears from that channel.

1. You can also manage every free channel from Settings -> Channels -> Free Channels. Channels marked Ready have the required configuration.

After the channel is ready, use the bottom input to chat through that route. See the free channel registration guide for the full Chinese walkthrough.

Asset modes turn the chat composer into an asset-generation surface while keeping the same session history. They are useful for producing UI mockups, icons, textures, sprites, 3D models, audio, and video, then switching back to coding in the same conversation. Image mode is the example below; sprite, mesh, music, speech, and video modes work the same way with their own *-mode-start commands.

1. Open Settings -> Images (or the matching asset section), choose a default provider, and fill in the required API key, account ID, base URL, or local ComfyUI endpoint. Providers with complete configuration are available from the composer in that mode.

2. Start a chat session and type /image-mode-start. You can also start and generate in one message, for example:

   /image-mode-start a stylized stone-wall texture for a fantasy dungeon, tileable, 1024x1024
   

3. While the mode is on, ordinary messages generate assets instead of running coding edits. The bottom Channel selector switches to asset providers, and the model selector appears when model selection is enabled.

4. Describe the asset you want. UltraGameStudio first asks the coding model to polish the prompt, then sends it to the configured provider. The result appears in the chat stream with the prompt and provider details.

5. Send /image-mode-end to return to the normal coding channel and model. If you only need one asset without staying in a mode, send a one-shot command such as /image, /img, /draw, /生图, /sprite, /music, or /video followed by the prompt.

User request
    |
    v
Chat composer
    |
    +--> selected runtime / channel / permission / workspace
             |
             +--> direct provider API, local CLI, or local free-channel proxy
                        |
                        +--> streamed assistant output, tool log, and chat history

Free-channel proxy:

• Runs locally and binds to 127.0.0.1:<port>.
• Routes each channel through http://127.0.0.1:<port>/ch/<channelId>.
• Translates Anthropic and OpenAI-compatible streaming protocols.
• Lets Claude Code use non-Anthropic and local providers through the same gateway path.

app/
  src/
    components/  Shared UI and rich assistant-message rendering
    lib/         Provider settings, free-channel routing, asset generation
                 (image, sprite, mesh/3D, music, speech, video, ComfyUI),
                 game-dev expert roster, persistence helpers
    panels/      Sidebar, chat dock, settings, scheduling UI
    store/       Zustand state and local history
  src-tauri/
    src/
      free_proxy.rs    Rust reverse proxy + Anthropic/OpenAI translation
      lib.rs           Tauri commands, filesystem/history bridge
  doc/                 Tutorials, localized READMEs, screenshots
backend/              Remote execution backend for cloud Runner jobs
packages/protocol/    Shared remote API types, status constants, Runner HTTP/SSE SDK
docs/                  Research notes, static docs, assets
pencil/                Pencil design files

• Free channel registration guide - Chinese walkthrough for creating and saving a free-channel API key.
• Chinese README

Useful commands from app/:

npm run dev        # Vite dev server
npm run typecheck  # TypeScript check without emitting files
npm run lint       # ESLint for .ts and .tsx files
npm run test       # Vitest suite
npm run desktop    # Tauri development mode
npm run package    # Production Tauri build

• Discord: https://discord.gg/2C9ptSEFG
• QQ Group: 149523963
• Issues: https://github.com/wellingfeng/UltraGameStudio/issues
• Repository: https://github.com/wellingfeng/UltraGameStudio

Pull requests should describe the behavior change, list verification commands, link related issues, and include screenshots or short recordings for UI changes.

MIT. See LICENSE.