A Custom AI Coding Tool Built for the Game Industry

wei feng — Sun, 14 Jun 2026 10:13:57 +0000

I have spent more than 15 years in the game industry. With the rapid progress of large language models over the past couple of years, AI has become capable enough to write code largely on its own. The role of the programmer is increasingly shifting toward feeding requirements to the AI, validating its output, and orchestrating agents.

But code is only a small part of a game engine. Far more of the work lives in assets and pipelines. So I wanted to take tools like CodeX and Claude Code and deeply customize them for game development — teaching the model what a material is, what a blueprint is, and how to handle terrain, sky, UI, skeletal animation, packaging, performance optimization, and more. To that end, I heavily refactored the AI coding tool I use day to day and built in a large number of game development workflows.

If you're interested, take a look: https://github.com/wellingfeng/FreeUltraCode

One-click generation of Unreal Engine UMG interfaces.

One-click model generation.

It already integrates image generation, 3D model generation, 2D sprite animation, sprite sheets, audio, skeletal rigging, video, and more — unifying the management of every kind of asset a game might need through a coding-focused large language model.

FreeUltraCode: An AI Coding Tool with 20+ Free LLM Channels

wei feng — Sat, 06 Jun 2026 01:05:21 +0000

I've been a game developer for over a decade — Unity C#, Unreal C++, a few custom engines. Last year I started using Claude Code and Codex CLI heavily. Not for "write me a sorting function" stuff. I'm talking about having it read an entire rendering pipeline, modify logic across a dozen files, add physics debug tooling, fix multi-threaded race conditions.

Claude Code is legit. It reads the project structure first, traces the call graph, then makes changes. Runs the build, catches errors, debugs itself, iterates until it passes. Codex is sharp too — especially when GCC spits out a wall of C++ template errors, it translates the noise into human-readable diagnostics.

But the bills are brutal.

Dynamic Workflows Are Powerful. So Is the Bill.

Let me explain Claude Code's Dynamic Workflows — they're not a "paid feature." They're a built-in execution system. You write a .js script using agent(), parallel(), pipeline(), consensus(), and Claude Code orchestrates the run — sequential, parallel, voting, gating, fully automatic.

Here's a simple code review workflow:

parallel([
  agent("scan for potential bugs"),
  agent("check for security vulnerabilities"),
  agent("review performance hot spots"),
  agent("assess maintainability"),
]);
consensus([...], { strategy: "multi-lens" });

Four agents scanning in parallel, one consensus node aggregating votes. Clean.

But scale this up and it becomes a compute black hole. One parallel block with 5 agents, a pipeline with 3 stages, each stage spawning 5 more — three levels deep and you've got 75 agents running. Each agent makes independent API calls, reads files, reasons, outputs. A single complex refactor can easily spawn dozens or hundreds of agents. Thousands of API calls. One run.

Dynamic Workflows themselves don't cost extra. But it's a "more agents = more tokens" architecture — cost scales linearly with agent count. Run 100 Claude agents on a major refactor, and the token bill will blow through your monthly budget regardless.

The real tension: multi-agent orchestration is essential, but paying premium rates for an entire agent army isn't sustainable.

Free Models Are Everywhere — But Scattered

I've got API keys for these free/low-cost channels:

GitHub Models — free playground access with rate limits, needs a GitHub token (models:read scope)
Hugging Face Router — free monthly Inference Provider credits
SambaNova Cloud — Free Tier, no payment method required, daily request/token caps
Together AI — free trial credits on signup
Groq — free tier, genuinely fast inference
Gemini — Google free tier
DeepSeek / Kimi — dirt cheap
NVIDIA NIM / OpenRouter / Mistral / Cerebras / Fireworks / Z.ai — each with free or trial access
LLM7 / Kilo Gateway — keyless channels, just works
Local: Ollama / LM Studio / llama.cpp

Plenty of options. But every single one requires separate registration, key management, and environment variables. Want to try Groq today? Dig through emails for the key. Want SambaNova's DeepSeek-V3.1 tomorrow? Another round of setup.

And here's the real problem: having a cheap model doesn't mean it writes good code. Free models fall short on single-pass quality compared to Claude Code or Codex — shallower reasoning, context drift on long files, sloppy on complex refactors. That's why most people hoard free keys but still pay Claude at the end of the month.

