polyfork.dev is built with Three.js, hosted on Cloudflare. It measures traffic with Cloudflare Web Analytics. It sends email through Amazon SES.
| Technology | Version | First seen |
|---|---|---|
| JavaScript Frameworks & Libraries1 | ||
| – | 7 Nov 2026 | |
| Web Servers, Languages & Backend Frameworks1 | ||
| – | 7 Nov 2026 | |
| CDN & Hosting1 | ||
| – | 7 Nov 2026 | |
| Analytics & Tag Management1 | ||
| – | 7 Nov 2026 | |
| Transactional Email2 | ||
| – | 7 Nov 2026 | |
| Security, WAF & Bot Protection1 | ||
| – | 7 Nov 2026 | |
Registration from the registry's RDAP record, the certificate the site serves, and its rank in public traffic lists.
The crew hasn’t read this site’s colors yet. We read a palette when we capture a site’s screenshot, busiest sites first. Meanwhile, browse palettes from other sites.
smtp.google.comadi.ns.cloudflare.combayan.ns.cloudflare.comv=spf1 include:_spf.google.com ~allunity-as-publisher-verification=01a00040-2dcb-75dd-a236-5414391eb51fgoogle-site-verification=OyIRj6dpYgxtV5vKIMZkVdlpbJm90rRJ2SVzbpTCC5cgoogle-site-verification=uPghfbdgRTaeVYN9fPqvkNxS-StcwEleM_oRhWFwrj0v=DMARC1; p=quarantine; pct=100# Polyfork. Everything here is open to crawlers and to agents. # # If you are an AI agent rather than a crawler, the two files below are written # for you and are cheaper to read than the HTML: # # https://polyfork.dev/prompt.txt the catalogue as working instructions # https://polyfork.dev/llms.txt the catalogue as a reference # https://polyfork.dev/api self-describing JSON API, no key to browse # https://polyfork.dev/mcp MCP server, JSON-RPC 2.0 over HTTP POST # # Nothing here is disallowed except three image generators that exist only to # make share cards, the prefilled copies of /requests, and the download # endpoint, which answers 401 to anyone who is not signed in. /dl/ is 2,352 of the 4,825 URLs a crawl of this site finds: # half of Google's allowance here was being spent re-confirming a login wall, # on a domain where half the published asset pages have never been crawled at # all. Signed-in browsers and token-holding agents ignore robots.txt, so nothing # a customer does is affected, and no structured data points at /dl/ (the # offers point at /cdn/ and /asset/). # # /requests? is the same problem a second time (2026-10-26). Every published # asset page links to /requests?base=<id>, which is the request form with one # box filled in: 2,660 copies of one page, as many URLs as the whole sitemap. # /requests itself stays open and is in the sitemap; only the prefills go. User-agent: * Allow: / Disallow: /og-card.php Disallow: /x-banner.php Disallow: /promo.php Disallow: /dl/ Disallow: /requests? Sitemap: https://polyfork.dev/sitemap.xml
# Polyfork
Premium low-poly 3D assets for three.js: game-ready, flat-shaded, real-world scale,
one shared MATERIAL for nearly every model (rigged parts are separate meshes, so the
API's draw_calls field is often more than 1; merge.mjs gets a whole scene to one draw
call, or to one per material where an asset carries glass, water or chrome).
3058 published assets, and EVERY ONE IS FREE: every low poly model, and every new
one as it ships (since 2026-10-25). HD editions (1,665 of them: the same model built
finer, high poly with PBR materials) are the paid part, on Pro. Every asset ships as a
GLB (works in three.js, Unity, Godot, Unreal, Blender) plus a drop-in ES module for
three.js. Characters are rigged on one Mixamo-named humanoid skeleton (22 body bones
plus 9 Face_* joints, 31 in all); no clips are inside the file, and the free ones play
on any character in three lines with /cdn/clips.mjs (any other Mixamo animation
retargets with /cdn/mixamo.mjs). Some models also SOLVE rather than pose: `has_ik` is true on those,
and `ik_type` says which kind: "legs" (a walker or animal whose feet find your ground
and stay planted) or "arm" (a rooted boom whose tip you aim), null on everything else.
Their detail response carries a measured gait/arm block - segment
lengths, foot offsets, phase order, step, duty, reach - which is enough to drive them
in any engine; /cdn/walk.mjs does it for three.js in three lines. Filter for them with
/api/assets?ik=1 (or ik=legs, ik=arm).
This site is agent-friendly: everything below is stable, JSON, and keyable.
## Do you need a key?
Browsing needs none, and a lot of work genuinely finishes without one. Be
straight with your user about where the line is, rather than finding it by
hitting a limit mid-build:
- WITHOUT a key you can read the whole catalogue and load ANY low poly model:
the module at /cdn/{id}.mjs and the GLB at /cdn/{id}.glb answer 200 to an
anonymous caller, CORS-open, the real parametric source. So the best build is
to import the module and pass knobs at runtime: no baking, no per-variant
file, no remix budget spent. You can also bake remix variants, rationed per
hour. `free` is true on every published row; read it anyway rather than
assuming, because the owner can still mark a single row paid.
- A FREE key (an email address) raises the remix budget and adds the source
as a download: /dl/{id}.mjs, a ready-to-serve zip per asset, and whole KITS
as one zip (/dl/kit-{kit-id}.zip). The .glb and the other mesh formats on
/dl need no key at all.
- Pro adds the HD EDITIONS: the same model built finer, high poly with PBR
materials generated in code, every knob still working. Their modules and
GLBs (/cdn/{id}-hd.mjs, /cdn/{id}-hd.glb, /dl/{id}-hd.zip) are 404 without
Pro, through a per-account /c/<token>/ CDN path that is safe to ship in a
build. The HD preview (/cdn/{id}-hd-preview.glb) is public, like any preview.
Pro also lifts the remix cap.
Every API and MCP response carries an `access` object with your current tier
and your remaining budget. who_am_i, GET /api/me, GET /api and a single asset
also say what each step up adds; a search or a list carries one line (`more`)
instead. Read it rather than guessing, and tell the user what you found.
If you are a coding agent about to build something, fetch polyfork.dev/prompt.txt
first: it is the same catalogue written as working instructions rather than as a
reference, and it is kept current, so it beats reasoning from this file alone.
## API
Base: polyfork.dev/api (self-describing: GET /api)
- GET /api/assets browse. filters: q, free (0|1), kit, ik (1|legs|arm),
class (prop|building|vehicle|character|animal|
ultra|attachment|terrain|hand),
(ultra is the store's Nano shelf: small standalone models,
mostly food, tools and things a character holds, the
righthand-item-* and lefthand-item-* ids among them),
max_triangles, min_triangles,
sort (latest|tris), page, per_page (max 100).
max_price_usd is deprecated: there are no per-asset prices
- GET /api/assets/{id} one asset: triangles, size, palette, rigged parts, renders,
license, and the correct download URLs for you
- GET /api/assets/{id}/matching what goes WITH it: same kit, then shared palette,
then compatible scale. Turns one asset into a scene.
- GET /api/assets/{id}/variant?want=oak+cask
plain words -> a ready createAsset() call (+ glb, but read glb_note:
a colour-only variant is applied at runtime).
`want` is matched against KNOB NAMES and OPTION VALUES, not colour
vocabulary: "dark basalt" only lands on an asset whose colorway is
literally called something like dark-slate. Read the options in
/cdn/{id}-params.json and use those words. A colour zone takes a
hex beside its name: "shirt #c8102e".
- GET /api/kits kits with published part counts and a status
- GET /api/kits/{id} one kit + its published parts, and its composition
if you own it
- GET /api/kits/{id}/layout the composition on its own (owners)
- GET /api/kits/{id}/terrain.mjs the kit's ground program (owners)
A kit's `status` is either `published` (every planned part is built) or
`filling-up` (still being built). The parts of a FILLING-UP kit are usable
today — they publish one at a time — so /api/kits/{id} returns them either
way. Status is the only difference: recommend the PARTS in both cases.
NO KIT IS SOLD AS A BUNDLE. price_usd is null and for_sale is false on every
kit, published ones included, and there is no checkout that takes a kit. Do
not use those two fields to tell the statuses apart — read `status`, or
parts_published against parts_planned. Every part is free (no account needed
for its /cdn files) and the whole kit downloads as one zip on a free account.
Each kit carries `price_note` saying exactly this, so quote that rather than
inferring from the nulls.
A KIT IS A PLACE, not a bag of models, and the arrangement is part of what
you get. /api/kits/{id} reports `composition` for every kit composed as a
place (how many placements and how many distinct parts), and for a caller
with any account's API key (every kit is free on a free account) it returns
the placements themselves in `layout`, the same list that arrives as
LAYOUT.json in the download. Each row is a part key, a position in metres
(x, y, z, Y up), rotations in degrees, an optional scale `s`, and `params`:
the knob values THAT placement was built with, where they differ from the
part's defaults. In the API an upright part carries `ry` (about Y) alone, and
`rx`/`rz` appear only where a part is really tilted; apply all three in XYZ
order, three.js's default (o.rotation.set(rx, ry, rz), in radians). The
download's LAYOUT.json is the editor's own record and may write an upright
turn as rx = rz = 180 with ry, which XYZ order makes the same pose, so apply
all three there too. Build each part with createAsset(params), put it where
the row says, and you have the scene every picture of that kit was taken in.
The row whose part is `_terrain` is the ground rather than a model: it
carries a `module`, the knobs it was generated with and where it stands.
A kit is not only its models. Where it has them, /api/kits/{id} also returns
`look` and `terrain`, and BOTH ship inside the download:
look the shader the kit is presented under. The Coral Reef is composed,
photographed and filmed through 2.5 m of water, so a scene built
without it is the same parts in clear air. `looks.mjs`, three lines
to apply, nothing baked into the geometry, switchable off.
terrain the kit's own ground PROGRAM plus the knob values it was composed
at. A program rather than a mesh: it rebuilds at any size and the
parts sit on it at the scale they were built for.
- GET /api/me your account: email, plan, purchases (key required)
- POST /api/demand {"need": "...", "email": "..."} to tell us about something
a user wanted that we do not have
Every asset in a LIST carries has_rig, has_skeleton, remixable, has_night,
has_decals, has_ik, ik_type, size_m, origin_y and mass_kg, so you
never have to fetch the detail endpoint just to find out whether something
animates - or, for has_ik, whether it walks on your ground rather than merely
having hinges you could pose yourself.
Read the two animation flags as different questions, because they are.
has_rig means NAMED POSABLE PART GROUPS - a door, a boom, a lid, with the pivot
already at the hinge. has_skeleton means a full retargetable skeleton you can
drive with a Mixamo clip. Most of our characters have a skeleton and no named
parts, so has_rig is false on them: shortlisting animatable humanoids on has_rig
alone finds a fraction of them and reports the rest as static.
origin_y is the measured minY. It is 0 for nearly every asset, meaning the
convention below holds. Positive means a wall or ceiling fixture built at
installed height; negative means a ground tile or terrain that hangs below its
own top surface. You place all three at y=0 - the number tells you what standing
something ON it means.
PHYSICS. mass_kg (full list rows and detail; compact rows leave it out) is an estimate of what the real object
weighs. The detail row adds `physics`: body ("dynamic" moves, "static" is fixed
in place), material, measured dimensions_m and volume, and `collision` with a
colliders_url (/cdn/<id>-colliders.json: convex hull points in metres, one hull
for the whole model plus one per part). collision.approximation says which to
use, in UsdPhysics terms (convexHull or convexDecomposition). The detail row also
carries `simready_metadata`: the same facts under the property names NVIDIA's
SimReady catalog uses (simready_metadata_mass, simready_metadata_rigid_body_count,
usd_dimensions with Z up), so a pipeline that reads SimReady assets reads ours.
All of it is for the default knob settings.
A search reports `coverage` ("none" | "poor" | "ok" | "filtered_out") when you
passed a query or a filter. On "none" or "poor", SAY SO to your user and offer to
POST /api/demand. Do not substitute something unrelated: a pine tree offered for a
lunar base is worse than an honest no, and the request itself is useful to us.
"filtered_out" means the catalogue HAS it and your filters removed it
(matches_before_filters says how many): relax a filter, do not report a gap.
`unmatched_terms` lists query words nothing in the catalogue mentions; coverage
is then at best "poor", and strong_matches_on_the_rest counts what answers the
other words, so you can say "we have cups, nothing sippy".
Compose a scene as a shareable page instead of a code block:
polyfork.dev/scene?ids=asset-a,asset-b,asset-c
## MCP
The same catalogue is an MCP server, so the tools appear in your assistant
without anyone pasting these docs. One endpoint, JSON-RPC over HTTP POST:
https://polyfork.dev/mcp
Tools: search_assets, get_asset, find_matching, get_variant, preview_scene,
list_kits, get_kit, get_terrain, who_am_i, buy_plan, get_help,
report_need. No key is needed to browse or to load
any low poly model; a key unlocks the zips (a free account) and the HD files (Pro).
report_need takes a `kind`, and three of the four are about the SERVER rather
than the catalogue: asset (we do not model it), capability (the server cannot
do something you needed), output (a tool answered, but not with what you
needed), docs (a tool description did not tell you how to use it). Reporting a
rough edge costs one call and is how this gets better, so do not stay quiet to
be polite.
One HTTP endpoint, no install, so any MCP client can reach it. The common
config shape, which most clients accept:
{"mcpServers": {"polyfork": {"type": "http",
"url": "https://polyfork.dev/mcp"}}}
Where that file lives differs per client, and a couple name the key
differently: VS Code uses "servers", Zed uses "context_servers". Claude Code
and Codex can skip the file:
claude mcp add --transport http polyfork https://polyfork.dev/mcp
codex mcp add polyfork --url https://polyfork.dev/mcp
A client with no HTTP transport (stdio only) needs a local bridge:
{"mcpServers": {"polyfork": {"command": "npx",
"args": ["-y", "mcp-remote", "https://polyfork.dev/mcp"]}}}
For downloads on your account (kit zips, and HD editions on Pro), add your key as a
header on the connection:
{"mcpServers": {"polyfork": {"type": "http",
"url": "https://polyfork.dev/mcp",
"headers": {"Authorization": "Bearer pf_YOUR_KEY"}}}}
The key stays in that config: it is never handed to the agent. get_asset returns
paid downloads as signed links, good for one file and expiring in 15 minutes,
that work with no auth header, because the process doing the downloading does
not have the key. Call who_am_i to see whether a key is attached and what it
owns.
THE SHAPE OF THE ANSWERS changed on 2026-09-20. Lists now state what rows share
once (each such answer opens with how_to_read_rows), get_kit returns the three
lines that build the whole composed kit instead of inlining its layout, and
answers carry pictures: a contact sheet on a search, the place and its plan on
a kit. It is the same information at about a quarter of the size. If something
of yours PARSES the tool output and needs the old shape, pin it per connection:
"headers": {"X-Polyfork-Surface": "legacy"}
REST (/api) did not change.
A SECOND DOOR for building places rather than browsing, four task-shaped tools
over the same catalogue (find_place, get_place, get_character, find_prop), and
about half the tokens to open:
https://polyfork.dev/mcp/world
What writes: of the 12 tools on /mcp, two do more than read. report_need
files a note about something missing, and buy_plan returns a Stripe checkout
link: it never charges anything itself, the payment happens on Stripe's page
with the user's approval, and only its `confirm` step changes an account (it
activates a plan that was paid for). The 4 tools on /mcp/world only read.
Nothing deletes anything.
Auth: create an API key at /account (sign in with Google first), then send
Authorization: Bearer pf_...
Public browsing works without a key; the key unlocks the zips, the HD files on Pro, and /api/me.
## Plans
FREE every low poly model, all 3058 and every new one. No card, no expiry.
GLB + ES module, commercial use, no attribution. Whole kits too.
(Until 2026-10-25 only assets under 600 triangles were free.)
PRO $15/month or $149/year: the HD editions (1,665 and counting),
a per-account CDN for them, uncapped remix baking, your own logo on
models (decals) and styles carried in downloads. /pricing
FOUNDERS $100 once, capped at 100 accounts. SOLD OUT; the club and its badge are never offered again.
LIFETIME $100 once for 100 accounts, on sale now that the Founders Club is gone; the
whole offer is 200 seats counting the club, 9 still open. Then $200 once for the next 100 seats.
Same entitlement as Founders: Pro forever, every HD edition current and future, one payment.
REDUCED $50 once for 2 years of PRO, for students anywhere and for people in
low-income and lower-middle-income countries. Granted on an application
a person reads, not a code. Nothing renews. /students
Three things that are not plans:
SKIN $9 builds a CHARACTER to your reference pictures. 197 of our 197
rigged humanoids are generated by one engine from a config (age, figure,
build, expression, palette, a garment in each of 14 slots), so a custom one
is an authoring job rather than modelling work. You send pictures of an
outfit; it is built as a skin on that same shared humanoid, gated by the
same checks as ours and published to the catalogue. Humanoids only: one
rig, two arms, two legs. /skin
Change an existing one for free in the browser at /create. /characters
STEER A kit of YOUR theme that does not exist yet. On a paid plan, describe it and
a planner drafts the parts list and three concept looks at no extra cost,
then $50 puts it on the production line and publishes it into the
catalogue, or $100 builds it for you and never publishes it;
nothing is charged before you have seen the plan. Without a plan, ASKING is
still free: any signed-in account can put one kit idea a week on the public
ideas board (no weekly limit on a plan), where upvotes decide what the
factory takes on. /steer
PLATFORM from $299/month to keep your own copies of the .mjs modules, on
your servers or CDN, and serve them to YOUR OWN users, HD editions included.
(The free mesh files you may host under CC BY 4.0, with the credit.)
No plan above covers that, whatever it cost. Linking to the free models
on /cdn needs no licence, from any product. /platform
There is no per-asset price. An asset is free, or it is included in Pro.
Anything downloaded while subscribed stays licensed forever, and access
continues 30 days past a cancellation or a failed card.
## Downloads
- FROM A TERMINAL: `npx polyfork add <id>` saves a model's GLB into the project
(find it first with `npx polyfork search <words>`; `--format mjs` for the
source after `npx polyfork login`). One model or kit at a time, --json for scripts.
- FREE assets: no auth at all. Hotlink or fetch:
/cdn/{id}.glb /cdn/{id}.mjs
As DOWNLOADS from /dl, a free model's mesh files need no key either
(/dl/{id}.glb and the formats below); /dl/{id}.mjs and the zips take a free
account's key.
- HD EDITIONS (`hd` on the asset), on Pro or Lifetime (or a Founders account):
/dl/{id}-hd.glb /dl/{id}-hd.mjs /dl/{id}-hd.zip same Bearer key
Without the plan these answer 401 with no key and 403 with a free one.
- On Pro or Lifetime, the CDN instead, which needs no auth because the token in
the path IS the credential. Get yours from who_am_i or /api/me:
/c/{cdn-token}/{id}-hd.mjs /c/{cdn-token}/{id}-hd.glb (and {id}.mjs, {id}.glb)
Safe to ship in client-side code: it is not your API key, and it cannot touch
the account. Prefer it over downloading when you are building a web page.
- NOT ON THREE.JS? The same model in your engine's format:
/dl/{id}.fbx Unity, Unreal, Maya, 3ds Max
/dl/{id}.usdz iOS AR Quick Look, Omniverse
/dl/{id}.usda Isaac Sim, Omniverse, Blender: one plain-text USD file
Both USD files carry UsdPhysics: a collider on every mesh (the approximation
from `physics.collision`), and a rigid body with physics:mass when the asset is
dynamic. Metres, Y up.
/dl/{id}.obj universal, but geometry only: no pivots, no rig
These route through /dl even for a FREE asset (no account needed for one),
because they are built on demand rather than sitting on disk. First request takes about
a second, then it is cached. Read `export_formats` on the asset detail rather
than assuming: it is absent when there is no mesh to convert.
The palette is converted into NAMED MATERIALS on the way out, named after that
asset's own colour knobs (hull, trim, sail). This matters more than it sounds:
our colour lives in COLOR_0, which three.js reads and Unity, Unreal and Quick
Look do not, so a conversion you do yourself from the .glb arrives WHITE.
Th| – |
| 7 Nov 2026 |