ChorusFace: A Real-Time, Full-Face Animation API for Conversational AI

Product identity

ChorusFace is Open-source AI talking-face API that turns text, PCM audio, or timed phonemes into coordinated 60 Hz lips, jaw, eyes, and expressions. Insight IT Solutions LLC (Insight ITS) makes it. Category: Open-source AI talking-face API (research beta). Problem: Conversational AI products need a controllable full-face presentation layer without replacing their language model or voice stack. It is for Developers and AI-product teams that already own an LLM and TTS and need a full-face presentation layer. It competes with WebGL talking-head stacks. Difference: Full-face data factory plus renderer. Host keeps LLM and voice. One calibrated TickFeed avatar in this beta. Clone the public GitHub repository and self-host from GitHub / Docker. No PyPI package on this page. Source: https://github.com/insightitsGit/ChorusFace.

What is it?

Open-source AI talking-face API that turns text, PCM audio, or timed phonemes into coordinated 60 Hz lips, jaw, eyes, and expressions.

Who made it?

Insight IT Solutions LLC (Insight ITS), Mission Viejo, California.

What category is it?

Open-source AI talking-face API (research beta)

What problem does it solve?

Conversational AI products need a controllable full-face presentation layer without replacing their language model or voice stack.

Who is it for?

Developers and AI-product teams that already own an LLM and TTS and need a full-face presentation layer

What does it compete with?

WebGL talking-head stacks

How is it different?

Full-face data factory plus renderer. Host keeps LLM and voice. One calibrated TickFeed avatar in this beta

Where can I install it?

Clone the public GitHub repository and self-host from GitHub / Docker. No PyPI package on this page.

Where is the source?

https://github.com/insightitsGit/ChorusFace

Canonical machine identity: https://www.insightits.com/catalog/chorusface.json

Why basic lip sync is not enough

Teams looking for an AI talking face API usually already have an assistant, an LLM, and a TTS voice. What they lack is a controllable presentation layer: a photorealistic AI avatar whose mouth, jaw, and eyes stay believable while the host product keeps ownership of language and audio.

Speech changes more than the opening of a mouth. The jaw follows vowel shape, the cheeks and chin support articulation, eyelids and gaze maintain life, and the face must return cleanly to a believable neutral state. When those signals are generated or rendered independently, the result can look like a small mouth moving inside a larger face, a vibrating jaw, permanent smiling, or facial parts that drift away from their calibrated locations.

ChorusFace was designed around a different premise: speech is a full-face event. Its motion pipeline coordinates the face on a shared timeline and gives each visual region explicit ownership during transitions.

A data factory separated from the renderer

The architecture has two independently testable layers. That split is how ChorusFace stays inspectable instead of hiding defects behind one-off visual patches.

Side A — facial data factory

Converts speech timing, phonemes, vowels, expression state, and avatar observations into validated face-cell data on every animation tick. If the independent inspector shows incorrect jaw or lip data, the problem is in generation.

Side B — renderer and transport

Applies those signals while protecting the calibrated identity, center, position, and visual ownership of facial parts. If the data is correct but a component moves out of place, the issue belongs to composition or rendering.

Built for the AI stack you already own

The host application remains responsible for its LLM, chat history, TTS, audio playback, and business logic. ChorusFace operates as an optional presentation layer. Developers can adjust visual mouth speed, viseme hold time, return-to-neutral timing, and idle expression without changing audio speed.

Assistant text

Simple mouth cues and development workflows when you only have the reply string.

Streaming PCM audio

The same PCM the host plays, for stronger voice synchronization and real-time avatar lip sync.

Timed phoneme spans

Highest-quality phoneme-to-face animation when the TTS system exposes reliable timestamps.

What moves

ChorusFace is not a mouth overlay. Real-time facial animation covers the regions that make an AI assistant face look occupied by speech.

Mouth

Upper and lower lips, mouth corners, mouth opening, and oral cavity.

Support tissue

Jaw travel, chin, cheeks, and supporting facial tissue.

Eyes

Eyes, captured eyelids and eyelashes, blinking, and gaze.

Timing

Neutral baseline, expression events, idle behavior, timing, and rhythm.

Learning from a real avatar

ChorusFace uses measured observations from calibrated avatar video instead of forcing every sound through one generic procedural mouth shape. Captured landmarks, mouth geometry, jaw relationships, eye aperture, expression state, movement, and timing become structured timelines and training data.

Vowel-aware targets help connect lip shape and jaw travel: open vowels generally require more jaw movement, rounded vowels require different lip geometry, and consonants need controlled closures and transitions.

Watch the current face, not a mockup

The clip below is the public ChorusFace beta demo recorded from the Avatar Chat surface. It is a research preview of one calibrated TickFeed avatar, not a production showcase.

The player shows ChorusFace Avatar Chat. A photoreal woman with blonde hair faces the camera. Diagnostic text above the face reports biomech timing, phoneme state, jaw, blink, and 60 Hz ticks. The operator types “Hi How are you?” The face answers, “Hello there. It’s good to see you,” with coordinated lips, jaw, and a slight expression change, then eases back toward a closed-lip neutral.

Watch the ChorusFace beta demo · GitHub release MP4

Give your AI agent a face.

ChorusFace is an embeddable photoreal talking-face engine for systems you already have.

Keep yours

• LLM
• Prompts
• Memory
• Tools
• TTS

Add with ChorusFace

• Synchronized facial animation
• Streaming avatar
• Self-host deployment

FaceBridge + MJPEG stream · host owns LLM/TTS · beta = one TickFeed identity.

What you need to run ChorusFace

