Free 3D assets for vibe coding

Gobkit gives you three ways to get free 3D assets, all CC0 and all machine-readable: 69 curated models, a growing community library anyone can upload to, and an API that generates a new creature when neither has what you need. Most asset sites hand you a fixed list. Gobkit hands you a list, a stream and a generator — and all three answer to a plain GET with no account and no API key.

The community count is deliberately not written on this page: it moves. On 20 August 2026 that endpoint returned six more models at 04:45 UTC than it had at 02:00 UTC the same morning. Fetch /api/community for the live number — any figure printed here would be a floor at best and wrong at worst. The curated 69 is fixed and safe to quote.

# the curated library — no key, no sign-up, CORS open
curl https://gobkit.com/api/free

# what other people have uploaded — same terms, different collection
curl https://gobkit.com/api/community

# what the generator understands — also no key
curl https://gobkit.com/api/prompt

Freebies: 69 curated CC0 models

Four packs, 69 models, one unauthenticated GET. The whole library is 10,605 triangles and 3.63 MB unpacked. Every model carries exactly one material and one draw call, so an entire enemy wave costs roughly what a single modern character costs. All 69 files pass the Khronos glTF validator with zero errors, so they import cleanly into Unity and Godot rather than only working in the browser demo they were built for.

The figures below were read out of the shipped .glb binaries on 19 August 2026 — triangle counts from the mesh accessors, sizes from the files on disk, bone counts from the skin joints. They are not rounded marketing numbers.

Method: triangle counts summed from each primitive's index accessor; sizes from the deployed files; validation via the Khronos glTF-Validator (0 errors across all 69 files). Re-run it yourself against any URL in /api/free. The manifest also carries a 42nd nature entry — a pre-assembled scene built from the same props — which is why /api/free reports 70 downloadable .glb URLs against 69 distinct models.

The licence, stated plainly

Every free Gobkit pack is CC0 1.0 Universal — a public domain dedication, not a permissive licence with conditions. You may copy, modify, redistribute, sell and use these models commercially without asking and without crediting anyone. There is no attribution clause, no share-alike clause and no non-commercial clause. The full legal text is at creativecommons.org/publicdomain/zero/1.0/legalcode. The community library below is CC0 1.0 as well.

Credit is welcome but optional. If you want to give it: Characters by Gobkit — https://gobkit.com

Community library: other people made these, and they are also CC0

Gobkit is not only a pack of files — it is a wall other people keep adding to. The community library at gobkit.com/community is creature models uploaded by named creators, reviewed by a human, then published under CC0 1.0 with a page of their own. It grows while you are reading it — on 20 August 2026 it gained six models and three new creators between 02:00 and 04:45 UTC — because anyone can upload, with no account and no key. The live count and the full list are one request away: GET /api/community.

The whole wall is one unauthenticated request:

curl https://gobkit.com/api/community

Every item comes back with title, creator, license, model_url (a plain .glb), thumb_url, page_url and a specs object.

The specs are measured by the server, not typed in by the uploader

This is the part that matters if you are choosing assets programmatically. When a .glb is uploaded, Gobkit parses the file and measures it: triangle count, material count, draw calls, texture resolution, bone count, animation clip names, node count and byte size. The uploader cannot type those numbers in, so you can filter on them and trust the answer — the difference between a marketplace description and a measurement.

Read from GET https://gobkit.com/api/community on 20 August 2026. Every item was CC0 and every model file was released for download. The ranges move as people upload — re-run the request for today's.

Community animations are named clips — the opposite of the freebies

This is the single easiest thing to get wrong. Community models ship separate named animation clips — typically idle, move and attack — so you find the clip by name and play it. Do not apply the frame-range slicing that the curated packs need; there is no single master timeline to slice.

import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
import * as THREE from 'three';

// 1. list the wall — no key, CORS open
const { items } = await (await fetch('https://gobkit.com/api/community')).json();

// 2. pick something cheap enough for a swarm
const pick = items.filter(i => i.tri_count < 5000)[0];

