What to have open.

OpenAI

OpenAI's assistant, with the Codex coding agent behind the same login and drawing on the same usage allowance.

Use it for Finding out whether an agent editing your files suits you before you pay anyone: the pricing page puts Codex on the Free plan for quick coding tasks, which is enough for a few rounds on a prototype. Do not plan a build around it — Free has no published limits and shares its allowance with chat.

The small print Free plan at $0; Go $8/month, Plus $20/month, Pro from $100/month

Anthropic

Pro and above put Claude Code, Anthropic's terminal agent, on your own machine next to the chat app.

Use it for The stretch where your prototype stops being one file — refactoring an entity or state system across a directory, run off a flat monthly fee rather than a metered API bill ticking up while the agent reads your repo.

The small print Free plan at $0; Pro at $17/month billed annually or $20/month, the cheapest tier that lists Claude Code as included

Google

The consumer app rather than the developer one: chat, image generation and editing, Deep Research, Canvas and Gems on a plain Google account.

Use it for Arguing about a picture with no project setup at all — upload the frame where the collision goes wrong, or a level sketched on paper, and talk it through. AI Studio wants a key and a prompt file; this wants a login.

The small print Free of charge with a Google Account (listed at €0/month); Google AI Plus, Pro and Ultra sit above it

Google

Google's browser workbench for the Gemini models, and where you get an API key without setting up billing first.

Use it for Getting one key that reaches both text and image models — Gemini for NPC dialogue or item generation inside your game loop, the Nano Banana image models for placeholder sprites. Cloud Billing only enters the picture when you outgrow the free rate limits.

The small print Free — Google's pricing page states AI Studio usage is free of charge in all available regions; API calls have a free tier with rate limits

LM Studio

Desktop app for running open-weight models locally, with a local server that answers OpenAI-style endpoints and a Claude-style Messages API.

Use it for Pointing code you have already written at localhost — your game's existing model client keeps its shape while you swap the model underneath and find out whether the feature still behaves on something small enough to run on the player's machine.

The small print Free for local use; its hosted cloud models are pay-as-you-go per token

Ollama

Pull an open-weight model, run it on your own machine, entirely offline if that is what you want.

Use it for Hammering a model thousands of times with no bill attached — generating NPC barks, item names, dialogue variants or level seeds at build time, or leaving a model wired into a dev-only tool you call on every iteration.

The small print Free plan at $0 for running models on your own hardware; paid tiers from $20/month buy more use of its cloud models

Siddharth Ahuja (ahujasid)

Connects a coding agent to a running Blender instance so it can create objects, set materials, read scene state and execute Python inside Blender.

Use it for Making the props your game needs. The agent blocks out a model, checks its own work against scene info, and pulls models, textures and HDRIs from Poly Haven or a generated mesh from Hyper3D — then you export to glTF for the web renderer rather than hand-modelling a crate. The README is candid that the Poly Haven integration behaves erratically.

The small print Free and open source, MIT. Asset integrations run on your own credentials — the README says the Hyper3D free trial key generates a limited number of models per day, and Sketchfab and Hunyuan3D need keys you supply. Poly Haven is a checkbox, no key.

Chrome DevTools team, Google

Gives an agent a live Chrome to inspect — performance traces, network, console with source-mapped stacks, heap snapshots, Lighthouse.

Use it for Answering "why does it drop to 20fps". It records an actual performance trace of your game loop, so the agent can point at the long task or the layout thrash instead of guessing and randomising your render code until something changes.

The small print Free and open source, Apache-2.0. Usage statistics are collected by default; opt out with --no-usage-statistics or the matching environment variable. Performance tools may also send trace URLs to Google's CrUX API unless you pass --no-performance-crux.

Upstash

Resolves a library name to an ID, then pulls current documentation for it into the agent's context before it writes code.

Use it for Keeping the agent off APIs that were removed two releases ago. Renderer and engine libraries churn hard, and a model writing from training data will confidently call a method that no longer exists — this makes that a lookup instead of a debugging session.

The small print Free and open source, MIT. Works without a key; the README recommends a free key from the Context7 dashboard for higher rate limits, without naming the numbers.

ElevenLabs

Exposes sound effect generation, text-to-speech, voice design and transcription as agent tools, from ElevenLabs themselves.

