A script becomes a speaking character through four controlled gates: define a playable performance unit, review the generated performance in the browser, publish a ready Snippet Set and integrate the resulting prefab through the smallest suitable Unity playback path.
That sounds more deliberate than “paste text and generate,” because it is. A script can be approved while its spoken rhythm is weak. A performance can look good in a browser but compete with the camera or interface in Unity. An imported prefab can play correctly while the surrounding application triggers it at the wrong time.
Treat each stage as a separate artifact with its own approval question. That makes the path easier to debug and much easier for writers, producers, animators and developers to share.
The four gates from script to scene
Gate | Output | Approval question |
|---|---|---|
1. Performance unit | One or more playable Snippets inside a coherent Snippet Set | Is each unit clear when spoken and useful on its own? |
2. Browser performance | Reviewed voice, timing, lip-sync, face, body, gaze and text | Does the performance express the intended moment without conflicting signals? |
3. Published set | A versioned Snippet Set ready for the Unity SDK | Are audio and animation confirmed for every included Snippet? |
4. Unity scene | Imported or updated prefabs using the right playback path | Does the character work in the real camera, timing and application context? |
The gates are not departments. One person may own several of them. Their value is that everyone can see which question is still open.
Gate 1: define a playable performance unit
In Snippets, one reusable unit of animated dialogue is a Snippet. It can contain the script, audio, word timing, viseme data, facial and body animation, duration and related metadata. A Snippet Set groups related Snippets for a tutorial, scene, conversation or one character’s lines.
Do not divide the script only by paragraph length. Divide it where the performance or application needs control. A useful boundary often appears when:
the communicative job changes, such as moving from explanation to instruction;
the character needs to pause for a user action;
another actor or application event takes the turn;
the scene may branch before the next line; or
a line should be replaceable without rebuilding the surrounding sequence.
For example, “Welcome. Choose a station. I’ll explain what happens next” contains at least two possible units. The welcome can play immediately. The explanation should wait until the application knows which station the user selected.
This is where Building Content for Characters, Not Screens becomes practical. Its scene beats, triggers and handoffs help determine where one Snippet should end and the next system decision should begin.
Gate output: a Snippet Set whose units match real moments in the experience, not arbitrary chunks of text.
Gate 2: generate, then direct the performance
Dialogue can enter a Snippet Set from a script, a prompt or uploaded audio. Generation is the starting interpretation, not the approval.
Review the result in the browser with the script and timeline visible. Current controls let teams play, pause, seek, select a text or timeline range and request a more specific change. A selected section can be simplified when it is too active, varied when the existing choice is close or regenerated when the interpretation needs a new pass. Generic A, B or C choices can change the base pose or style.
Use those controls as directing decisions:
Simplify when movement competes with the line or visual target.
Vary when the timing and intention work but the chosen motion does not.
Regenerate when the section needs a different interpretation.
Change the base pose when the whole unit begins from the wrong physical attitude.
Then review the channels together. Lip-sync should align with the voice. Gesture and facial emphasis should support the same words. Gaze should have a target. The character should settle before control passes to the audience or application.
For a channel-by-channel check, use Body Language Is Part of the Message. For whole-performance cause and effect, use the Presence Loop.
Gate output: each included Snippet has approved audio and animation, with known handoff timing.
Gate 3: publish a ready Snippet Set
The Unity SDK consumes a published Snippet Set. It does not generate the set locally. In the current workflow, every included Snippet needs confirmed audio and animation before the set can be published.
Publishing packages the set for delivery. The export includes set and Snippet metadata plus per-Snippet audio and animation assets. This is the boundary between an editable browser performance and a version Unity can import.
Before publishing, run a small release check:
Confirm the final script text and order.
Play every Snippet from beginning to end.
Verify audio and animation readiness.
Confirm that handoff pauses belong either in the performance or the application, not accidentally in both.
Keep the Snippet identity stable when you expect an existing Unity reference to update in place.
The word “publish” here refers to making the Snippet Set available to the Unity SDK. It is not the same as releasing the game, training application or website.
Gate output: a published Snippet Set that appears in the Unity import workflow.
Gate 4: choose the smallest Unity playback path
The current SDK covers Unity 2022.3 LTS, Unity 6.0 LTS and Unity 6.3 LTS. The verified cloud workflow requires a Snippets account, internet access for cloud operations and published platform content. Its main dependencies include UniTask, UnityGLTF and TextMeshPro. If the project already uses another GLTF importer such as glTFast, check for importer conflicts before integration.
After authentication, the SDK can list published sets, download their raw assets and generate prefabs from a selected template. The default generated location is Assets/My Snippets/<Snippet Set Name>/, with generated prefabs and a Raw folder.
Choose playback by scene complexity:
Need | Start with |
|---|---|
One synchronized performance |
|
One configured action for a prototype, UI or QA |
|
Ordered dialogue, pauses, walking or custom-animation steps |
|
Procedural movement or gaze | Add |
For one line, begin with SnippetPlayer. A generated prefab can play on enable or through Play() and Stop(). Do not introduce a flow controller before the scene needs sequencing.
For controller-driven scenes, the recommended setup command is Snippets > Scene Auto Setup. The actor registry owns lookup and coordination, while the flow controller executes ordered steps. The surrounding application still decides when a branch, gameplay condition or scenario state should trigger a particular performance.
Gate output: the character plays correctly in the target Unity scene through the least complex suitable runtime path.
Test the scene, not only the asset
The final review happens in Unity because the scene changes the meaning of the performance.
Run the character at the real camera distance. Keep interface motion, subtitles, other actors and the actual trigger active. Check whether the voice is audible, the target of a gesture is visible and the character leaves space for the next action. Confirm that stopping or changing steps returns the performance to an acceptable state.
Separate the review into three questions:
Script review: Is the line correct, speakable and divided at the right handoff?
Performance review: Do voice, timing, face, body, gaze and text form one readable action?
Scene review: Does the asset play, stop and hand control back correctly in the application?
If the scene review fails, identify the owning layer before editing. A late trigger belongs to application logic. A mismatched gesture belongs to the performance. A line that gives away the answer belongs to the script.
Update without losing the thread
When a published set is updated, the SDK matches existing prefabs by Snippet ID and updates them in place. New Snippets generate new prefabs. Removed remote Snippets are removed locally. Existing scene and prefab references are preserved when the ID remains stable.
That is a useful update path, not permission to ignore structural changes. Renaming, removing or reorganising content can still require a reference review. Removing a set from Unity deletes its local generated and raw assets, but it does not delete the cloud set.
Before a substantial update:
note which Snippet IDs are already referenced in scenes or prefabs;
update one representative set first;
review removals and renamed content explicitly;
run the same script, performance and scene checks again; and
keep application logic separate from the authored performance.
Common failure patterns
Symptom | Likely owning layer | First check |
|---|---|---|
The line feels rushed or difficult to follow | Script | Read it aloud and split at the next genuine action or turn |
The character moves continuously | Browser performance | Simplify the range and restore a clear prepare-deliver-settle rhythm |
The set does not appear for import | Publish gate | Confirm the set is published and every Snippet has ready audio and animation |
The prefab plays but the moment feels wrong | Unity scene | Check camera, trigger timing, UI competition and the visual target |
An update breaks a reference | Content structure or Unity | Check whether the relevant Snippet ID, removal or hierarchy changed |
The character cannot decide what to say next | Surrounding application | Branching, real-time conversation and scenario state are outside the authored performance |
This diagnostic order prevents teams from trying to repair every problem with more animation or more code.
Before choosing the surrounding interaction model, compare the production trade-offs in Scripted Characters vs Autonomous NPCs.
Prove one complete line first
Choose one representative line with a real trigger and handoff. Move it through all four gates. Keep the first Unity setup as small as the scene allows, then review the result in context.
Once that line works, add the next Snippet and the next application decision. A speaking character becomes dependable when every layer has a clear artifact, owner and exit condition—not when every layer is collapsed into one button.
If you are evaluating this workflow for a Unity project, use the Snippets early-access process to test one representative scene and its technical requirements.
Written by Cristian Anton
