Open-Source AI for Game Dev

A no-hype guide for experienced developers — March 2026 — compiled by Opus 4.5

Your Code Never Leaves Your Machine

With the setup in this guide:

The AI model runs locally in a Docker container on your workstation
Zero network calls. Zero telemetry. Zero cloud dependency
Your code goes from your editor → localhost:11434 → back to your editor. That's it
The container can be placed on a network-isolated Docker bridge with no internet access at all
The model weights are open — you can audit exactly what's running

This isn't "trust our privacy policy." There is no network connection. The model is a file on your disk, inference happens on your CPU/GPU, and the results go to your editor. Cloud AI tools (ChatGPT, Copilot) are fine for brainstorming generic questions, but you'd never point them at proprietary engine code. Local open-source models solve this completely. Studio IT can verify with a packet capture in 30 seconds.

Quickstart: Sandboxed Unreal Experiment in 10 Minutes

Everything runs locally in Docker. No accounts, no API keys, no cost. Nuke it all with one command when done.

Hardware You Need

1 Install Docker Desktop

Download from docker.com/products/docker-desktop

2 Run Ollama in a Container

# Mac (Apple Silicon — uses GPU automatically)
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

# PC with NVIDIA GPU — add --gpus all
docker run -d --gpus all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

3 Pull the Model and Test It

# Download Qwen3-Coder 30B (~18GB, go get coffee)
docker exec ollama ollama pull qwen3-coder:30b

# Talk to it directly
docker exec -it ollama ollama run qwen3-coder:30b

# Try: "Write a C++ ACharacter subclass with replicated health,
#  a TakeDamage override, and a BlueprintCallable heal function"
# Type /bye to exit

4 Connect Your Editor

Once Ollama is running, any tool that speaks its API (localhost:11434) can use the model. Pick whichever fits your workflow:

Continue.dev — Plugin for VS Code and JetBrains IDEs (Rider, CLion, etc.). Install the extension, select Ollama as provider, pick qwen3-coder:30b. Gives you chat, inline edits, and autocomplete
Aider — Terminal-based, editor-agnostic. Describe changes in English, it edits files and makes git commits. Works with any IDE or none
Direct API — Ollama exposes an OpenAI-compatible API at localhost:11434. Any tool that supports custom OpenAI endpoints (many do) can connect

5 Open Your Vanilla UE Project and Try It

Good first tests: ask it to scaffold a new actor component, write a spatial query, explain an engine function you're unfamiliar with, or generate test boilerplate for an existing class.

Sandboxing Details

Full Network Isolation (Optional)

Nuke Everything

The Open-Source Model Landscape

Recommended: Qwen3-Coder

Qwen3-Coder Alibaba — ollama.com/library/qwen3-coder

480B total / 35B active (MoE) • 256K context (ext. to 1M) • Most downloaded AI coding model globally (Jan 2026)

Benchmarks put it at Claude Sonnet level. Solid C++ generation. On SecCodeBench it beats Claude Opus on secure code generation (61.2% vs 52.5%). You'll use the 30b variant locally — 30B total / 3.3B active, runs on 32GB RAM.

Also Worth Knowing

Kimi K2.5 Moonshot AI

76.8% SWE-bench Verified (highest open-source) • Strong agentic reasoning

Best at "read a bug report, navigate a codebase, generate a working patch."

DeepSeek V3.2 DeepSeek

73.1% SWE-bench Verified • Fully open weights

Strong reasoning, good at navigating large codebases. Solid all-around coder.

Swap models anytime: docker exec ollama ollama pull deepseek-v3.2 — any connected tool picks them up automatically.

Honest Limitations & Strengths (UE-Specific)

Where all models still struggle:

HLSL / GLSL / shader code — Weak across all models (open and proprietary). Training data is sparse vs. C++/Python. Expect to hand-hold and verify heavily
UE macros & patterns (UPROPERTY, UFUNCTION, gameplay framework) — They'll scaffold an ACharacter subclass fine, but don't trust replication or GAS setup details without review
UE-specific tooling (Blueprint ↔ C++ bridge, .Build.cs, .Target.cs) — Limited understanding. Plausible-looking output that frequently gets dependencies and plugin setup wrong
Large-scale refactoring (50+ interdependent files) — Proprietary models (Claude Opus at 80.8% SWE-bench vs best open-source at 76.8%) are still meaningfully better at tracking cross-file dependencies
Context window reality — Models degrade well before advertised limits. A "200K context" model typically becomes unreliable around 130K tokens

Where they're already useful — even for UE:

Boilerplate & scaffolding — Headers, class declarations, delegate signatures. Massive time saver
Algorithms & math — Spatial hashing, pathfinding, quaternion ops, intersection tests, IK solvers. Generally correct C++
Code explanation — Paste unfamiliar engine code, ask "what does this do." Great for onboarding or deep-dives
Debugging & test writing — Paste an error + code, get plausible root causes. Describe behavior, get Automation Framework scaffolding back

The real value: AI handles the tedious 60% so you spend more time on the hard 40%.

Pricing, Sustainability & the Market

Open-weight models (Apache 2.0, MIT) are yours once downloaded. No subscription, no API metering. The tooling (Ollama, Continue.dev, Aider) is free and community-maintained. Hardware is the only cost — and you already have it.

Proprietary services (OpenAI, Anthropic, Google) have to keep prices competitive because open-source alternatives are now this good. If cloud AI costs 10x what a local model does for 90% of the quality, developers will just run Qwen locally. The labs know this.

Two other forces: compute costs keep falling (MoE architectures mean you don't need a datacenter anymore), and the total addressable market is still massive and largely untapped globally. These companies are competing for hundreds of millions of developers who haven't adopted AI tools yet. That's not a market where you raise prices — that's a market where you race to make it accessible.

The top open model (Kimi K2.5, 76.8% SWE-bench) is within striking distance of the top proprietary ones (Claude Opus, ~80.8%). The gap narrows every quarter. And even worst case — if every AI company folded tomorrow — the models on your disk still work.

Open-Source AI for Serious Game Development