Use it for Sound, which is the thing every vibecoded game skips. The agent generates a jump, a hit and a pickup as real files in your assets folder while it is wiring the audio into the game loop, so you get a build that sounds like something instead of a silent one with TODOs. Every call spends credits, so it is not a free scratchpad.

The small print MIT-licensed server, API key required. The README states a free tier with 10k credits a month. Read this before you ship: on the pricing page the commercial licence starts at the Starter tier, not the free plan.

Figma

Pulls design context out of a Figma file — variables, components, layout — into the agent, and can write content back to the canvas.

Use it for Only earns its place if your menus and HUD already exist as a design. Then the agent reads the real spacing, colour and component values off the frame instead of inventing a layout, which is the difference between a UI that matches the game's art and one that looks like a form.

The small print Figma's help page says the remote server is available on all seats and plans, and the desktop server on a Dev or Full seat for all paid plans. Writing to the canvas is free during the beta; Figma's docs say it will eventually be a usage-based paid feature.

Coding-Solo

Launches the Godot editor, runs projects in debug mode, and pipes console and error output back to the agent.

Use it for Closing the feedback loop on a Godot build. The agent runs the project, reads its own runtime errors, and fixes the script — no copy-pasting stack traces out of the editor. It also creates scenes, adds nodes and loads sprites. Last push was April 2026, so treat it as settled rather than actively developed.

The small print Free and open source, MIT. Needs Godot installed plus Node 18 or newer.

Hugging Face

Hugging Face's own server for the Hub, which also lets you attach MCP-compatible Gradio Spaces as callable tools.

Use it for Getting placeholder art without leaving the agent. Add an image-generation Space in your MCP settings and it becomes a tool the agent can call, so it produces sprites, tiles and textures as it builds rather than leaving grey boxes everywhere. The docs' own example prompt is "Create a 1024 x 1024 image of a cat ghibli style". The changelog still labels the server experimental.

The small print Set up from your Hugging Face MCP settings while logged in, so an account is required. Neither the docs page nor the changelog states a price, so treat cost as unconfirmed rather than free.

Microsoft

Drives a real browser through Playwright's accessibility tree rather than pixel input, exposing navigation, clicks, key presses, screenshots, console messages and network requests.

Use it for Letting the agent actually play the browser game it just wrote — press keys, click, screenshot, read the console — instead of asking you whether it works. Worth knowing how it reads a page: the README's stated approach is structured accessibility data with no vision model, and the coordinate-based tools sit behind an opt-in --caps=vision flag.

The small print Free and open source, Apache-2.0. Runs via npx.

ambientCG

A CC0 library of PBR surfaces, decals, atlases, HDRIs and models where the licence is the actual feature.

Use it for Source material for the texture pass, and the input stage for the two tools above. Pull a surface — metal, fabric, leather, stone, wood, ground, tiles and a long tail besides — and you get a PBR map set rather than one flat JPEG, so the normal and roughness maps are already there. In a 2D build these become tiling backgrounds, UI panel surfaces, ground tiles, and the starting image you push through Materialize when you want a variant nobody else is shipping. CC0 means no attribution file to maintain, no per-asset licence audit before you publish, and nothing to renegotiate if the project turns commercial. The site claims "over 1,000,000 monthly downloads", so check you're not using the same concrete as everyone else.

The small print Free, and unusually clean about it: "All assets are released under the Creative Commons CC0 license, making them free to use without attribution - even in commercial circumstances." No account required to download. Optional Patreon and Ko-fi support buys ad-free browsing and early access to new assets, nothing more.

Comfy Org (originally comfyanonymous)

A node-graph diffusion backend you run on your own machine and drive from a script.

Use it for Sprite sheets, tilesets and textures at volume. Build the graph once until the look is right, then call it over its API endpoints so the other forty frames come out at the same size, palette and style — the part a chat window is worst at. Running locally means no per-image cost while you iterate, at the price of owning a GPU. Note the repo moved from comfyanonymous to Comfy-Org; old links redirect.

The small print Free and open source under GPL-3.0, run on your own hardware. A paid hosted version, Comfy Cloud, exists separately.

Music Technology Group, Universitat Pompeu Fabra, Barcelona (started 2005) and its community

A two-decade database of Creative Commons audio, with an API on top of it.

Use it for Footsteps, hits, interface blips and ambience without opening a DAW. The API means an agent can search and shortlist candidates instead of you scrolling. Read the licence on every file before it goes in the build: CC0 is admin-free, CC-BY needs a credits screen, and CC-BY-NC quietly rules out ever charging for the game.

