Local AI

Connect without taking over model management

Local AI supplies on-device GGUF text inference and an app-owned model/settings workspace for Windows and Android. Use it when your product needs a bounded text-generation operation, not a model with unrestricted tool or project authority.

Select uk.capp.sidecar.local-ai, build/install for the intended target and prepare a compatible model through its Studio. The application interface is window.capp.ai.local; local.connect({protocol, clientName}) creates the preferred scoped connection.

Omit appId to bind to the current installed application, or supply its actual compiled identity. A copied example ID can be rejected as local_ai_application_binding_mismatch. The connection's protocol identifies your client contract, not a model name or a licence to connect to another app.

First successful completion

1. Select Local AI in the application's target package. Android provisions the engine as part of the build; the application bundle does not contain your GGUF model.
2. Open the device Studio. Import a compatible model or explicitly download one, inspect its verification/load status and load it.
3. Inspect observed readiness, memory/context limits and any processor execution report. A downloaded file, recommended setting or detected GPU name is not successful inference.
4. Make one small completion from the Studio, then from the scoped app connection. Keep the first output budget small and confirm the returned text.
5. Test Stop, an unloaded/unavailable model and an app reload before making inference part of a required product path.

A configured model can be loaded or prepared by ensureReady() and by a scoped completion. These are not passive status calls. Keep that behaviour behind an explicit user/application choice and never silently switch to a hosted provider after local failure.

A bounded, cancellable product example

This example connects lazily, requests an isolated title only after Generate, writes text rather than HTML, and retains its busy guard until the request settles. No model download credential is embedded.

<section id="local-title">
  <label for="title-notes">Notes</label>
  <textarea id="title-notes" maxlength="800">A notebook for garden observations.</textarea>
  <button data-generate type="button">Generate title</button>
  <button data-stop type="button" disabled>Stop</button>
  <p data-status role="status"></p>
  <pre data-output></pre>
</section>

function bindLocalTitle(root) {
  if (!root) throw new Error('Title form is missing');
  const input = root.querySelector('textarea');
  const generate = root.querySelector('[data-generate]');
  const stop = root.querySelector('[data-stop]');
  const status = root.querySelector('[data-status]');
  const output = root.querySelector('[data-output]');
  if (!input || !generate || !stop || !status || !output) throw new Error('Title controls are missing');
  let client = null;
  let busy = false;
  let disposed = false;
  let stopRequested = false;
  async function run() {
    if (busy || disposed) return;
    const notes = input.value.trim();
    if (!notes || notes.length > 800) { status.textContent = 'Enter 1–800 characters.'; return; }
    busy = true;
    stopRequested = false;
    generate.disabled = true;
    output.textContent = '';
    status.textContent = 'Preparing local inference…';
    try {
      if (!client) {
        const local = window.capp?.ai?.local;
        if (typeof local?.connect !== 'function') throw new Error('Local AI is unavailable');
        client = local.connect({ protocol: 'example.notes.title.v1', clientName: 'Notes title' });
      }
      if (typeof client?.complete !== 'function') throw new Error('Completion is unavailable');
      stop.disabled = typeof client.cancel !== 'function';
      let streamed = '';
      const result = await client.complete({
        prompt: `Suggest one short title for these notes:\n${notes}`,
        maxTokens: 80,
        isolated: true,
        onToken(token) {
          streamed += String(token);
          if (!disposed && !stopRequested) output.textContent = streamed;
        }
      });
      if (!disposed) {
        if (!stopRequested) output.textContent = String(result?.output ?? streamed);
        status.textContent = stopRequested ? 'Request settled after Stop; review any partial text.' : 'Reply received. Review before use.';
      }
    } catch {
      if (!disposed) status.textContent = stopRequested ? 'Stop requested; the request has settled.' : 'Local inference failed. Check the model in Studio.';
    } finally {
      busy = false;
      if (!disposed) { generate.disabled = false; stop.disabled = true; }
    }
  }
  async function cancel() {
    if (!busy || typeof client?.cancel !== 'function') return;
    stopRequested = true;
    if (!disposed) { stop.disabled = true; status.textContent = 'Stop requested; waiting for the request to settle…'; }
    try { await client.cancel(); }
    catch { if (!disposed) status.textContent = 'Could not confirm Stop. Waiting for the active request.'; }
  }
  generate.addEventListener('click', run);
  stop.addEventListener('click', cancel);
  return () => {
    disposed = true;
    generate.removeEventListener('click', run);
    stop.removeEventListener('click', cancel);
    void cancel(); // Scoped to this connection, not another feature's generation.
  };
}
const disposeLocalTitle = bindLocalTitle(document.querySelector('#local-title'));