// 3. load it and play a clip BY NAME — no subclip() here
new GLTFLoader().load(pick.model_url, (gltf) => {
  scene.add(gltf.scene);
  const mixer = new THREE.AnimationMixer(gltf.scene);
  const idle = THREE.AnimationClip.findByName(gltf.animations, 'idle');
  mixer.clipAction(idle).play();   // remember to mixer.update(dt) in your loop
});

Uploading: it is an open platform, not a closed pack

Anyone can add to this library. Post a .glb as multipart form data — no account and no key — and a human reviews it before it goes on the wall. You get back a slug, a status and a one-time manage token so you can take your own model down again later. Uploading releases the model under CC0.

curl -X POST https://gobkit.com/api/community \
  -F [email protected] \
  -F title="Bog Wyrm" \
  -F creator_name="your name"

Or use the browser form at gobkit.com/community/upload. Each model gets a permanent page at gobkit.com/s/<slug> with its measured specs, a 3D viewer and an embed snippet.

Not in either list? Then generate one

This is the thing a fixed asset list cannot do. If your game needs a four-armed obsidian warden with a greataxe and nobody has published one, no amount of browsing helps. Gobkit's third layer takes a plain-language request and produces the model.

The vocabulary is public — an agent can learn the interface with no credentials

GET https://gobkit.com/api/prompt is unauthenticated. It returns the complete vocabulary the endpoint understands — the counts, body types, weapons and palettes it recognises, the behaviour rules, the per-monster credit cost and worked examples. An AI agent can read the entire interface before anyone signs up for anything, which is the point: you should be able to find out whether Gobkit can make the thing you want before you pay to find out.

# no key — this is the whole interface, in one document
curl https://gobkit.com/api/prompt

Plan mode: parse a sentence, charge nothing

POST /api/prompt with a sentence and, by default, it only parses. It generates nothing and charges no credits. What it returns is a set of /api/batch requests you can send verbatim — including the split, because a request over 10 units per call is always returned as a plan rather than executed. Plan mode needs a signed-in account (or an API key), but it never costs credits.

curl -X POST https://gobkit.com/api/prompt \
  -H "Authorization: Bearer <your API key>" \
  -H "content-type: application/json" \
  -d '{"prompt":"30 blue greataxe enemies"}'

# → parsed: {count:30, body:…, weapon:greataxe, palette:blue}
# → estimate: {monsters:30, credits:300, calls:3}
# → calls: 3 ready-to-send POSTs to /api/batch, safe to run in parallel

What actually costs money, stated plainly

Plans are USD $19, $39 or $99 a month for 30, 100 or 500 generated monsters; the public API key comes with the top plan. Generated output is yours commercially, with no watermark. Nothing on the two free layers above ever needs a plan.

The two animation rules, side by side

Gobkit's two collections come from different pipelines and do not share an animation convention. Carrying one rule across to the other is the most common integration bug we see.

Both endpoints state their own rule in a top-level usage object. Read that object rather than trusting a remembered convention — it is the authoritative source for the files that endpoint serves.

Frame ranges for the curated packs

Minion Pack timelines are 3.708 s (90 frames, no walk); both Animal packs are 4.958 s (120 frames). Confirmed by reading each animation's input accessor maximum.

Loading the models, engine by engine

three.js — curated pack, spawning a wave

import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
import { clone } from 'three/addons/utils/SkeletonUtils.js';
import * as THREE from 'three';

new GLTFLoader().load('https://gobkit.com/freebies/minion/minion-a01.glb', (gltf) => {
  // one master timeline — cut the action you want out of it
  const idle = THREE.AnimationUtils.subclip(gltf.animations[0], 'idle', 0, 29, 24);

  // spawn a wave — SkeletonUtils.clone, NOT .clone(), or the rig silently breaks
  for (let i = 0; i < 30; i++) {
    const unit = clone(gltf.scene);
    unit.position.set(i % 6 * 2, 0, Math.floor(i / 6) * 2);
    scene.add(unit);
    const mixer = new THREE.AnimationMixer(unit);
    mixer.clipAction(idle).play();
    mixers.push(mixer);   // remember to mixer.update(dt) in your loop
  }
});

The SkeletonUtils.clone detail is the single most common failure we see reported: a plain Object3D.clone() copies the mesh but keeps pointing at the original skeleton, so every copy animates as one. It applies to community models too.