The small print Free to download; each sound carries its own licence — CC0, CC-BY or CC-BY-NC

Kenney

Thousands of free game assets — 2D, 3D, interface, audio, pixel and textures — under CC0.

Use it for Placeholder art that doesn't look like placeholder art, on day one. CC0 means no attribution file, no licence audit before you ship, and no argument about whether a generated sprite is clean. Point the agent at a downloaded pack and have it wire the sprite sheet up, rather than generating art it will get subtly wrong across frames.

The small print Free to download; the packs carry a Creative Commons CC0 licence. There is also an optional paid all-in-one bundle and a supporter club, neither of which you need.

LibreSprite contributors

The community fork of Aseprite, taken from the last commit covered by GPLv2 before it went proprietary in 2016 — a real pixel editor, not a web toy.

Use it for Hand-fixing what the generator got wrong, which is every project eventually. Onion skinning and real-time animation preview for judging a walk cycle frame by frame; layer and frame composition; tiled drawing mode so you can author a texture and watch it repeat while you draw; custom palettes; pixel-precise tools including filled contour, polygon and shading. This is where AI sprite output gets cleaned up, a jittery frame gets redrawn, and a palette gets enforced across a sheet before it goes near the engine. An agent can generate sprites all day, but it can't look at a walk cycle and tell you the third frame pops.

The small print Free. The site states "This program is distributed under the GNU General Public License Version 2". No account, no tier, no upsell. Linux, macOS, Windows and Android, plus a browser version.

Lospec

A database of several thousand pixel-art palettes — 4,397 results the day I looked — downloadable in the formats editors actually import.

Use it for The decision you make before generating a single sprite, and the one people skip. Pick a palette, then download it as GIMP .GPL, Photoshop .ASE, JASC .PAL, Paint.net .TXT, .HEX, or a PNG swatch strip at 1x/8x/32x. Load the file into LibreSprite to constrain your own edits, and paste the hex list into your agent's prompt or a project style file so every generated asset lands in the same colours — the difference between a coherent game and a folder of unrelated images. The classic hardware palettes are in there, which is the cheapest way to make a rebuild read as the correct era without doing anything clever.

The small print Free to browse and download — nothing is paywalled. The site runs on voluntary support: a visible Patreon goal ("$278 / $500" the day I looked, 63 supporters) and one-off tips from $1 to $500. I couldn't confirm what patrons actually get; the Patreon page advertises exclusive posts and lists no other benefits.

Rodz Labs

A node-graph procedural material tool that produces PBR map sets without a source photograph anywhere in the pipeline.

Use it for The texture and material pass, when you want surfaces nobody else has. The site claims "over 200 nodes" for creating and transforming patterns as a graph; you can combine them or drop to GLSL when the node set runs out. Exports PBR texture maps as image files with presets aimed at Godot, Unity and Unreal, and there's a community library of user-made materials, nodes and brushes to start from. Because the material is a graph rather than a bitmap, you can change your mind about art direction and re-export the whole set. For a 2D build this is the fastest honest route to tiling backgrounds, ground surfaces and panel textures that don't read as stock photography.

The small print Free, with one asterisk. On itch.io it's pay-what-you-want, and the page tells you outright to click the "No thanks, just take me to the downloads" link when prompted for a donation — so £0 is a supported answer. MIT licensed, source on GitHub, Windows/macOS/Linux, currently at 1.7 and still shipping. The Steam listing is the exception — 15,49€, developer and publisher Rodz Labs — which buys convenience, not features.

Bounding Box Software

Load a flat image and it derives height, normal, metallic, smoothness, occlusion and edge maps from it, then makes the result tile.

Use it for The step immediately after you've generated or photographed a flat texture and need it to react to light. You chain derivations — diffuse to height, height to normal, normal to edge — tweak, remove the visible repeat, and export the map set as image files your shader can sample. In a 2D build that means normal-mapped sprites and tile backgrounds that hold up under a dynamic light, which is the cheapest way to stop a flat 2D scene looking flat. It's a desktop app sitting at 1.78 with no visible roadmap — treat it as a stable utility, not a product. The site cites use on the Uncharted Collection, which suggests the output is production-grade even if the tool is dormant.

