Log inSubmit server
Posecode logo

Posecode

by posecode-dev

Text-based language and MCP server for describing, validating, and rendering deterministic 3D human motion.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install Posecode

Pick your client, then add it in one click or paste the config.

STDIONode.js
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "posecode-dev-posecode": {
      "command": "npx",
      "args": [
        "-y",
        "posecode-mcp@latest"
      ]
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

We couldn’t confirm it starts correctly

The install command started, but didn't respond the way we expected when we tried to talk to it.

npx -y posecode-mcp@latest

initialize succeeded but no response to tools/list.

This is an experimental automated check and can have false negatives — missing environment variables, a slow cold install, etc. It doesn’t necessarily mean something’s wrong. Last checked 1mo ago.

Overview

Posecode provides a text language to describe human kinematic motion as readable, editable source code. It enables developers, animation tools, and language models to generate, validate, and render anatomically constrained 3D human movements without black-box models. The MCP server exposes APIs for generation, validation, critique, and sharing of movement sequences, making it suitable for applications needing precise, inspectable human motion representations.

Use cases

  • Generate deterministic human motion from text instructions
  • Validate and critique human movement sequences programmatically
  • Render anatomically constrained 3D human figures in web applications
  • Edit and share movement sequences in a structured text format
  • Integrate human motion descriptions into animation or AI workflows

Key features

  • Text-based movement description language (.posecode format)
  • Anatomically clamped joint angle constraints for safety
  • Client-side parsing and rendering of 3D human motion
  • Deterministic and inspectable movement generation
  • MCP server exposing generation, validation, and critique endpoints

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked Today

Recent health check succeeded.

20/21 checks healthy over the last 79d

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 10d ago via OSV.dev · posecode-mcp@latest (npm)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars126Stargazers on the source repository.
npm downloads415Package downloads in the last 30 days.
Last commit2d agoMost recent push to the default branch.
Install checkInconclusiveStarted but did not complete the MCP handshake in our test.
Directory activity3 viewsConfig copies, upvotes, and views on AllMCPs.

From the project README

Posecode

Kinematic motion as text.
An inspectable, editable movement format for animation tools, LLMs, and web products.

Like Mermaid for movement: small text documents for describing, validating, and rendering
deterministic human motion without hiding the source inside a black box.

Live Playground · Movement Library · Language Specification (SPEC.md) · LLM Authoring Guide · Examples · MCP Server

CI status npm version Apache 2.0 and AGPL 3.0 licenses MCP compatible

Why Posecode?

Animation clips and generated trajectories can show movement, but they often hide the semantic decisions that produced it.

Posecode keeps those decisions in readable source. A human can write the document, an animation tool can emit it, or an LLM can draft it. Parsing, validation, editing, and rendering do not require an AI model.

Jumping jacks rendered from a Posecode document

One .posecode document — shoulders: abduct 160, hips: abduct 30, repeat 12 — rendered live in the browser.

For example:

Bend your knees, move your hips backward, and keep your chest upright.

A human may understand that instruction, but a renderer cannot reliably determine:

  • which joints should move,
  • by how many degrees,
  • in which coordinate frame,
  • over what duration,
  • in what sequence,
  • or within which physical limits.

Humans, tools, and language models all need a shared syntax for expressing movement in a renderable and testable form.

Posecode provides that missing representation.

See Posecode in 28 seconds

From readable movement source to validated 3D rendering, MCP tools, and a one-script web embed.

Watch the 28-second Posecode builder demo

▶ Watch the 28-second builder demo
Plain text in. Smooth, programmable 3D motion out.

Movement examples

Deadlift rendered from Posecode
pelvis: hinge — deadlift 		Squat rendered from Posecode
knees: flex 95 — squat 		Lateral raise rendered from Posecode
shoulders: abduct 90 — lateral raise

Why Not Diffusion Text-to-Motion?

Neural text-to-motion systems can generate impressive movement, but they introduce problems for lightweight, programmable applications.

Resource intensive

Many systems require large models and GPU-backed inference, making real-time consumer deployment expensive.

Difficult to control

They usually produce coordinate trajectories rather than editable semantic instructions.

It is difficult to request a precise change such as:

Reduce knee flexion by 10 degrees during the second phase.

Hard to validate

Black-box trajectories do not naturally expose readable joint rules, phase definitions, or range-of-motion limits.

Hard to debug

When a movement looks wrong, developers may not know which semantic instruction caused the problem.

The Posecode Approach

Posecode uses a lightweight, text-driven pipeline.

  • Readable: movements are stored as small .posecode documents.
  • Structured: joints, actions, angles, timings, and constraints are explicit.
  • Editable: developers and models can modify individual movement properties.
  • Fast: parsing and rendering happen client-side.
  • Deterministic: the same Posecode input produces the same validated representation.
  • Inspectable: parser warnings and fidelity checks explain problems.
  • Agent-friendly: the MCP server exposes generation, validation, critique, and sharing tools.
  • Safety-aware: authored and IK-generated angles are constrained by configured range-of-motion limits.

The Idea in 30 Seconds

A .posecode file describes movement as timed phases with targeted joint actions.

1. Write .posecode2. Render the movement
posecode exercise "Body-weight squat"
rig humanoid
pose start = standing

step "Descend" 1.6s settle:
  hips: flex 80
  knees: flex 95
  ankles: dorsiflex 14
  ground-lock: feet
  cue "Sit the hips back"

step "Drive up" 1.2s drive:
  hips: flex 0
  knees: flex 0
  ankles: dorsiflex 0
  ground-lock: feet

repeat 8		Squat animation

OpenAI Build Week 2026: Posecode existed before the hackathon. During Build Week, the project was extended using Codex — running on GPT-5.6 — as the primary engineering tool for a real batch of shipped work: motion/grounding quality, language contract diagnostics, licensing restructuring, release automation, and product-facing pages. The sections below distinguish previous work from Build Week work using actual commit history, not a roadmap.

OpenAI Build Week Extension

What existed before Build Week

Before Build Week, Posecode already included:

  • the core .posecode domain-specific language,
  • a parser and intermediate motion representation,
  • basic range-of-motion validation,
  • a Three.js/WebGL renderer,
  • forward kinematics,
  • basic inverse-kinematics and ground-lock behavior,
  • a browser playground,
  • example movement files,
  • shareable Posecode links,
  • and an MCP server foundation.

This original version was developed primarily with Claude as an AI-assisted engineering tool.

That prior work provides the foundation for the project, but it is not presented as the new hackathon contribution.

What was added during Build Week

Every item below is a merged, dated pull request built with Codex (GPT-5.6) — see Build Week Evidence for direct links.

  1. Motion and grounding overhaul — ROM-constrained reach IK, semantic palm/fist/sole/knee/pelvis contact surfaces, multi-contact refinement, stable support handoffs, and XBot-aware grounding (#76).
  2. Language contract and diagnostics — Posecode language/IR v0.3 custom start-pose blocks with ROM-checked overrides, live and clip-wide grounding/self-collision diagnostics, and an accessible metric floor guide (#92).
  3. Licensing restructure — split the monorepo into an Apache-2.0 standard layer (spec, parser, share, language, LSP, VS Code) and an AGPL-3.0 product layer (render, embed, MCP, eval, playground), with a commercial-license path (#84).
  4. Release automation — Changesets-driven npm publishing via GitHub OIDC, MCP Registry publishing, and CI validation of package versions, entry points, and tarball contents (#66).
  5. Third-party integration readiness — Posecode 0.2 timing vocabulary (drive/settle/flow/snap), a parser validation CLI, and embed compatibility metadata (#62).
  6. Ground-lock correctness — parser-owned validation for per-side foot/hand/elbow ground locks and back-contact support for supine movements, replacing silent acceptance of invalid contacts (#61, #64).
  7. LLM-first landing page and product page — redesigned the landing page around a prompt → Posecode → live 3D story, and added a /for-products page documenting the web component, parser, renderer, and MCP server for integrators (#82, #74).
  8. Mobile and search fixes — mobile toolbar/viewer layout, natural hand orientation, and Google Search indexing corrections (#78, #65).

Build Week feature status

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about Posecode

Posecode is a text language and toolset for describing, validating, and rendering deterministic human motion as structured, editable source code.

Unlike neural systems, Posecode uses a lightweight, deterministic, and inspectable text format that is easy to control, validate, and debug without large models or black-box trajectories.

Yes, the movement source is plain text that humans and language models can write and modify directly.

The MCP server offers APIs for generating, validating, critiquing, and sharing Posecode movement documents.

Yes, Posecode enforces configured range-of-motion limits to ensure authored and inverse-kinematics-generated angles stay within safe anatomical bounds.

Related MCP servers

All in Architecture & Design All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewPosecode AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/posecode-dev-posecode?style=directory)](https://allmcps.com/mcp/posecode-dev-posecode)
HTML Embed
<a href="https://allmcps.com/mcp/posecode-dev-posecode"><img src="https://allmcps.com/api/badge/posecode-dev-posecode?style=directory" alt="Posecode on AllMCPs" /></a>