Call disposeLocalTitle() when removing the view. Disposing does not unload the shared model or delete its file. Keep deterministic validation and any saving, billing or business effects outside the model response.

Application API and readiness

See the exact inference types. Optional methods differ by target/version; inspect the returned connection and its advertised capabilities.

The runtime admits one resident model, one active generation and one model download. A competing request can be rejected as busy; queue or ask the user to retry deliberately rather than opening multiple connections to bypass it. Creating another client does not reserve a second inference engine.

isolated: true starts with bounded request context rather than borrowing another conversation. It does not mean a separate OS process, separate model weights or arbitrary parallel inference. Enforce your own input bounds and inspect installed generation limits before requesting JSON/schema output or large contexts.

Models and processors

On Windows, speech processing defaults to Automatic GPU and uses ONNX Runtime DirectML when the installed DirectX 12 adapter accepts the Kokoro model. Allow CPU fallback keeps the packaged CPU provider available if DirectML is unavailable or session creation fails; CPU only disables GPU speech explicitly. The effective provider is shown after the voice loads. These settings affect Kokoro only and do not change the GGUF model's GPU-layer fitting.

The selected package supplies/provisions the engine, not an embedded GGUF. Import or download the model into the application's storage. A successful download is separate from a successful architecture/quantisation load. Keep a failed-to-load file available for diagnosis rather than assuming the transfer was corrupt.

For Hugging Face downloads, Studio accepts repository, filename, revision and an optional expected SHA-256. A full expected hash is enforced when supplied; length/header checks alone are not the same evidence. Optional access tokens are request-only, not a field to publish in your application source. Android transfers depend on the activity remaining alive; interrupted transfers can retain a resumable part file.

Use Use recommended settings to opt back into device adaptation, or Apply custom settings to choose explicit values. Applying settings during active inference is refused. A change that reloads a model is an explicit operation, not a harmless theme preference.

Windows can adapt context and GPU offload to detected resources while retaining memory headroom and allowing CPU fallback. Android has its own packaged engine/resource constraints. Observed native execution is the evidence for processor use. A recommendation, automatic mode, model catalogue estimate or GPU name is not a guarantee that a completion used the GPU.

Authority

Inference output is text or structured data, not permission to act. Guide, Agent and the application retain their own tool validation and approval boundaries. Local AI does not turn a parsed JSON object into an authorised payment, filesystem operation or application command.

Windows 0.11.6 keeps text weights loaded by default. Studio's Model residency control saves a text idle timeout; zero retains the model. Voice keeps its separate idle policy. Automatic profiles choose a 15,000-token text context when the conservative GPU memory target reaches 4 GiB, otherwise 4,096. Existing custom settings remain unchanged; use recommended settings or apply 15,000 explicitly to opt in. Context capacity and output length are separate, and Kokoro has no GGUF token context.

A healthy unchanged Windows engine can reuse its model for another load or conversation reset. Warm voice readiness reuses its prior synthesis check and reports synthesis rather than repeated engine preparation. Cancellation, failures, processing/model changes or exit can still require a cold load. Real installed latency and provider execution remain verification requirements.

Scoped connections omit owner download credentials and settings controls. They minimise capability exposure but do not isolate hostile JavaScript already executing in the same app environment. Protect sensitive context at its actual owner boundary.

Application preferences such as local/cloud default mode are routing hints to the product, not an automatic cloud fallback or a provider credential. The Studio may show recent application prompts/output in bounded process-memory diagnostics; review that context before sharing a screen or diagnostic export.

Troubleshooting

Local speech beside the text model