The small print Free. The site states "Materialize is open source under the GNU GPL v3", source is on GitHub, and the download page hands over Materialize_1.78.zip with no price, no email and no licence key — despite being called getkey.php. Worth knowing before you commit: 1.78 is the only build on offer and the GitHub repo isn't serving releases, so the site is the sole distribution channel.

Meshy

Text-to-3D and image-to-3D with PBR texturing, auto-rigging and a poly-count-controlled low-poly mode.

Use it for The generalist. Feed it concept art or a prompt and get a textured mesh out as GLB, FBX, OBJ or USDZ, which covers every engine you are likely to target. Low Poly Mode is the bit that matters for a game build — the site says it "gives you clean topology with a poly count you control", so you can ask for a few thousand tris instead of a scan-density blob. One-Click PBR Texturing returns albedo, normal, metallic and roughness with no shader setup, and auto-rigging plus the motion preset library will get a humanoid walking in a test scene without you opening Blender. Set expectations honestly: it is a remesh, not hand-modelled edge flow, so props and background dressing ship fine as-is, and anything that deforms at close range wants a retopologise pass before it becomes a hero asset. UVs come baked, which is the real time saved.

The small print Free plan is $0 for 100 credits a month, with lower queue priority; the pricing page states free-tier output is CC BY 4.0, so you owe attribution. Pro $20/mo or $240/yr for 1,000 credits a month, API access and 10 concurrent tasks. Studio $60/mo or $576/yr. Enterprise on request. Paid plans state you own the assets you create.

PixelLab

Text-to-pixel-art that respects the grid — sprites, rotation sets and animation frames at the pixel sizes an engine expects, rather than a 1024px painting downscaled until it looks crunchy.

Use it for The placeholder-to-shippable pass. Prompt it, or hand it a reference sprite for style consistency, and it returns sprite sheets, 4- and 8-direction rotation sets, skeleton-driven animation frames, inpainted edits and tilesets, plus UI bits like buttons and health bars — all as PNG at the size you asked for. Generation is cloud-side, so no local GPU. The part that matters for an agent build: there's a documented HTTP API with per-endpoint pricing, so your agent can request frames as a build step instead of you exporting by hand.

The small print Free to start — the homepage CTA is "Try for free" with "No credit card required". The /pricing page is a JS checkout that rendered no numbers for me, so I won't quote tier prices I couldn't read. The API page does publish per-call estimates in USD, as ranges over output size: Pixflux image generation $0.00793–$0.0132 (64×64 up to 400×400), animate-with-text $0.01565, create character 4 directions $0.0105–$0.0122, 8 directions $0.0133–$0.0173, and "Pro tools" priced by size at $0.095 (to 256×256) through $0.185 (to 512×512). All of it carries the disclaimer "All prices are estimates and will vary because of variation in the GPU processing time." Commercial use is allowed; the FAQ's only condition is "we only ask that you do not train new models with the images."

Poly Haven — a small remote studio based in South Africa, funded by Patreon donations and corporate sponsors

CC0 HDRIs, photoscanned PBR textures and 3D models, downloadable without an account.

Use it for Lighting, mostly. One HDRI makes a Three.js or Blender scene look lit rather than flat before you place a single light, which is the biggest single visual upgrade available to an agent-built 3D scene. The no-signup part is what makes it automatable: a script or an MCP-driven Blender session can pull assets straight in, and the third-party Blender MCP server has Poly Haven downloads wired in already.

The small print Free, CC0, no paywall and no signup

Deemos / Hyper3D

High-detail image-to-3D and text-to-3D with an adjustable effort dial and a low-poly conversion step.

Use it for The one to use when you want detail first and will decimate afterwards. It generates mesh, UVs and textures together, exporting STL, FBX, OBJ, GLB, GLTF and USDZ. Output is dense — the 10M+ polygon figure on the site comes from a customer testimonial rather than a spec sheet, but the direction is right, so treat Smart Low-Poly as part of the workflow rather than an optional extra. The thinking-effort dial runs Extreme-Low to Extreme-High at roughly 4, 9, 20, 40 and 80 seconds, which is genuinely useful when you are iterating on silhouette and do not care about pores yet. Multi-view input improves geometry accuracy over a single photo. The pay-before-confirm free tier is the honest part of the pricing: you see the result before it costs you anything. Note that the API sits behind Business, which is the tier that matters if an agent is calling this rather than a human.