What I wanted to solve: use free/cheap models, orchestrated through workflows, to produce code quality on par with Claude Code and Codex. One cheap model can't compete. But put five of them on an assembly line — planning, executing, reviewing, cross-verifying — and the quality gap closes through structure and collaboration.

FreeUltraCode: One Dropdown, All Channels

FreeUltraCode is a local desktop app (Tauri 2 + Rust, source on GitHub). What it does is dead simple:

A dropdown menu to switch channels.

The Channel selector at the bottom lists every channel you've configured. Pick one, conversations flow through it. Setup takes three steps: select channel → click "Register" to get a key from the provider's site → paste it back. Status turns green. Done.

No proxy/VPN required, no registration handled for you, no keys stored on any server. All config, chat history, and API keys stay on your machine.

Crucially: switch channels mid-session, context is preserved. File references, intermediate conclusions, tool outputs — all carried over when you switch. No need to re-feed context.

Real-World Usage (Game Dev)

Task: "Add a climbing system to this third-person character controller"

Step 1 → Switch to GitHub Models / Groq
  Scan project structure, locate CharacterMovement, Input, Animation layers
  Read relevant code, list existing interfaces and what needs changing
  (free models handle this fine)

Step 2 → Switch to Claude Code / Codex
  Core logic — add Climbing state to the state machine,
  change physics queries from Raycast → CapsuleTrace,
  add BlendSpace to the animation blueprint
  (premium models for architectural decisions)

Step 3 → Switch to Together AI / DeepSeek
  Write tests, run lint, generate comments, draft commit messages
  (high volume, low complexity — free channels in parallel)

Step 4 → Switch back to Claude Code
  Final review — walk through all changes, check edge cases,
  confirm network sync logic isn't missing
  (quality gate needs a reliable model)

Free Auto: Let the Tool Handle Channel Switching

Manual switching works when you know which model fits the task. Sometimes you don't want to think about it. CI fails a linting task at 2 AM — you just want any free channel to fix it and stop bothering you.

That's where the Auto channel comes in (freecc:auto, first option in the dropdown). It's not a fixed upstream — it's a smart router:

Configure keys for however many free channels you want
Switch to Auto, send requests
The proxy cycles through channels — first one to return a valid response wins
Hit a 429 (rate limit)? Auto-skip, 30-second cooldown before retry
Hit a 5xx (upstream down)? Mark as failed, skip for this round
All channels exhausted? Returns 503 with a failure log showing what died and why

Connection timeouts are budgeted — no hanging on a single slow upstream. Channels that succeed are naturally prioritized (clean cooldown state); problematic ones get pushed to the back.

Net effect: fire a request, get a result, channel switching is invisible. Configure 8 channels, and Auto becomes an 8-channel failover pool — one goes down, the next picks up.

Auto can also lock a model. Set a model override like z-ai/glm-5.1 in Settings, and regardless of whether Auto routes to Groq, Together, or DeepSeek, they'll all be asked to run the same model. Useful when you know what model quality you want.

Real scenario (game dev):

2 AM. CI is red. A lint error from a Claude Code session.
You're asleep, but FreeUltraCode's scheduled task is still running.

Auto channel attempts:
  GitHub Models → 429, skip, 30s cooldown
  Groq → works, fixes it in minutes
  (DeepSeek, Together, HuggingFace never even get touched)

Wake up. CI is green. Commit is done.
You don't know whether Groq or DeepSeek fixed it.
You don't need to know.

Local Proxy: No Global Config Changes, Multiple Lines Simultaneously

Tools like cc-switch solve the same problem, but they do it by modifying Claude Code's global environment variables — switch channels, change ANTHROPIC_BASE_URL. That means you can only use one channel at a time, and it affects everything globally. Open a second terminal window, same channel applies.

FreeUltraCode takes a different path. It runs a Rust-based local reverse proxy on 127.0.0.1, routing by port path. Claude Code doesn't need any config changes — it thinks it's still talking to Anthropic's official API:

Claude Code → 127.0.0.1:8766/ch/official     → Anthropic official
Claude Code → 127.0.0.1:8766/ch/deepseek     → DeepSeek
Claude Code → 127.0.0.1:8766/ch/kimi         → Kimi
Claude Code → 127.0.0.1:8766/ch/auto         → Free Auto smart routing

Each channel maps to its own port path, no interference. You can run official Claude, DeepSeek, and Kimi Claude Code sessions all at once. The proxy handles Anthropic ↔ OpenAI protocol translation — if the upstream speaks OpenAI (Groq, Together, DeepSeek), the proxy translates; if it natively speaks Anthropic (Kimi, Z.ai), it passes through.