Local AI 0.11.3 provides a separate Windows x64 Kokoro speech slot. The existing GGUF stays independent. This is text-to-speech output, not a microphone, voice cloning or arbitrary parallel text models. Android neural speech is not available in this milestone.

Configure the package

In Library → Local AI → Voice engine & model, enable scoped speech. The Windows installer includes the speech engine, private runtime, pronunciation support and its prebuilt dependencies. Native packaging prepares and verifies those dependencies automatically. An incomplete dependency set fails the package build, not a player's first request. No player Python installation, package-manager command, development checkout or terminal setup is required.

Choose the Kokoro v1.0 int8 ONNX preset and default voice. Voice startup defaults to downloading missing model files and loading on launch. Download-only and Manual are alternatives. Allow model downloads controls implicit fetching; explicit owner download/repair remains available. Disabling scoped speech omits its engine payload from that Windows package.

Startup, model controls and playback

Enabled voice begins preparing silently when the installed app starts, alongside the configured text baseline. Only the Kokoro model and matching voice bank download at runtime, not the interpreter or dependencies. Startup does not create an audio context or play a test sentence. After successful model load and synthesis verification, a user audio gesture still allows audible playback. An app request that arrives during startup waits for that same operation rather than creating a duplicate.

Open Voice · installed engine & Kokoro model in Studio. Engine presence, model files and model load are separate states. Model filenames, sizes and recorded hashes can be inspected. Available controls:

Voice, speed, volume, startup policy, CPU threads (1–8) and idle unload (0 keeps loaded) are configurable. Changing threads unloads only the speech model and is refused during active work. This release has one supported speech model architecture/preset; it is not a general-purpose loader for arbitrary voice engines.

The initial model download needs connectivity unless compatible files are imported. A completed, verified model installation supports offline reuse. Existing verified voice weights can survive the update; the old incomplete runtime is not reused. No cloud or OS-speech fallback is added.

The engine recipe fixes versions and filenames and validates actual wheel dependencies during the build. Some digests are embedded pins; remaining wheel digests use exact upstream HTTPS metadata. Models retain observed fixed-release HTTPS or imported-file hashes. These checks are not publisher signing or a completely independently pinned distribution. No application-provided engine path or URL is accepted.

// Call from an explicit user gesture in the trusted app owner.
const owner = window.capp?.ai?.local?.speech;
if (!owner) throw new Error('Local speech is not included in this package');
const voice = owner.connect({protocol:'example.ship.status.v1'});
try {
  await voice.activate(); // Joins startup if pending; retain a busy/progress state.
  await voice.speak({text:'Propulsion online.',voice:'bm_george',speed:1,volume:0.6});
} finally {
  voice.dispose();
}

The owner can subscribe to speech.subscribe(listener) for phase/byte progress and explicitly call speech.prepare({repair: true}) for an in-app repair. Dispose subscriptions when removing the view. Owner preparation shares the same speech lease; it cannot race another connection's synthesis.

Local AI 0.26.0 accepts complete text without a fixed character ceiling. Local AI 0.11.7 targets a short first phrase, then synthesizes and decodes one segment ahead while playing the current one. A ready lookahead starts on the audio clock, avoiding a wait for the previous completion callback. This is bounded segmented speech, not an API for incoming text tokens or individual audio samples. cancel() stops only that connection's own current and scheduled speech; keep your busy guard until speak() settles. Five curated voices are available: George, Emma, Heart, Sarah and Michael. Speed is 0.5–2 and volume 0–1. This English voice preset set does not establish multilingual acceptance.

local.modelSlots() reports separate text/speech slots and unsupported vision/transcription. There is one speech engine per installed application process. Automatic processing prefers DirectML and reports the provider that actually succeeds, including any CPU fallback; choosing Automatic does not prove GPU inference. A verified worker stays resident across normal utterances and utterance-only text rejections. A bounded in-memory audio cache speeds exact repeats. Cancelling active synthesis can stop the worker, so the next utterance may cold-load again. No cloud or browser-speech fallback is automatic. Subtitles remain the appropriate fallback.

