Skip to content
helmstudio
Contents

h3 studio's manifest

h3 studio makes video with synchronised sound from MiniMax-H3, through a native Metal engine written in C behind a Go server: no Python, and no PyTorch. Its own repository ships this manifest as helmstudio.yaml; the copy here is the registry's, kept in step with it. Scored against the criteria, it passes six of the seven a manifest can answer; it declares no test profile.

The file is studios/h3-studio.yaml, shown in full. A note follows the line it explains.

# A registry entry: a pointer at h3 studio's repository
# (schema/registry-entry.json, docs/design/05-sdk-and-custom-studios.md §5a).
#
# The manifest belongs in the studio's own repository as helmstudio.yaml, beside
# the code it describes, so that a studio can announce a new build step without
# waiting for a helmstudio release. h3 studio does not ship one yet, so the
# manifest is carried inline here — and the pull request that moves `ref` to a
# commit where it does ship one deletes the inline copy, leaving one copy again.
#
# Where the inline manifest sets id, repo or ref, each must equal this entry's;
# the validator enforces it. There is no `certified` field: a level is derived
# from what has actually been checked, never declared by the thing being
# checked (docs/decisions.md M7 Q4, Q15).

id: h3-studio
The id the studio is known by everywhere, and the file is named for it.repo: https://github.com/janishar/h3c-studio
Where helmstudio clones from. It reads the repository with git, never through a forge's API.ref: main
A branch, so an install takes whatever it points at when the clone runs. A registry entry normally pins a commit; docs/decisions.md 2026-09-19 says why this one does not.manifest:
Inline, because the repository ships no helmstudio.yaml at this commit. Where it sets id, repo and ref, each must equal the pointer's, and the validator checks that they do.  # h3 studio's manifest for helmstudio: the same studio the registry points at,
  # described by its own repository, beside the code it runs. The registry entry
  # keeps the pointer — id, repo and ref — and no longer needs a copy of this.
  id: h3-studio
The same id as the pointer's.  name: h3 studio
The name people see.  description: Native Metal video and audio generation from MiniMax-H3, no PyTorch in the loop.
One sentence saying what the studio does.  kinds: [video, audio]
What it makes: video with sound, so both kinds.  # helmstudio 03 §2's identity hue for this studio, chosen against its yellow accent.
  hue: { dark: "#e0a33c", light: "#a06a10" }
Its identity colour in each theme: a stripe, a dot and its clips on the timeline in the launcher, and the accent on its own page.  license: MIT
The studio's own licence. A weight has no licence field yet, so the model's licence is not declared anywhere in the manifest.  repo: https://github.com/janishar/h3c-studio
The same repository as the pointer's.  ref: main
The same branch as the pointer's.  submodules: true
The engine, h3c, is a submodule, and the first build step runs inside it, so the clone fetches submodules too.  peak_ram_gb: 21
What the model occupies once loaded. It is the number the arithmetic uses when another heavy studio is running; the comment says where it came from.  requires:
An Apple Silicon Mac with 64 GB of memory and 200 GB of disk, and the tools the build and the studio call, ffmpeg among them.    os: [darwin]
    arch: [arm64]
    tools: [git, make, cc, go, ffmpeg]
    ram_gb: 64
    disk_gb: 200
  runtime:
A native kernel on Metal, in C: the framework and the backends are separate fields because they make separate claims.    framework: native-kernel
    backends: [metal]
    precision: [bf16, int8]
    language: c
  # What h3 studio actually uses, and no more (criterion 9). A finished take is
  # adopted as an asset and recorded as one gallery item; sequences are
  # helmstudio's timeline; and a render is reported as a task job with its
  # progress and its log, so the launcher can see what this studio is doing.
  # Sessions stay h3 studio's own directories, so kv and records are not
  # requested and a gallery item carries no session_id.
  capabilities: [assets, gallery, timeline, jobs]
Settings and sessions, the files it makes, the gallery and the timeline: four sentences on the approval screen, and a token for exactly those.  # The page loads helm-ui for the shared gallery; it still draws its own takes
  # rail, viewer and timeline, so this pins what it loads and nothing else.
  sdk: { runtime: "^1", ui: "^1", css: "^1" }
Pins major 1 of the runtime SDK and helm-css, which is what criterion 15 asks for.  # Contacted at build or run time, which is what the field means and what the
  # approval screen shows. The Go proxy and the checksum database are here
  # because `go build` resolves helm-runtime-sdk through them; Hugging Face is
  # where the weights come from.
  network: [huggingface.co, cdn-lfs.huggingface.co, proxy.golang.org, sum.golang.org]
The hosts it is expected to contact, for its weights.  build:
Two steps, in order: the Metal engine, built with make in its submodule, then the Go server.    - name: Build the Metal engine
      cwd: h3c
      run: make -j8
    - name: Build the studio server
      cwd: .
      run: go build -o dist/h3studio .
  # FL2VA and Ref2VA are two pipelines inside one MiniMaxAI/MiniMax-H3 repo, both
  # expected as subdirectories of the single directory --model points at
  # (server/model.go). Both share dest so {models.fl2va} and {models.ref2va}
  # resolve to the same directory; files scopes each to its own subtree.
  weights:
Two pipelines from one Hugging Face repository, in one directory, each scoped to its own files. Both are required here, so an install fetches both before the studio is ready.    - name: fl2va
      repo: MiniMaxAI/MiniMax-H3
      dest: MiniMax-H3
      files: ["FL2VA/**"]
      size_gb: 62
    - name: ref2va
      repo: MiniMaxAI/MiniMax-H3
      dest: MiniMax-H3
      files: ["Ref2VA/**"]
      size_gb: 62
  processes:
One process: the Go server, which drives the engine.    - name: studio
      role: main
      heavy: true
It holds the model, so only one heavy studio runs beside it: none.      cmd: "./dist/h3studio --h3 ./h3c/h3 --model {models.fl2va} --port {port} --root {data}"
{models.fl2va} becomes the real path of the weights directory, and {data} the data directory helmstudio keeps for the studio.      port: { prefer: 8710 }
      health: { tcp: true, timeout_s: 30, interval_s: 2 }
      # /api/queue does not answer the busy contract yet, so the switch dialog
      # reads h3 as unknown until it does.
      busy: { path: /api/queue }
Declared, so the switch dialog asks before stopping it. Until h3 serves the busy answer, the dialog reads it as unknown, never as idle.      ui: /