The small print Free tier is pay-by-result: you generate and preview before confirming, and the page quotes direct credits at $1.50 each rather than a monthly free allowance. It includes 10 private assets. Creator $30/mo, or $24/mo billed yearly at $288, estimated at about 60 models. Business $120/mo, or $96/mo billed yearly at $1,152, about 416 models, and this is the tier with full API access and 120–240 RPM limits. Enterprise and Education on request.

Sloyd

Parametric generators alongside text- and image-to-3D, aimed at game-ready props rather than photoreal capture.

Use it for A different shape of tool to the rest of the list. Alongside the AI path there are parametric template generators, so a crate or a sword is a set of sliders you adjust and re-export rather than a prompt you re-roll and hope. The page claims "Every model is generated with clean topology optimized for real-time engines", and exports carry geometry, UV mapping and texturing across GLB, FBX, OBJ, STL and USD — GLB and FBX being the two you will actually use for an engine. That makes it a good fit for the boring middle of a game build: the fifty props nobody will look at closely but which all need to load, light and collide correctly. Read the licence tiering carefully, because it is the real decision here — the free tier is personal use only, so anything you intend to ship needs Plus at minimum, and anything you intend to sell on an asset store needs Pro.

The small print Guest tier is free: 1 AI 3D generation per day, GLB and OBJ export, personal-use licence only. Sloyd Plus $15/mo, or $12.50/mo billed annually at $150, for 12 AI credits a month, 2 concurrent generations, unlimited exports and a commercial licence that does not cover redistribution or reselling. Sloyd Pro $50/mo, or $41.67/mo at $500/yr, for 60 credits, 5 concurrent generations, multi-image-to-3D, 4K textures, and a licence that does permit redistribution and marketplace reselling.

Microsoft

Microsoft's 4B-parameter single-image-to-3D model, MIT-licensed weights, outputs a textured GLB.

Use it for Single reference image in, mesh with PBR materials out — base colour, roughness, metallic and opacity — exported as GLB, which is exactly the format you want for Three.js, Godot or any glTF pipeline with no conversion step. Resolution is selectable and the quoted H100 timings are about 3 seconds at 512³, 17 at 1024³ and 60 at 1536³, so the low setting is fast enough to sit inside an iteration loop while you judge silhouettes. The MIT licence is the headline: no MAU threshold, no excluded territories, no attribution on your shipped game, which is not true of most of this category. Caveats are the honest ones for a generative 3D model — this is generated geometry, not authored edge flow, so it is fine for static props and wants a retopologise pass before it deforms. And 24 GB VRAM plus CUDA means most people will be renting a box rather than running it on the laptop.

The small print No fee. Code and the 4B-parameter weights are released under the MIT Licence per both the repo and the model card, which is about as unencumbered as this category gets, though some dependencies including nvdiffrast and nvdiffrec carry their own terms. Hardware is the cost: the repo states an NVIDIA GPU with at least 24 GB of memory, verified on A100 and H100, with CUDA Toolkit 12.4 recommended.

VAST AI Research

Fast text- and image-to-3D whose distinguishing feature is a quad remesher that runs as part of generation.

Use it for Reach for this when topology is the thing you care about. The Smart Mesh page promises clean topology and models "optimized for Unity, Unreal & Blender", and names STL, OBJ and FBX as export formats — check the others in the exporter yourself rather than trusting a list. Intelligent Segmentation splits a generated model into editable parts, which is how you get a separately animatable turret or door instead of one welded lump, and auto-rigging claims clean skeletons and skin weights. The reason it fits an agent-driven build is the official plugins: Blender, Unity, Unreal, Godot, Cocos and ComfyUI, so it lives in the pipeline rather than in a browser tab. The free tier's download cap is the real constraint, not the credits — you can generate considerably more than you can take home.

The small print Read this one on the day you buy: every paid price on the page when checked was under a 50%-off promotion, and no list price was shown, so the numbers below are promotional and will move. Free tier: 200 credits monthly (up to 8 models), 10 models stored, and a hard download cap of 15 downloads of the v2.5 model per month. Pro shown at $13.93/mo, $167.16/yr, for 3,000 credits and unlimited downloads. Max at $53.94/mo, $647.28/yr, for 25,000 credits. Team at $54.93 per seat per month.

Tripo AI and Stability AI

Single-image 3D reconstruction with MIT-licensed weights, quoted at under half a second on an A100.