Use Studio's editable test passage to compare a new phrase with an exact repeat. Keep idle unload at zero for warm comparisons and measure startup separately. First audio measures admission to the first scheduled buffer, excluding preparation and device output delay. Real-time factor divides synthesis time by audio duration: below 1 means the provider can synthesize faster than the resulting audio plays; a slow first phrase or a later stall can still be audible. Scheduled playback gaps, native/decode timing and cache hits help distinguish provider speed from buffering. These are observed local timings, not a fixed latency guarantee.

Speech client types and bounded native request schema describe the optional extension. The types are a standalone Sidecar contract, not a new npm package. The native host validates compiled selection and ownership; scoped methods do not isolate malicious code already executing in the same app.

Packaged app connection versus engine readiness

On Windows, Local AI Studio belongs to the owning native shell while the packaged application runs in a separate app frame. Local AI 0.10.2 delivers a limited window.capp.ai.local facade to the currently selected, same-origin compiled application. Use that document's connect() and speech.connect(); do not borrow the full parent API or native IPC. Delivery checks the current frame, document, selected package and application identity. Navigation invalidates the old connections and cancels only their owned work.

The facade preserves scoped status, readiness, completion, speech, cancellation and progress callbacks. It can open the owner's Studio, but it does not expose model import/download/deletion, speech repair, filesystem paths or native invocation. Same-origin JavaScript is not a security sandbox against hostile code already executing with the same privileges. Cross-origin pages, unrelated frames and documents without the compiled app binding are not given this interface.

A loaded GGUF in Studio with Connections 0 and an application saying the Sidecar is missing is a connection/delivery symptom, not proof that the model failed. Repackage with the updated factory and selected Local AI; a webpage refresh cannot change its owning shell. Do not delete the GGUF or app data as a connection repair.

The expanded Voice · installed engine & Kokoro model section identifies Kokoro-82M int8 ONNX and its separate voice bank. Check is passive. Selected voice prepares on launch by default; Test voice or an app's activate() joins that preparation or prepares on demand under the configured policy. A loaded text model is not a voice model; ready Android llama.cpp build artifacts do not establish Windows speech readiness. File preparation, model loading, synthesis and audible playback remain separate observations. No user-installed Python or terminal setup is required.

Pronunciation-engine failures

If Studio reports speech_phonemizer_not_bundled or an installed pronunciation binding failure, update or repair the application package with Local AI 0.11.1 or later. The voice weights can be present even when the installed engine cannot load its pronunciation library. Keep the Kokoro files and your GGUF; repairing model files does not replace installer-owned libraries. The builder verifies the bundled pronunciation library and its language data through the same bootstrap used by the installed worker. There is no system-Python or eSpeak installation step for the app user.

Windows speech recovery

Automatic GPU mode verifies the complete speech path, including the first neural inference. If DirectML cannot initialise or execute Kokoro and Allow CPU fallback is enabled, Local AI retries the same request on the packaged CPU provider. Studio reports the provider that actually succeeded. Stage-specific failures distinguish pronunciation, model initialisation and inference; updating the application package does not require deleting GGUF or voice model files.

Optional character dialogue

Local AI 0.12.0 adds a separate Windows x64 slot for prerecorded dialogue. Qwen3-TTS supports voice design, preset speakers and reference cloning through three fixed models. Chatterbox and Chatterbox Turbo provide two further model choices. GGUF text and Kokoro speech retain their own settings and lifecycle.

Rebuild the cApp owner with MCP 0.24.12 and package the application with scoped app speech enabled. In Local AI configuration, set Dialogue authoring engines to Qwen3-TTS, Chatterbox or Both; the default is Not included. Compile again after changing application source or Sidecar settings. A packaging-only owner update can reuse the selected valid release. With Local AI 0.13.0, these large private engines are delivered in one Windows Setup.exe. Download and run that file; it unpacks the included installation files automatically and opens the installer. The package supplies the engine dependencies; users do not install Python or run a package manager. Native build and installed-runtime qualification remain separate acceptance checks.

Applications connect through window.capp.ai.local.dialogue.connect({protocol: 'capp.local-dialogue.v1'}). status() is passive. Explicit prepare({model, device}) downloads and verifies the selected pinned model files and loads the model; render(...) uses verified local files. Models require several gigabytes each and use the shared user model directory described below. Use the fixed model catalogue reported by the installed runtime and prepare only the model the user chooses. No dialogue weights download merely from opening the application or reading status.