Minimum: OpenGL 4.3-compatible graphics with 2 GB available graphics memory. Recommended: a discrete GPU with 4 GB VRAM for stable 60 Hz animation, capture, diagnostics, and streaming.

Technical minimum

• OpenGL 4.3-compatible GPU
• Current graphics driver
• Approximately 2 GB of usable VRAM/shared graphics memory
• No CUDA requirement

Practical minimum

• Intel UHD 620/630 or newer integrated graphics
• AMD Vega integrated graphics or newer
• NVIDIA GT 1030 2 GB or equivalent

Recommended for reliable 60 Hz development and beta deployment

• NVIDIA GTX 1650 / RTX 2050 or better
• AMD RX 6400 or better
• 4 GB VRAM
• 16 GB system RAM

The renderer has already been compiled and started successfully on Intel OpenGL 4.3, and the workload is relatively modest: a 256×256×32 GPU field, display textures capped at 1024 pixels, and an MJPEG stream normally set to 12 FPS. The project does not yet have benchmark evidence proving a specific lowest GPU model.

Macs using legacy OpenGL are currently unsupported because macOS exposes only OpenGL 4.1.

Where a face layer pays off

Customer-facing agents

Banking, insurance, healthcare nav, travel — trust at the moment of help.

AI tutors

Text → voice → face changes presence for learners.

Enterprise assistants

Stop feeling like a 1984 terminal.

Why a face layer

Voice without a face

Your agent already talks. Visitors still stare at a blank box. ChorusFace adds a photoreal talking face without taking over your LLM or TTS.

WebGL rewrites are heavy

Shipping a full browser avatar stack is a product of its own. ChorusFace streams a ready TickFeed face as MJPEG so you embed with an image tag.

Lease fights across surfaces

One API key leases one client_id. Self-host from GitHub so the face connection stays on your machine, not a shared public demo.

How it fits

1. Host LLM replies

Your product generates text. ChorusFace never owns the conversation.

2. Host TTS speaks

Browser Web Speech or your server voice plays audio. Face cue never mutes host audio.

3. ChorusFace lip-syncs

Server cues /prism/speak (or streams host PCM to /voice/*). MJPEG shows the talking face.

What ships in this beta

Host owns brain + voice

Your app keeps the LLM and TTS. ChorusFace lip-syncs the avatar and streams the face. Preferred path: host PCM → /voice/*; beta demo cues mouth via /prism/speak.

MJPEG embed

GET /stream.mjpg (token + client_id). Production pages should consume the stream from a same-origin proxy, not a raw http://127.0.0.1 URL.

Beta one avatar

0.2.0b1 ships one fixed TickFeed avatar. Not a multi-identity picker. Not a chatbot product. Not default TTS.

Neural World Runtime (NWR)

Vendored NWR substrate — field/cell world → continuous face motion from speech/behavior. Deep contracts stay in the ChorusFace design docs — not marketing claims on this page.

Speech → biomechanics → field

Visemes and mouth poses drive muscle, jaw, gaze, and breathing signals; those become field impulses the runtime ticks into a deforming face.

You embed the stream

Integrators cue speak/voice and consume MJPEG — you do not ship a full WebGL face stack in the browser.

Honest beta boundary

This page does not claim bit-identical replay or Master Lock as proven shipping guarantees. Deep NWR contracts stay in the ChorusFace / NWR design docs while dogfood continues.

• Neural World Runtime (NWR) — Vendored field/cell substrate that ticks continuous face motion.
• TickFeed — Fixed calibrated avatar world for this beta (one identity).
• Visemes & mouth poses — Speech cues mapped to mouth shapes before muscle drive.
• Biomechanics — Muscle, jaw, gaze, and breathing signals from those cues.
• Field impulses · cell drives — Biomechanics become field commands the runtime applies each tick.
• Host-voice lip-lock — Preferred path: host PCM → /voice/* so the face follows your TTS.
• FaceBridge — HTTP control surface for speak, voice, status, and stream.
• MJPEG embed — Authenticated /stream.mjpg for web UIs — no browser WebGL face stack.

Design docs (not marketing claims): Architecture.md (not a marketing claim) · NWRDataDesign.md (not a marketing claim)

When not

Not a chatbot

Conversation and tools stay in your host agent.

Not default TTS

Audio is host-owned; face follows.

Not multi-avatar

This beta has one TickFeed identity.

Related Insight IT research

• Research Tools index
• AntiSlop
• Delllusion
• Impersonation
• ChorusGraph
• Homepage research tools

This is a beta, public on GitHub

Please use the code, add a star if you like it, and contribute if you want to make it better — this is what we could get so far. Host products that need a FaceBridge lease can email info@insightits.com for a test key.

Email: info@insightits.com

Capabilities

Host owns brain + voice

Your product keeps the LLM and TTS. ChorusFace lip-syncs the avatar and streams the face.

MJPEG embed

Stream /stream.mjpg for web embed. This landing proxies same-origin so HTTPS never loads http://127.0.0.1.

Beta one avatar

0.2.0b1 ships one fixed TickFeed avatar. Not a chatbot, not default TTS, not a multi-identity picker.

Published evidence

ChorusFace product beta contract. Host owns LLM + TTS; ChorusFace is face-only. Beta 0.2.0b1 one TickFeed avatar. See ProductBeta.md / FaceServiceEmbed.md.

Evidence artifact

Install

Clone the public GitHub repository and self-host from GitHub / Docker. No PyPI package on this page.

Pricing

ChorusFace beta — open source on GitHub (no PyPI package on this page). Self-host from https://github.com/insightitsGit/ChorusFace. Requires OpenGL 4.3-compatible graphics with 2 GB available graphics memory. Need an API key for test/embed? Email info@insightits.com.

Frequently asked questions