Use it for Turning one concept image into a rough mesh you can drop into a Three.js or Godot scene the same afternoon. Treat the output as blockout quality — silhouette roughly right, topology and detail not — and retopologise in Blender before it goes near a hero asset. Default options want about 6GB of VRAM, so it is a desktop-GPU job. The half-second figure is on an A100; on your own card, expect slower. Worth knowing before you reach for a stronger Chinese open-weight generator instead: Tencent's Hunyuan3D 2.1 community licence states in its opening line that it does not apply in the EU, UK or South Korea. MIT here spares you that.

The small print Free and open source under MIT — the README states the licence covers source code and pretrained models

The BabylonJS GitHub organisation

A full web rendering and game engine, with the inspector, playground, and asset sandbox that three.js makes you assemble yourself.

Use it for The alternative to bolting five libraries onto three.js. Two tools do most of the day-to-day work: the playground, for testing API calls directly without a build step, and the sandbox, where you drag a .babylon or glTF file in to find out whether the file or your code is at fault — which is the fastest way to settle an argument with an agent about a broken export. WebGPU support is documented separately, so check that page before assuming a feature is there. The real trade is training data: an agent has seen far more three.js than Babylon, so expect to correct more API details in exchange for less integration work.

The small print Free, Apache-2.0 — the repo's license.md is the Apache License Version 2.0, January 2004.

The Blender open source project

The free 3D creation suite covering modelling, rigging, animation, simulation, rendering, compositing, motion tracking and video editing.

Use it for The interesting part is not using Blender, it is not using it: the whole application is reachable from Python, so an agent can drive it. BlenderMCP — third-party, MIT, made by Siddharth (@sidahuj), explicitly not from Blender — puts that behind an MCP server: create, modify and delete objects, apply materials, run arbitrary Python, pull CC0 assets from Poly Haven, and read back a viewport screenshot so the model can see what it just did. That screenshot loop is what turns Blender from a thing you learn into a thing you delegate: fix the mesh a generator got wrong, then export glTF for the browser.

The small print Free and open source, GNU General Public License v3

Don McCurdy

A glTF 2.0 SDK and command-line tool for JavaScript and TypeScript, on web and Node.

Use it for The step everyone skips until the first playtest loads 60MB of GLB over mobile data. It reads, edits, and writes glTF 2.0 from a script or the CLI, and the optimisation list is the part that matters: Draco or Meshoptimizer mesh compression, texture resizing and compression to WebP or KTX2/Basis Universal, animation frame resampling, removal of unused nodes and textures, and deduplication of vertex and texture data. Run it as a build step over your Blender or Mixamo exports rather than by hand, and keep the source files — most of these operations are lossy.

The small print Free. The site's footer reads "Copyright 2026, MIT License.", with documentation published under Creative Commons Attribution 3.0.

Godot Engine contributors; earlier copyright held by Juan Linietsky and Ariel Manzur

A free, open-source engine for 2D and 3D games from one interface, MIT licensed.

Use it for Where you go when a browser canvas stops being enough and you want a scene tree, physics and an animation system you did not write yourself. Ships to desktop, mobile and web, with consoles through third-party publishers, so the same agent-built project can reach a store page. The dedicated 2D renderer is a real 2D engine rather than 3D with the depth ignored, which is the practical reason most small games belong here rather than in Unreal. MIT also means no royalty arithmetic to revisit if the thing actually sells.

The small print Free and open source, MIT. No royalties, and the licence does not apply to what you make with it — you are the sole copyright owner.

Phaser Studio and the open source community

A fast, free HTML5 game framework with WebGL and Canvas rendering, in development for over 13 years.

Use it for The 2D counterpart to Three.js, and the cure for agents reinventing a game loop badly inside one enormous HTML file. Sprites, input, scenes and physics already exist, so the prompt is about your game rather than about collision maths. JavaScript or TypeScript, works with the usual frontend tooling, and the same build targets YouTube Playables, Discord Activities, Reddit games and Twitch overlays — places a small game can actually find players. Link goes to the repo deliberately: the phaser.io front page now sells a separate hosted AI game-generation service, and the library is what this entry is about.

The small print Free and open source, MIT. Download the library, or install it from npm or a CDN.

PlayCanvas

A WebGL2/WebGPU engine with a browser-based visual scene editor, hosted as a paid service but open source underneath.