Even better: dynamic channel switching within a single Claude Code session. Claude Code reads ANTHROPIC_BASE_URL from the environment on every call — FreeUltraCode's gateway injects this value per-request. Which means:

Round 1:
  DeepSeek scans project structure, finds the issue → cheap

Round 2:
  Switch to Claude official → precise fix

Same session, full context preserved.

No restarting the terminal. No re-feeding file references and intermediate conclusions. DeepSeek for problem identification, Claude for the actual fix — each doing what it's best at, costs under control.

	cc-switch	FreeUltraCode
Config approach	Modify global env vars	Gateway + port forwarding, no global changes
Multiple simultaneous channels	❌ One channel at a time	✅ Different terminals, different channels
Same-session dynamic switching	❌ Requires config change + restart	✅ Dynamic base URL injection per API call
Protocol translation	Depends on upstream compatibility	Rust proxy with built-in Anthropic↔OpenAI translation

/ultracode: Cheap Models, Premium Output

This is the core of FreeUltraCode. One-line natural language task, auto-generated execution plan, parallel sub-agents — planning, execution, review, adversarial verification, acceptance gates — the entire pipeline running on your free channels.

fuc ultracode "Move weapon damage calculation from client to server, handle prediction rollback"

Six built-in strategies, auto-selected: classify-and-act, fan-out-and-synthesize, adversarial-verification, generate-and-filter, tournament, loop-until-done.

The underlying logic: replace single-model deep reasoning with structured pipelines. One cheap model struggling alone → five cheap models working in sequence, cross-reviewing, gating each other. The total cost might still be a fraction of a single Claude invocation.

Every run logs to .fuc-run/<run-id>/ with a complete audit trail: task ledger, event stream, verdict, final result.

Tech Stack

Layer	Technology
Desktop shell	Tauri 2 + Rust
Frontend	React 18 + Vite 5 + TypeScript 5
State management	Zustand
Styling	Tailwind CSS
Channel proxy	Rust `tiny_http` + `ureq`, local reverse proxy, Anthropic ↔ OpenAI protocol translation
Storage	Fully local, zero server dependencies

Who This Is For

Daily Claude Code / Codex users feeling the token bill
People with keys to multiple free channels but tired of config juggling
Those who know which tasks can run on cheap models and which need premium, and want granular cost control
Game/graphics/systems devs — large codebases, heavy compiles, high AI call volume

Not for casual users who ask a question once in a while. If that's you, just open a terminal and run Claude Code. You don't need a shell on top.

Default Models (Partial)

Channel	Default Model	Cost Model
GitHub Models	`openai/gpt-4.1-mini`	Free, GitHub token required, rate-limited
Hugging Face Router	`deepseek-ai/DeepSeek-V4-Pro`	Monthly free inference credits
SambaNova Cloud	`DeepSeek-V3.1`	Free Tier, no card, daily caps
Together AI	`Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8`	Free credits on signup
Kilo Gateway	`poolside/laguna-xs.2:free`	No key, 200 req/hr
LLM7	`codestral-latest`	No key, 100 req/hr

Get Started

cd app
npm install
npm run dev       # Web → localhost:5173
npm run desktop   # Tauri desktop app

On Windows, double-click run.bat in the repo root.

an open-source version Dynamic Workflows

wei feng — Mon, 01 Jun 2026 08:19:57 +0000

Claude Code's Dynamic Workflows Are Expensive，found an open-source version called OpenWorkflows

I recently upgraded Claude Code to version 4.8 and tried out Dynamic Workflows. I used it to develop a fairly complex feature for migrating a UE4 project to UE5. The quality was genuinely high, but it cost me more than 300 RMB in just one morning. My relay service only gives me a weekly quota of 600 RMB, so it is very easy to burn through the whole quota if I am not careful.

From what I have read online, Dynamic Workflows uses multi-angle exploration, adversarial validation, and solution voting. In other words, dozens of agents run in parallel for each requirement, challenge each other, and select the best answer. No wonder the output quality is relatively high. Does anyone here understand this mechanism well?

Since I am on a tight budget, I searched around and found an open-source version called OpenWorkflows (https://github.com/wellingfeng/OpenWorkflows). It says it can use cheaper large models such as Kimi and DeepSeek. Has anyone tried it? I would really appreciate a tutorial.

DEV Community: wei feng