The dialogue slot admits one active job. Keep a request busy until its original promise settles after cancel(); call dispose() when retiring the view. Cancellation and unload belong to the connection that owns the job or model. Opening another client does not create another worker.

Dialogue Automatic and CUDA processing require an available NVIDIA CUDA device. A failed GPU attempt reports an error; CPU requires explicit selection. These controls are separate from Kokoro's DirectML and CPU-fallback settings. Installed Windows model loading, generated audio, GPU execution and performance still require qualification; package selection alone does not establish them.

Local AI 0.12.1 with MCP 0.24.4 corrects a package-build failure that labelled the valid embedded Python download as speech_asset_hash_mismatch:python. Rebuild the owner, compile with the updated Local AI package and package again. There is no need to delete downloaded models or verified engine archives. A subsequent speech_asset_size_mismatch reports the expected and received byte counts; a checksum failure remains a separate integrity error.

Shared model directory

Local AI 0.13.0 on Windows stores model weights in %USERPROFILE%\.capp\models, shared between cApp applications built with this release. GGUF folders retain the model/quantization filename plus a content suffix; dialogue folders include the upstream revision; Kokoro uses kokoro-82m-v1-int8-onnx. Refresh models in Studio to rescan. Other installed apps need a rebuild to adopt the store; Android keeps app-private storage.

The first use migrates verified existing model data while retaining old app paths. Models can be read by multiple apps. Repair, import replacement and deletion are refused while another app holds a loaded model lease. Shared deletion affects every app and requires confirmation. Uninstalling one application does not remove this external user directory. Engines, processes, prompts, references and settings remain app-owned.

For additional model families, use a data-only capp-model.json beside the files following the model descriptor schema. kind and format are extensible. Discovery reports file presence and does not grant download/execution rights or assert inference support. A new engine adapter must separately validate its supported files and own preparation, locking and load checks.

Character-dialogue lines have no cApp character cap or fixed output-duration cap. Very long requests may still stop or fail because of the selected engine, memory or its generation defaults; no automatic splitting or guaranteed full reading is implied. Reference clips must remain valid mono 24 kHz PCM16 WAV; their duration is application policy.

Optional sound effects and music

Local AI 0.15.1 adds longer Stable Audio generation and continuation for Windows x64. Enable scoped app speech and Sound and music authoring → Stable Audio 3 · CPU / GPU, rebuild/restart the owner with MCP 0.24.14, freshly Compile your application and Package. The private dependencies are included in the existing single Setup.exe delivery. Preserve application identity and saved data when updating.

Connect through window.capp.ai.local.audio.connect({protocol: 'capp.local-audio.v1'}). status() is passive. After accepting the model terms, call prepare({model: 'sa3-medium', device: 'gpu', acceptLicense: true}). Choose sa3-sfx or sa3-music for Small models, or sa3-medium for music and sound. Status reports selected model download sizes; shared files are reused. Only selected model/device files download.

render({model: 'sa3-medium', device: 'gpu', text: 'A slow sustained synthesizer drone', durationSeconds: 180, seed: 42, steps: 8}) returns base64 audioWav, model revision, seed, actual device and timing metadata. Output is stereo PCM16 44.1 kHz. English prompts remain subject to the model encoder's 256-token capacity; the old 2,000-character ceiling is removed. Longer renders need more resources; acceptance is not a memory-fit guarantee.

Device gpu accelerates diffusion through Windows DirectML; prompt encoding and the audio codec use CPU. Device cpu selects LiteRT explicitly. GPU preparation requires a finite forward and observed GPU partition, and does not silently become a CPU session. Switching between audio and character dialogue releases the previous authoring model. Active work is protected; GGUF and Kokoro keep separate slots.

For continuation, pass sourceWav containing nonempty mono/stereo PCM16 44.1 kHz context. durationSeconds includes that context and at least one new second. The returned prefix preserves the input PCM; append the new region to your original track. Voice Lab 1.5 supplies this workflow in its editor, plus import, trim/cut, fades, undo/redo and new-version saves. Music remains mixed audio, without isolated stems or lyrics-controlled singing.