Godot 4

Godot imports .glb natively — drop the file into res://. A curated pack's baked timeline arrives as a single AnimationPlayer track; slice it with an AnimationLibrary or seek by time (frame / 24.0 seconds). A community model arrives as several named tracks you can play directly.

var anim = $AnimationPlayer
anim.play("clip")
anim.seek(30.0 / 24.0, true)   # jump to the first frame of 'attack' (curated pack)

anim.play("idle")               # community model — just play the named clip

Unity

Unity has no built-in glTF importer. Use glTFast or UnityGLTF — both read these files directly, with no Draco or Meshopt decoder needed. For curated packs, split the imported clip into idle / attack / dead / walk sub-clips at 24 fps using the frame ranges above; community models import as separate clips already.

Unreal 5 · Blender · <model-viewer>

Unreal 5 and Blender both import .glb natively with no plugin. <model-viewer> works for a quick preview but, on a curated pack, can only autoplay the entire timeline — use a real engine if you need one action at a time. On a community model, animation-name selects a clip.

<script type="module" src="https://ajax.googleapis.com/ajax/libs/model-viewer/3.5.0/model-viewer.min.js"></script>
<model-viewer src="https://gobkit.com/freebies/animal/Corgi.glb"
              camera-controls autoplay shadow-intensity="1"></model-viewer>

Conventions you do not have to guess

• Orientation: +Z forward, +Y up, metres, feet on the ground plane at Y=0 — the same in both collections. Verified: a look-at helper needs no extra 180° correction.
• Compression: none. Plain binary glTF 2.0, no Draco, no Meshopt, no extensionsRequired. Nothing to install.
• Textures: embedded in the file. Curated models share a small baked atlas; community models are usually flat-colour with no texture at all, occasionally 1024×1024. Nothing to relink.
• Materials: exactly one per curated model, so one draw call per unit. Community models run 5–12 materials, which is still cheap but is not a single draw call — check specs.draw_calls before spawning hundreds.
• Lighting: colour is baked in — a single directional light is enough.
• Hotlinking: allowed, CORS open, no rate limit. But for anything you ship, download the file and bundle it. CC0 explicitly permits it and your build then has no runtime dependency on us.

Where these came from, and what they are not

Gobkit is run by Alsomind Tech Co., Ltd., a company in Taipei, Taiwan. The curated packs are hand-checked exports with a hand-built skeleton — 240 triangles and 20 bones for a minion, 16 bones for the animals — deliberately low-poly rather than undirected generation output. The community models are other people's work, made with the anyCreature harness and reviewed before they go up. Whether any of that matters to you is your call; the measured numbers above let you check rather than take our word for it.

Both free layers are genuinely free and will stay that way. What Gobkit sells is generating new ones: $19, $39 or $99 a month for 30, 100 or 500 generated monsters, with the public API (/api/generate, /api/batch, /api/prompt) on the top plan. You never need a plan to use anything in layers 1 and 2.

Other places to look

Gobkit is not the only source of free 3D game assets, and for a lot of projects it should not be the only one you use. Genuinely useful alternatives:

• Kenney — the reference CC0 library. Enormous, stylistically consistent, mostly static props and kitbash pieces.
• Poly Haven — CC0 photoscanned props and HDRIs; high fidelity, high poly, not built for swarms.
• Quaternius — CC0 low-poly packs including rigged characters, a close neighbour to what is on this page.
• Sketchfab — huge, but licences vary per model; read each one before shipping.

Each of those is a fixed catalogue: excellent when it contains what you need, a dead end when it does not. That is the structural difference here — Gobkit is a catalogue plus a library that grows as people upload plus a generator for the case neither covers. And the machine track is the other half of it: /api/free and /api/community need no account, no key and no scraping, so an AI agent can list and fetch everything in two calls instead of driving a download page.

Start here

Read https://gobkit.com/llms.txt, then fetch both https://gobkit.com/api/free
and https://gobkit.com/api/community. Read each one's `usage` object before
writing loader code — they use different animation conventions. Drop three
free CC0 characters into my scene playing their idle animation.