Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
// Pure data and generation logic for the /open-source credits page.
//
// scripts/build-open-source-credits.mjs calls buildCredits() and writes the
// result to data/open-source-credits.json. tests/open-source-credits.test.js
// imports the same function and diffs it against that committed file, so a
// dependency added to package.json without a regenerated, re-committed
// dataset fails the test instead of rotting silently.
//
// Three kinds of entry feed the page:
// npm - every direct dependency in package.json, resolved against its
// own installed package.json for version/license/repository/funding.
// model - GPU worker models under workers/*, hand-curated from each
// worker's README because the license and upstream name are prose,
// not machine-readable metadata.
// asset - non-code asset sources (Poly Haven, Mixamo, the CC0 animation
// packs) and vendored/forked source trees recorded in NOTICE and
// third_party/README.md.
//
// Every area id used below must appear in AREAS; the page and the guard test
// both read AREAS as the source of truth for section order and labels.
import { readFileSync, existsSync } from 'node:fs';
import { resolve, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';
const here = dirname(fileURLToPath(import.meta.url));
export const ROOT = resolve(here, '../..');
export const AREAS = [
{ id: 'rendering', label: 'Rendering' },
{ id: 'formats', label: 'Formats and compression' },
{ id: 'generation', label: 'Generation models' },
{ id: 'motion', label: 'Motion' },
{ id: 'voice', label: 'Voice' },
{ id: 'assets', label: 'Assets' },
{ id: 'infrastructure', label: 'Infrastructure' },
];
const AREA_IDS = new Set(AREAS.map((a) => a.id));
// ---- npm dependency curation -----------------------------------------------
//
// Only "major" projects (the ones a visitor would recognize or that do
// genuinely load-bearing work) get a hand-written "what it powers here"
// line. Everything else in package.json still gets a full entry (name,
// version, license, repository, funding) from its own installed metadata,
// just grouped by the fallback classifier below with no powers line.
const CURATED_PACKAGES = {
three: {
area: 'rendering',
powers:
'The 3D engine behind every viewer: the Forge stage, AR Studio, the agent embeds, and the Entity Studio.',
},
'three-mesh-bvh': {
area: 'rendering',
powers: 'Accelerated raycasting and collision queries for the viewer and AR placement.',
},
'three-gpu-pathtracer': {
area: 'rendering',
powers: 'The physically based path-traced render mode in the Forge viewer and cinematic captures.',
},
'three-pathfinding': {
area: 'rendering',
powers: "Navmesh pathfinding for agent movement in AgenC's embodiment surfaces.",
},
postprocessing: {
area: 'rendering',
powers: 'Bloom, depth of field, and color grading passes on top of the three.js render.',
},
'@pixiv/three-vrm': {
area: 'rendering',
powers: 'VRM avatar import and rendering across the viewer and avatar pipeline.',
},
'@pixiv/three-vrm-animation': {
area: 'rendering',
powers: 'VRM animation playback paired with @pixiv/three-vrm.',
},
'@dimforge/rapier3d-compat': {
area: 'rendering',
powers: 'Physics simulation for AgenC rooms and interactive 3D scenes.',
},
'@sparkjsdev/spark': {
area: 'rendering',
powers: 'Gaussian-splat rendering for captured scenes and reconstructed environments.',
},
'dat.gui': {
area: 'rendering',
powers: 'Internal tuning panels for lighting and material debugging in the 3D tools.',
},
delaunator: {
area: 'rendering',
powers: 'Delaunay triangulation for terrain and globe-surface mesh generation.',
},
'@gltf-transform/core': {
area: 'formats',
powers: 'The glTF read/write/transform pipeline behind every export and optimize path.',
},
'@gltf-transform/extensions': {
area: 'formats',
powers: 'glTF extension support (meshopt, Draco, KTX2) in the export and optimize pipeline.',
},
'@gltf-transform/functions': {
area: 'formats',
powers: 'Mesh simplification, pruning, and resampling transforms used by the optimize panel.',
},
meshoptimizer: {
area: 'formats',
powers:
'Mesh and vertex-cache optimization, and the EXT_meshopt_compression codec every stylize/rig/remesh/segment worker decodes before touching a caller-supplied mesh.',
},
draco3dgltf: {
area: 'formats',
powers: 'Draco geometry compression and decompression for glTF assets.',
},
'gltf-validator': {
area: 'formats',
powers: 'Validates every generated GLB against the glTF 2.0 spec before it ships.',
},
'manifold-3d': {
area: 'formats',
powers: 'Boolean mesh operations (union, difference, intersection) in the mesh-ops pipeline.',
},
'@ffmpeg/ffmpeg': {
area: 'formats',
powers: 'In-browser video/audio transcoding for capture and export flows.',
},
'@ffmpeg/util': { area: 'formats', powers: 'Helper utilities for the @ffmpeg/ffmpeg WASM build.' },
fflate: { area: 'formats', powers: 'Fast zip/gzip (de)compression for asset bundling and uploads.' },
sharp: { area: 'formats', powers: 'Server-side image resizing and format conversion (thumbnails, OG images, textures).' },
hyparquet: { area: 'formats', powers: 'Reads Parquet files for dataset and analytics tooling.' },
'hyparquet-compressors': { area: 'formats', powers: 'Compression codecs for the hyparquet Parquet reader.' },
'@mediapipe/tasks-vision': {
area: 'motion',
powers: 'Pose, hand, and face landmark detection behind video-to-motion capture and the home voice camera lane.',
},
'onnxruntime-web': {
area: 'motion',
powers: 'In-browser ONNX model inference for client-side pose and sign-language recognition demos.',
},
nipplejs: { area: 'motion', powers: 'The on-screen joystick for touch-driven avatar and agent movement.' },
'@elevenlabs/elevenlabs-js': {
area: 'voice',
powers: "The agent's text-to-speech voice in chat, calls, and the home voice loop.",
},
'@ricky0123/vad-web': {
area: 'voice',
powers: 'Browser-side voice activity detection for the hands-free wake-word loop.',
},
'wawa-lipsync': { area: 'voice', powers: "Drives the avatar's mouth shapes from live or recorded speech audio." },
'@avaturn/sdk': {
area: 'assets',
powers: 'The Avaturn avatar creator embedded in the Avatar Creator flow.',
},
'simple-dropzone': { area: 'assets', powers: 'Drag-and-drop file intake for avatar and model uploads.' },
'idb-keyval': { area: 'infrastructure', powers: 'Lightweight IndexedDB storage for client-side caches.' },
express: { area: 'infrastructure', powers: 'The HTTP server behind server/index.mjs in production.' },
'@modelcontextprotocol/sdk': {
area: 'infrastructure',
powers: "The MCP server and tool definitions three.ws exposes to agent clients.",
},
'@solana/web3.js': { area: 'infrastructure', powers: 'Solana transaction building and RPC access across the platform.' },
'@solana/kit': { area: 'infrastructure', powers: 'Modern Solana client primitives used alongside @solana/web3.js.' },
'@coinbase/x402': { area: 'infrastructure', powers: 'The x402 payment protocol implementation for pay-per-call APIs.' },
ethers: { area: 'infrastructure', powers: 'EVM transaction building for the Base and other EVM-chain lanes.' },
viem: { area: 'infrastructure', powers: 'Typed EVM client used alongside ethers for EVM-chain integrations.' },
ajv: { area: 'infrastructure', powers: 'JSON Schema validation for API payloads and agent tool schemas.' },
zod: { area: 'infrastructure', powers: 'Runtime schema validation across the API and agent SDKs.' },
ai: { area: 'infrastructure', powers: 'The Vercel AI SDK powering agent chat streaming and tool calls.' },
'livekit-client': { area: 'infrastructure', powers: 'Real-time audio/video for the LiveKit avatar presence lane.' },
ws: { area: 'infrastructure', powers: 'WebSocket transport for live agent and multiplayer connections.' },
'puppeteer-core': { area: 'infrastructure', powers: 'Headless Chromium automation for server-side rendering and screenshots.' },
'@huggingface/transformers': {
area: 'infrastructure',
powers: 'In-browser transformer model inference for client-side AI features.',
},
colyseus: { area: 'infrastructure', powers: 'Multiplayer room server used by shared 3D spaces.' },
'colyseus.js': { area: 'infrastructure', powers: 'Multiplayer room client paired with the colyseus server.' },
};
// ---- GPU worker models ------------------------------------------------------
//
// Hand-curated from each worker's own README (license and upstream name are
// prose there, confirmed against the upstream LICENSE file on the date
// noted). A worker with no third-party model (pure in-house code, e.g.
// agent-* orchestration workers) has no entry here on purpose.
export const WORKER_MODELS = [
{
id: 'model:trellis',
name: 'Microsoft TRELLIS',
org: 'Microsoft',
license: 'MIT',
repo: 'https://github.com/microsoft/TRELLIS',
area: 'generation',
powers: 'workers/model-trellis: single-image to textured 3D mesh, a Forge image-to-3D lane.',
},
{
id: 'model:trellis2',
name: 'Microsoft TRELLIS.2',
org: 'Microsoft',
license: 'MIT',
repo: 'https://github.com/microsoft/TRELLIS.2',
area: 'generation',
powers: "workers/model-trellis2: the default image-to-3D PBR engine behind Forge's primary lane.",
},
{
id: 'model:sam3d-objects',
name: 'SAM 3D Objects',
org: 'Meta',
license: 'SAM License (Meta, last updated November 19, 2025; use allowed subject to Trade Controls, gated weights)',
repo: 'https://github.com/facebookresearch/sam-3d-objects',
area: 'generation',
powers: 'workers/model-sam3d-objects: rebuilds the objects in one photo as a laid-out 3D scene (Forge and AR Studio "From a photo"), a 32 GB+ GPU lane that stays off until the owner stages the weights.',
},
{
id: 'model:hunyuan3d',
name: 'Tencent Hunyuan3D 2.1',
org: 'Tencent',
license: 'Tencent Hunyuan Non-Commercial License (self-hosted inference only, no redistribution)',
repo: 'https://github.com/Tencent-Hunyuan/Hunyuan3D-2.1',
area: 'generation',
powers: 'workers/model-hunyuan3d: a Forge image-to-3D engine, served worldwide excluding the EU, UK, and South Korea per the license territory clause.',
},
{
id: 'model:triposg',
name: 'TripoSG',
org: 'VAST-AI-Research',
license: 'MIT',
repo: 'https://github.com/VAST-AI-Research/TripoSG',
area: 'generation',
powers: 'workers/model-triposg: a Forge image-to-3D engine.',
},
{
id: 'model:triposr',
name: 'TripoSR',
org: 'VAST-AI-Research and Stability AI',
license: 'MIT',
repo: 'https://github.com/VAST-AI-Research/TripoSR',
area: 'generation',
powers: 'workers/model-triposr: fast single-image mesh reconstruction, a Forge lane.',
},
{
id: 'model:partcrafter',
name: 'PartCrafter',
org: 'wgsxm',
license: 'MIT',
repo: 'https://github.com/wgsxm/PartCrafter',
area: 'generation',
powers: 'workers/model-partcrafter: part-aware 3D generation for segmentable Forge results.',
},
{
id: 'model:holopart',
name: 'HoloPart',
org: 'VAST-AI-Research',
license: 'MIT',
repo: 'https://github.com/VAST-AI-Research/HoloPart',
area: 'generation',
powers: 'workers/model-holopart: completes a part-segmented mesh into per-part and whole-object geometry.',
},
{
id: 'model:anigen',
name: 'AniGen',
org: 'VAST-AI-Research',
license: 'MIT',
repo: 'https://github.com/VAST-AI-Research/AniGen',
area: 'generation',
powers: 'workers/model-anigen: predicts mesh, joint skeleton, and skinning for animatable results.',
},
{
id: 'model:pixal3d',
name: 'Pixal3D',
org: 'TencentARC',
license: 'MIT',
repo: 'https://github.com/TencentARC/Pixal3D',
area: 'generation',
powers: 'workers/model-pixal3d: pixel-aligned image-to-3D built on the TRELLIS.2 backbone.',
},
{
id: 'model:make-it-animatable',
name: 'Make-It-Animatable',
org: 'jasongzy',
license: 'MIT',
repo: 'https://github.com/jasongzy/Make-It-Animatable',
area: 'motion',
powers: 'workers/rig: predicts joint positions, skinning weights, and pose for auto-rigging.',
},
{
id: 'model:unirig',
name: 'UniRig',
org: 'VAST-AI-Research',
license: 'MIT',
repo: 'https://github.com/VAST-AI-Research/UniRig',
area: 'motion',
powers: 'workers/rig-nonhuman: skeleton prediction for non-human auto-rigging.',
},
{
id: 'model:skintokens',
name: 'SkinTokens',
org: 'VAST-AI-Research',
license: 'MIT',
repo: 'https://github.com/VAST-AI-Research/SkinTokens',
area: 'motion',
powers: 'workers/rig-nonhuman: skin-weight prediction, paired with UniRig.',
},
{
id: 'model:ict-facekit',
name: 'ICT-FaceKit',
org: 'ICT-VGL',
license: 'MIT',
repo: 'https://github.com/ICT-VGL/ICT-FaceKit',
area: 'motion',
powers: 'workers/rig: the template head used for facial rigging correspondence.',
},
{
id: 'model:motion-diffusion-model',
name: 'Motion Diffusion Model (MDM)',
org: 'GuyTevet',
license: 'MIT',
repo: 'https://github.com/GuyTevet/motion-diffusion-model',
area: 'motion',
powers: 'workers/model-text2motion: the default text-to-motion backend.',
},
{
id: 'model:momask',
name: 'MoMask',
org: 'EricGuo5513',
license: 'MIT',
repo: 'https://github.com/EricGuo5513/momask-codes',
area: 'motion',
powers: 'workers/model-text2motion: the selectable alternate text-to-motion backend.',
},
{
id: 'model:mediapipe-tasks',
name: 'MediaPipe (PoseLandmarker, HandLandmarker, ImageSegmenter)',
org: 'Google',
license: 'Apache-2.0',
repo: 'https://github.com/google-ai-edge/mediapipe',
area: 'motion',
powers: 'workers/model-video2motion: landmark and segmentation models the pose solver retargets onto the canonical rig.',
},
{
id: 'model:lingbot-map',
name: 'LingBot-Map',
org: 'Robbyant',
license: 'Apache-2.0',
repo: 'https://github.com/Robbyant/lingbot-map',
area: 'generation',
powers: 'workers/model-video2scene: video-to-scene reconstruction.',
},
{
id: 'model:asl-fingerspelling',
name: 'Kaggle ASL Fingerspelling 1st place solution',
org: 'ChristofHenkel',
license: 'Apache-2.0 (code and weights); training data CC BY 4.0',
repo: 'https://github.com/ChristofHenkel/kaggle-asl-fingerspelling-1st-place-solution',
area: 'motion',
powers: 'workers/model-asl-recognition: sign-language fingerspelling recognition.',
},
{
id: 'model:quadriflow',
name: 'QuadriFlow',
org: 'hjwdzh',
license: 'MIT',
repo: 'https://github.com/hjwdzh/QuadriFlow',
area: 'formats',
powers: 'workers/remesh: quad remeshing.',
},
{
id: 'model:xatlas',
name: 'xatlas',
org: 'jpcy',
license: 'MIT',
repo: 'https://github.com/jpcy/xatlas',
area: 'formats',
powers: 'workers/remesh: UV unwrapping for remeshed geometry.',
},
{
id: 'model:manifold',
name: 'Manifold',
org: 'hjwdzh',
license: 'MIT',
repo: 'https://github.com/hjwdzh/Manifold',
area: 'formats',
powers: 'workers/remesh: watertight mesh repair.',
},
{
id: 'model:rembg',
name: 'rembg (with u2net and BiRefNet)',
org: 'danielgatis, ZhengPeng7',
license: 'MIT',
repo: 'https://github.com/danielgatis/rembg',
area: 'generation',
powers: 'workers/rembg: background removal ahead of image-to-3D generation.',
},
{
id: 'model:gltfpack',
name: 'gltfpack (meshoptimizer)',
org: 'zeux',
license: 'MIT',
repo: 'https://github.com/zeux/meshoptimizer',
area: 'formats',
powers: 'workers/stylize and every worker that decodes EXT_meshopt_compression on a caller-supplied mesh.',
},
{
id: 'model:longcat-video-avatar',
name: 'LongCat-Video-Avatar-1.5',
org: 'Meituan',
license: 'MIT',
repo: 'https://huggingface.co/meituan-longcat/LongCat-Video-Avatar-1.5',
area: 'generation',
powers: 'workers/longcat: built and tested, not yet deployed to production.',
},
];
// ---- asset sources and vendored/forked code --------------------------------
export const ASSET_SOURCES = [
{
id: 'asset:polyhaven',
name: 'Poly Haven',
license: 'CC0 1.0',
repo: 'https://polyhaven.com',
funding: 'https://www.polyhaven.com/donate',
area: 'assets',
powers: 'Every prop in the /objects library and the curated HDRI environment set, fetched by scripts/fetch-polyhaven-objects.mjs.',
},
{
id: 'asset:mixamo',
name: 'Mixamo',
license: 'Adobe Mixamo Terms of Use (commercial use permitted, redistribution of raw clips not permitted)',
repo: 'https://www.mixamo.com',
funding: null,
area: 'motion',
powers: 'Most of the curated animation gallery at /animations (the "Studio" tier), exported under an authenticated Adobe account.',
},
{
id: 'asset:quaternius',
name: "Quaternius Universal Animation Library 2",
license: 'CC0 1.0',
repo: 'https://quaternius.com',
funding: 'https://www.patreon.com/quaternius',
area: 'motion',
powers: 'Part of the bulk mocap library at GET /api/animations/library.',
},
{
id: 'asset:mesh2motion',
name: "Mesh2Motion human animation packs",
license: 'CC0 1.0',
repo: 'https://www.mesh2motion.org',
funding: null,
area: 'motion',
powers: 'Part of the bulk mocap library at GET /api/animations/library.',
},
{
id: 'vendor:modly',
name: 'Modly',
license: 'MIT',
repo: 'https://github.com/lightningpixel/modly',
funding: null,
area: 'infrastructure',
powers: 'The desktop app fork, the Modly GPU worker, and the workflow graph behind the Forge desktop and mesh-ops pipelines.',
},
{
id: 'vendor:characterstudio',
name: 'CharacterStudio',
license: 'MIT',
repo: 'https://github.com/M3-org/CharacterStudio',
funding: null,
area: 'infrastructure',
powers: 'The trait-swapping avatar builder that runs inside the Avatar Creator iframe (character-studio/).',
},
{
id: 'vendor:threejs-editor',
name: 'three.js editor',
license: 'MIT',
repo: 'https://github.com/mrdoob/three.js',
funding: null,
area: 'rendering',
powers: 'The vendored scene editor behind the Scene Studio (src/scene-studio/vendor/).',
},
{
id: 'vendor:threeui',
name: 'ThreeUI',
license: 'MIT',
repo: 'https://github.com/MengTo/threeui',
funding: null,
area: 'rendering',
powers: 'A read, pattern-matched third-party source tree under third_party/threeui, not shipped to production.',
},
{
id: 'vendor:openzeppelin',
name: 'OpenZeppelin Contracts',
license: 'MIT',
repo: 'https://github.com/OpenZeppelin/openzeppelin-contracts',
funding: 'https://github.com/sponsors/OpenZeppelin',
area: 'infrastructure',
powers: 'Audited Solidity building blocks for the EVM-chain contracts (contracts/lib/openzeppelin-contracts).',
},
{
id: 'vendor:forge-std',
name: 'forge-std',
license: 'MIT or Apache-2.0',
repo: 'https://github.com/foundry-rs/forge-std',
funding: null,
area: 'infrastructure',
powers: 'Foundry testing helpers for the smart-contract test suite (contracts/lib/forge-std).',
},
];
// ---- license overrides for packages with no declared license in their
// installed package.json -----------------------------------------------------
//
// Checked by hand against the upstream repository on 2026-10-13 because
// `npm` has no license field to fall back on for these.
const LICENSE_OVERRIDES = {
// No LICENSE file and no license field anywhere in the livepeer/livepeer-js
// repo, npm registry metadata, or README as of 2026-10-13.
livepeer: 'not declared upstream (no LICENSE file; verify before redistribution)',
// package.json omits the field, but the upstream repo
// (solana-foundation/solana-attestation-service) carries an MIT LICENSE file.
'sas-lib': 'MIT',
};
// ---- fallback classifier for every other npm dependency --------------------
function fallbackArea(name) {
const n = name.toLowerCase();
if (/ffmpeg|gltf|draco|meshopt|parquet|zip|compress/.test(n)) return 'formats';
if (/three|rapier|bvh|pathtrac|webgl|gaussian|splat/.test(n)) return 'rendering';
if (/voice|speech|tts|stt|lipsync|vad-/.test(n)) return 'voice';
return 'infrastructure';
}
function readJson(path) {
return JSON.parse(readFileSync(path, 'utf8'));
}
function npmEntries() {
const pkg = readJson(resolve(ROOT, 'package.json'));
const names = [
...Object.keys(pkg.dependencies || {}),
...Object.keys(pkg.devDependencies || {}),
].sort();
const entries = [];
for (const name of names) {
const pkgJsonPath = resolve(ROOT, 'node_modules', name, 'package.json');
if (!existsSync(pkgJsonPath)) continue; // reported separately by the build script
const meta = readJson(pkgJsonPath);
const curated = CURATED_PACKAGES[name];
const repoField = meta.repository;
const repo =
typeof repoField === 'string'
? repoField
: repoField && typeof repoField === 'object'
? repoField.url
: meta.homepage || null;
entries.push({
id: `npm:${name}`,
kind: 'npm',
name,
area: curated?.area || fallbackArea(name),
license: meta.license || meta.licenses?.[0]?.type || LICENSE_OVERRIDES[name] || 'unknown',
repo: normalizeRepoUrl(repo),
funding: normalizeFunding(meta.funding),
version: meta.version || null,
powers: curated?.powers || null,
});
}
return entries;
}
export function normalizeRepoUrl(repo) {
if (!repo) return null;
let url = repo
.replace(/^git\+/, '')
.replace(/\.git$/, '');
if (/^git@([^:]+):(.+)$/.test(url)) {
url = url.replace(/^git@([^:]+):(.+)$/, 'https://$1/$2');
} else if (/^ssh:\/\/git@([^/]+)\/(.+)$/.test(url)) {
url = url.replace(/^ssh:\/\/git@([^/]+)\/(.+)$/, 'https://$1/$2');
} else if (/^[^/:]+\.[^/:]+:[^/]+\/[^/]+$/.test(url)) {
url = url.replace(/^([^:]+):(.+)$/, 'https://$1/$2');
} else if (/^[^/\s:]+\/[^/\s:]+$/.test(url)) {
url = `https://github.com/${url}`;
}
return url
.replace(/^git:\/\//, 'https://')
.replace(/^github:/, 'https://github.com/');
}
function normalizeFunding(funding) {
if (!funding) return null;
if (typeof funding === 'string') return funding;
if (Array.isArray(funding)) return normalizeFunding(funding[0]);
return funding.url || null;
}
/** Build the full, deterministic credits dataset. Pure: no side effects. */
export function buildCredits() {
const entries = [
...npmEntries(),
...WORKER_MODELS.map((m) => ({
id: m.id,
kind: 'model',
name: m.name,
area: m.area,
license: m.license,
repo: m.repo,
funding: null,
version: null,
powers: m.powers,
org: m.org,
})),
...ASSET_SOURCES.map((a) => ({
id: a.id,
kind: a.id.startsWith('vendor:') ? 'vendored' : 'asset',
name: a.name,
area: a.area,
license: a.license,
repo: a.repo,
funding: a.funding || null,
version: null,
powers: a.powers,
})),
];
for (const e of entries) {
if (!AREA_IDS.has(e.area)) {
throw new Error(`open-source-credits: entry "${e.id}" has an unknown area "${e.area}"`);
}
}
entries.sort((a, b) => a.area.localeCompare(b.area) || a.name.localeCompare(b.name));
return { areas: AREAS, entries };
}