Windows private-interpreter import checks are mandatory during packaging. Linux neural checks and browser fixtures do not establish DirectML hardware performance or installed acceptance. Render locally prepared weights; no cloud provider fallback or runtime package installation is provided.

Powered by Stability AI. Review the model licence and Gemma terms before preparation or distribution.

Local AI 0.15.1 fixes continuation requests rejected with local_ai_app_request_invalid in packaged application frames. Update the owner to MCP 0.24.14, freshly Compile with Local AI 0.15.1, then Package and install the updated application. Existing models and saved recordings can be retained. Voice Lab 1.5.1 adds descriptive hover tooltips to its buttons.

Project audio folders

Local AI 0.16.0 adds an optional Windows project-audio capability. Enable Project audio folders, retain scoped app speech, rebuild/restart the owner with MCP 0.24.15 and freshly Compile/Package the app. This option is off by default. It does not load a model or grant general filesystem access.

local.audioProjects.connect({protocol:'capp.audio-project-client.v1'}) creates a scoped connection. open() presents a native folder picker for a project with capp-audio-project.json. Draft WAVs and metadata remain under the user's .capp/audio-drafts folder; approve({id,sha256}) copies an exact reviewed take into the project's assets/audio tree and retains the draft. Per-take metadata records preserve source/recipe history, file format and SHA-256. Caller-chosen paths and arbitrary file operations are not accepted.

Voice Lab 1.6.0 provides project opening, automatic copies of newly saved takes, manual export of existing recordings, a draft/approved browser, audition and explicit approval. Updating keeps the existing recording library and model weights. New approved audio still needs deliberate gameplay event bindings. Source and bridge checks do not establish an installed Windows build or file picker/approval acceptance.

Image-to-3D authoring

Local AI 0.18.0 provides a separate Windows x64 image-to-3D capability. Enable Scoped 3D generation, select Image-to-3D engine → TripoSR, rebuild the cApp owner with MCP 0.24.17, then freshly Compile and Package the application. Speech permission is not required. A private CUDA-capable Python engine is bundled with the app; the player does not install Python, pip or the CUDA toolkit. GPU use requires an NVIDIA driver.

The app connects through its own window.capp.ai.local.models3d facade using protocol capp.local-models3d.v1. Preparation requires explicit acceptance of the selected model’s licence. Only that fixed, pinned model is downloaded. Render accepts a bounded PNG, device choice and detail 128 or 256; TripoSR output is a static GLB with vertex colours. Advanced shapes support seed, steps and separate multiview inputs. No URL, path, cloud fallback or arbitrary executable is accepted. Status does not prepare models. Stop terminates the owned job while preserving downloaded weights.

For TripoSR, automatic device choice uses suitable NVIDIA GPU capacity or CPU and reports the actual device. Explicit NVIDIA selection fails if unavailable. 3D, audio and dialogue share one heavy authoring slot within an application. Android 3D generation, automatic background removal, texture generation, rigging and animation are not implemented. Linux CPU inference has been exercised; installed Windows and CUDA acceptance are separate tests. Existing audio workflows and shared model identities are retained.

Hunyuan detail and memory

Local AI 0.22.0 adds 384/512 mesh detail to the four Hunyuan shape models, finite guidanceScale 0–20, integer numChunks 1000–32000 and memoryMode gpu or cpu-offload. Defaults remain guidance 5, batch 8000 and GPU. CPU offload also applies during preparation and still requires NVIDIA CUDA. It uses system RAM and can be slower; smaller batches reduce only part of peak decoding memory. Other models retain their current resolution limits. These controls affect geometry.

3D Lab 0.18.0 retains the settings with each generation and restores them when reusing its reference. Rebuild/restart the owner with MCP 0.24.26, then freshly Compile and Package with Local AI 0.23.0. Existing model weights and identities are reused. Source, dispatch and controlled-browser checks are separate from pending installed Windows, real CUDA quality and memory acceptance.

Image-to-3D model selection