Use it for The answer to "where is the scene editor" if you have been placing objects by typing coordinates. The engine README claims WebGL2 and WebGPU, ammo.js rigid-body physics, asynchronous asset streaming built on glTF 2.0 with Draco and Basis compression, WebXR, and "first-class support for loading and rendering 3D Gaussian Splats". Worth knowing the split: the editor is a separate MIT repo that you can run locally with npm run develop, so the subscription buys hosting and storage rather than the software. The REST API means an agent can push assets into a project instead of clicking through the UI.

The small print Engine and editor repos are both MIT. Hosted editor plans as listed today: Free at "$0 / month" with "1GB Storage"; Personal at "$15 / month" with "10GB Storage"; Organization at "$50 per seat / month" with "50GB Storage". All three tiers list free app hosting, self-host downloads, REST API access, and unlimited public and private projects.

Dimforge

A Rust 2D/3D physics engine compiled to WebAssembly, with official JavaScript bindings.

Use it for The physics you need the moment your three.js scene has to do more than spin a cube: rigid bodies, colliders, raycasts, joints, and a character controller you did not write yourself — the built-in one handles stopping at obstacles, sliding on shallow slopes, stairs, and moving platforms. Because it is WASM, initialisation is asynchronous — the docs are explicit that the module "has to be loaded asynchronously", and that is the single detail an agent most reliably gets wrong on the first pass. Fixed-timestep the simulation and interpolate the render, or your game will behave differently on a 144Hz monitor.

The small print Free. The site says "Forever free and Open-Source"; the repo is Apache-2.0. JS/WASM builds ship as the @dimforge/rapier2d and @dimforge/rapier3d npm packages, plus -compat builds that inline the WASM as base64 for bundlers that choke on .wasm.

Poimandres (pmndrs)

A React renderer for three.js — the scene graph expressed as components instead of imperative setup code.

Use it for The difference between a three.js demo and a three.js game you can still edit in month two. State, UI, and scene stop living in separate worlds, and the ecosystem list in the README is the real payload: drei for the helpers you would otherwise rewrite ("useful helpers, this is an ecosystem in itself") and @react-three/rapier for physics. The cost is a second mental model — an agent that knows React and an agent that knows three.js are not automatically an agent that knows how refs, disposal, and the render loop interact here.

The small print Free, MIT licence per the repo.

Isaac Mason

A WebAssembly port of Recast Navigation — the README's own summary is "navigation mesh construction, path-finding, and spatial reasoning toolkit".

Use it for Enemies that walk around walls instead of into them. Recast bakes a navmesh from your level geometry, Detour paths across it, and the Crowd class handles multiple agents avoiding each other. Temporary obstacles run through the TileCache — add or remove box and cylinder obstacles for doors and destructibles, then call tileCache.update(navMesh) to rebuild the affected tiles, with the caveat in the docs that TileCache assumes small tiles. Ships three.js and PlayCanvas integration packages. This is the one an agent will otherwise reinvent as an A* grid, which works until your level stops being flat.

The small print Free, MIT licence per the repo.

mrdoob and contributors

A JavaScript 3D library aiming to be easy to use, lightweight and cross-browser.

Use it for The browser 3D layer, and the reason a one-prompt 3D game is plausible at all. Your agent writes a scene, camera, renderer and a glTF load — no install, no build step required, no editor to click through, and the result is static files you can host anywhere. Current builds ship the WebGL and WebGPU renderers; SVG and CSS3D are addons. Pair it with Blender for models and Poly Haven for the HDRI and the whole pipeline stays in the repo.

The small print Free and open source, MIT

Epic Games

Epic's engine, licensed on royalties rather than up front — 5% above the first $1m per product.

Use it for Photoreal 3D and a production content pipeline, and the entry on this list where one prompt gets you nothing playable. Large install, a project format that assumes a human driving an editor, and iteration measured in builds rather than page refreshes. Reach for it when you specifically need Unreal's renderer, and expect the agent to help with code and asset wiring rather than hand you a game. Read the royalty addendum yourself before signing anything — the exclusions are per product, not per studio.

The small print Free below $1m USD product revenue. Above that, 5% royalty on lifetime gross revenue per product, with the first $1,000,000 per product excluded and any quarter under $10,000 for that product excluded. Epic Games Store sales are royalty-free. Non-game commercial use above $1m falls under a seat licence instead.