Local AI 0.18 adds an optional Windows shape engine for TripoSG and Hunyuan 2 mini, 2, multiview and 2.1. TripoSR remains available with CPU support and now exports normals. Applications receive per-model availability and may pass bounded multiview references, seed and steps through the scoped 3D facade.

3D Lab lists nine models with their memory requirements. SF3D, SPAR3D and TRELLIS.2 are labelled as requiring runtime setup; they are not included as working engines in this release. Added Windows/CUDA pipelines still require target verification. Rebuild the owner with MCP 0.24.17, freshly Compile, then Package. Model licences and downloads remain explicit per-model actions.

Animation authoring

Local AI 0.21.1 provides a separate Animation authoring grant. Select UniMate + MoMask motion + UniRig skeletons for all three models, or retain UniMate-only selection. Rebuild the owner with MCP 0.24.20 and freshly Compile then Package the application.

window.capp.ai.local.animation.connect({protocol:'capp.local-animation.v1'}) exposes status, prepare, render, cancel, unload and dispose. Preparation requires explicit model licence acceptance; status never downloads. Model/device readiness comes from the verified packaged runtime.

Motion requests take a prompt, duration, seed, device and one connected rest skeleton, Y-up and facing +Z. UniMate now uses upstream anatomy conditioning, an adaptive initial solver and previous-tail conditioning for longer actions. It is still experimental; long-range intent and foot contacts need review. MoMask returns canonical humanoid motion for retargeting. UniRig instead accepts flat mesh positions/indices and returns a proposed skeleton in the input coordinates. Review and apply it before a separate local binding step; it does not generate animation or neural skin weights. Its CPU path uses one sample and CUDA uses the upstream 15-beam profile, with different memory and quality tradeoffs.

Version 0.21.1 extends the existing eight-frame join correction to root movement as well as local rotations. Complete return windows preserve the final pose and later generated trajectory; incomplete final windows are left unchanged. This applies to newly generated actions after an owner rebuild and fresh application Compile/Package. It is a bounded join repair, with installed/neural quality still requiring review. Optional editing smoothing is a separate, deferred design issue.

UniMate's checkpoint is CC BY-NC 4.0. MoMask code is MIT; its pinned checkpoint mirror and CLIP dependency are documented in the packaged provenance. UniRig includes MIT checkpoint/wrapper terms and GPL-3.0-or-later encoder source. Licence acceptance remains explicit. Full source and notices accompany the runtime. Models download only on preparation, with exact file-size and hash verification.

3D Lab 0.8.0 fixes bone-segment skin ownership and source-rest retargeting, retains editable actions and prompts, and adds non-destructive skeleton review. Existing saved weights are retained; use Bind with smooth weights to replace old automatic weights. Manual rigging and saved playback work without a model loaded. Real Linux CPU inference and controlled browser checks do not certify installed Windows/CUDA; representative motion quality remains an acceptance step.

Local AI 0.22.1 and 3D Lab 0.19.2 remove the fixed output vertex and triangle ceilings. Generated meshes retain their detail. GLB files still have a 64 MiB transport/import bound and must pass structural validation. Larger geometry uses more memory; source checks do not establish installed Windows or GPU performance.

Reference framing and Builder textures

Local AI 0.23.0 adds Hunyuan render imagePadding, finite 0.05–0.25 with default 0.15. It controls foreground framing in the pinned image processor. Each render resets the value, confirms it in the result and reports conditioning dimensions, view names and extraction details. Other models and preparation reject this field. The 512-pixel conditioning size and model weights are unchanged. Tight framing is an experiment to compare with identical views and seed, not a promise of sharper geometry. Rebuild/restart the owner and freshly Compile/Package the application.

3D Lab 0.20.0 exposes Standard, Tight and Wide framing and retains it in disk recipes. Its Builder also applies colour, normal, roughness and metalness images; clear or frosted glass; and visible-surface UV texture baking from retained reference views. Textures embed in saved/exported GLBs and original drafts remain intact. Source baking preserves triangles and does not infer hidden artwork or repair geometry. This is local image projection, not a neural texture model. Physical glass needs matching glTF material-extension support in the receiving renderer.

GLB export after generation

Local AI 0.23.1 repairs undefined vertex normals before advanced-model GLB export, preventing the pinned exporter's division by zero from writing invalid JSON metadata. Positions, faces, triangle counts, model weights and dependency pins are unchanged. The export is checked before returning it. 3D Lab 0.20.1 retains completed invalid bytes for explicit recovery download instead of silently losing the result; invalid assets cannot enter the draft catalogue. Rebuild/restart the owner and freshly Compile/Package the Lab. Pinned-export and browser tests are separate from pending installed Windows/CUDA acceptance.

Standalone Hunyuan 2.1 paint for native apps

Local AI 0.24.0 added experimental Windows native colour painting for an existing mesh and Front reference. Local AI 0.25.0 adds actual generation resolutions from 256 to 1536 pixels per side, in steps of 64, and optional round-robin passes. This native authoring path is separate from the browser shape-generation API. It returns four base-colour images for review and baking; it does not regenerate the mesh, rig or animation. Model preparation and licence acceptance are explicit.

In Creative Suite 0.26.0, start with 512 pixels and 20 steps. Large meshes receive a disposable reduced painting copy, while colour is baked onto the full-detail original. Round robin paints Front → Right → Back → Left using the same source reference and loaded weights. All four views together remains available. Single side passes skip cross-view attention, so inspect seams and material consistency. Higher resolutions are experimental and may run out of memory or fail to improve quality. Reduce the slider and retry; the original model remains intact.

Generated views remain separate until reviewed and applied. Repeated tests reuse the original Front reference by default, and previous results stay retained. Final atlas size is chosen separately in the baking controls. Roughness and metalness are not applied by this integration.

Rebuild/restart the owner with MCP 0.24.33 / Local AI 0.26.0, then freshly Compile and Build the consuming native application. Existing verified weights are reused. Android 0.23.3 removes silent prompt/system truncation and its fixed output-token ceiling. These changes do not add an Android paint pipeline. CPU/source checks do not establish the new modes' installed Windows behavior, GPU memory fit or visual quality.

Local AI 0.25.1 corrects the paint surface maps to the model renderer's coordinate, normal and position conventions. New results identify that conditioning version; regenerate old results to evaluate the correction. This repairs input semantics but does not establish corrected GPU visual quality. Creative Suite 0.25.1 also provides an undoable Clear all textures action for fresh bakes, retaining reference images and model geometry. Load generated references, clear the old finish if needed, then Preview baked workflow, Apply and Save.

Application-controlled model workloads

Local AI 0.26.0 removes arbitrary workload ceilings from supported model adapters and their artifact transport. Paint no longer stops at 100,000 triangles or 1536 pixels; shape generation no longer uses a short resolution preset whitelist. UniRig accepts larger source meshes; UniMate can assemble motion beyond 60 seconds. Speech/audio reference length and text ceilings are removed. Kokoro batches long phoneme sequences, and text inference admits requests against the loaded model's actual context and caller token budget. Android 0.23.3 preserves complete prompts.

Creative Suite 0.26.0 exposes a 10,000–1,000,000 painting-copy slider, default 100,000, with its own memory budget and actual-count reporting. Its image slider still covers 256–1536 pixels. Raising either control can exhaust resources; it does not promise better detail or a GPU fit. The original mesh stays intact.

Actual architecture and format requirements still apply: aligned paint dimensions, TripoSG power-of-two octrees, UniMate's joint tensor, UniRig's joint decoder, MoMask's native motion window, Stable Audio's encoder and compiled graph shapes, Kokoro's batch/speed requirements and the loaded text-model context. Permissions, integrity checks, cancellation and schema-parser safeguards remain in place. Rebuild the owner and consuming applications. CPU/source checks establish the changed admission behavior; native, GPU and visual acceptance remain separate.

Configuration reference

These are the selected package's configuration fields. String credential values and installation-specific defaults are never published here. A field's presence does not bypass its runtime policy.

Agent interfaces

These names are declared by the package for host/Agent integration, not JavaScript methods to invoke directly. The host must register a tool, grant its scope and enforce its approval policy. A manifest declaration alone does not prove availability in every Agent catalogue. Prefer the application API above when integrating your own app.