loudkit 0.1.1: two models, 28 voices, released revisions

.gitattributes

@@ -33,3 +33,21 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+audio/loudr-1/clara.opus filter=lfs diff=lfs merge=lfs -text
+audio/loudr-1/colette.opus filter=lfs diff=lfs merge=lfs -text
+audio/loudr-1/emma.opus filter=lfs diff=lfs merge=lfs -text
+audio/loudr-1/henri.opus filter=lfs diff=lfs merge=lfs -text
+audio/loudr-1/henry.opus filter=lfs diff=lfs merge=lfs -text
+audio/loudr-1/lucy.opus filter=lfs diff=lfs merge=lfs -text
+audio/loudr-1/miles.opus filter=lfs diff=lfs merge=lfs -text
+audio/loudr-1/oliver.opus filter=lfs diff=lfs merge=lfs -text
+audio/loudr-1/oscar.opus filter=lfs diff=lfs merge=lfs -text
+audio/loudr-1/sophie.opus filter=lfs diff=lfs merge=lfs -text
+audio/turbo/clara.opus filter=lfs diff=lfs merge=lfs -text
+audio/turbo/emma.opus filter=lfs diff=lfs merge=lfs -text
+audio/turbo/henry.opus filter=lfs diff=lfs merge=lfs -text
+audio/turbo/lucy.opus filter=lfs diff=lfs merge=lfs -text
+audio/turbo/miles.opus filter=lfs diff=lfs merge=lfs -text
+audio/turbo/oliver.opus filter=lfs diff=lfs merge=lfs -text
+audio/turbo/oscar.opus filter=lfs diff=lfs merge=lfs -text
+audio/turbo/sophie.opus filter=lfs diff=lfs merge=lfs -text

README.md

@@ -9,56 +9,48 @@ python_version: "3.12.12"
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: On-device TTS. Twenty voices, ten languages, one engine.
+short_description: On-device TTS. 28 voices, ten languages, two models.
 models:
   - loudreader/loudr-1
+  - loudreader/loudr-1-turbo
 preload_from_hub:
-  - loudreader/loudr-1 loudr-1.safetensors,loudr-1-enrollment.safetensors,ve.safetensors,manifest.json,release.json,SHA256SUMS,voices/carmen.safetensors,voices/colette.safetensors,voices/dante.safetensors,voices/darkman.safetensors,voices/dave.safetensors,voices/freja.safetensors,voices/gosia.safetensors,voices/henri.safetensors,voices/ines.safetensors,voices/joe.safetensors,voices/kathleen.safetensors,voices/kerstin.safetensors,voices/nathalie.safetensors,voices/nils.safetensors,voices/paola.safetensors,voices/pim.safetensors,voices/selma.safetensors,voices/soren.safetensors,voices/thorsten.safetensors,voices/tugao.safetensors
+  - loudreader/loudr-1 loudr-1.safetensors,loudr-1-enrollment.safetensors,ve.safetensors,tokenizer.json,manifest.json,release.json,SHA256SUMS,voices/carmen.safetensors,voices/clara.safetensors,voices/colette.safetensors,voices/dante.safetensors,voices/darkman.safetensors,voices/dave.safetensors,voices/emma.safetensors,voices/freja.safetensors,voices/gosia.safetensors,voices/henri.safetensors,voices/henry.safetensors,voices/ines.safetensors,voices/joe.safetensors,voices/kathleen.safetensors,voices/kerstin.safetensors,voices/lucy.safetensors,voices/miles.safetensors,voices/nathalie.safetensors,voices/nils.safetensors,voices/oliver.safetensors,voices/oscar.safetensors,voices/paola.safetensors,voices/pim.safetensors,voices/selma.safetensors,voices/sophie.safetensors,voices/soren.safetensors,voices/thorsten.safetensors,voices/tugao.safetensors
+  - loudreader/loudr-1-turbo loudr-1-turbo.safetensors,tokenizer.json,manifest.json,release.json,SHA256SUMS
 ---
 
 # loudkit
 
-Twenty voices across ten languages, from [loudreader/loudr-1](https://huggingface.co/loudreader/loudr-1),
+Twenty-eight voices across ten languages, on two models:
+[loudreader/loudr-1](https://huggingface.co/loudreader/loudr-1) and
+[loudreader/loudr-1-turbo](https://huggingface.co/loudreader/loudr-1-turbo),
 running the [loudkit](https://github.com/loudreader/loudkit) engine on ZeroGPU.
 
 ## Two tabs
 
-- **Voices.** Twenty voices, each beside the reference recording it was enrolled
-  from. English first, with a dropdown for the other nine languages. The samples
-  were rendered ahead of time and ship in this repo, so playing them uses no GPU.
-  Under them is a box for your own text, up to 1,000 characters.
-- **Clone.** A voice from about ten seconds of audio. Try a shipped example, or
-  record yourself.
+- **Voices.** Twenty-eight voices, each beside the reference recording it was
+  enrolled from, and each rendered on both models from the same passage at the
+  same seed. English first, with a dropdown for the other nine languages. The
+  samples were rendered ahead of time and ship in this repo, so playing them
+  uses no GPU. Under them is a box for your own text, up to 1,000 characters,
+  and one that renders the same words on both models side by side.
+- **Clone.** A voice from about ten seconds of a recording, then speak with it
+  on either model. One profile serves both, which is what a portable voice
+  profile means. The microphone is the default path; an upload is gated on a
+  confirmation, and neither recording outlives the request.
 
-ZeroGPU bills GPU time to the visitor, not to the owner. An anonymous visitor
-gets about two minutes a day. A signed-in free account gets about five. Listening
-costs none of it.
+## What this demo is honest about
 
-## Cloning and consent
+ZeroGPU bills GPU time to the visitor. Listening costs nothing, because the
+fifty-six samples are files. Speaking and cloning spend the visitor's own daily
+quota, which is why the text boxes are capped well below what the library takes.
 
-Clone your own voice, or a voice you have permission to use.
+Both models are pinned to an immutable Hub commit rather than to a branch, so
+the fingerprint the page prints is the fingerprint of the bytes it ran.
 
-- Four shipped examples let you hear cloning without recording anything. Their
-  donors released them for building TTS voices.
-- Recording yourself is the next path. It clears the example.
-- An upload is last, and needs an explicit confirmation.
-- Recordings are deleted when the request ends. The voice embeddings are never
-  written to disk and never leave the process.
-- Cloned audio carries no download button.
+Output files carry C2PA provenance: the algorithm fingerprint, the recipe and
+the seed.
 
-See [RESPONSIBLE_USE](https://github.com/loudreader/loudkit/blob/main/RESPONSIBLE_USE.md).
-
-## Determinism
-
-The Voices tab has a determinism check. It renders the same text twice at the same
-seed and prints the SHA-256 of both waveforms. They match.
-
-That holds within this build and this device. loudkit promises a bit-identical
-waveform for the same seed, build, backend and input. It does not promise that
-your machine matches this GPU. See the
-[identity contract](https://github.com/loudreader/loudkit/blob/main/docs/reference/IDENTITY-CONTRACT.md).
-
-## Run it locally
+## Running it locally instead
 
 ```bash
 pip install "loudkit[torch,audio,enroll,hub]"
@@ -67,16 +59,9 @@ pip install "loudkit[torch,audio,enroll,hub]"
 ```python
 import loudkit as lk
 
-engine = lk.load("loudreader/loudr-1")
-voice = lk.voice("kathleen", repo="loudreader/loudr-1")
+engine = lk.load("loudreader/loudr-1", revision="v0.1.1")
+voice = lk.voice("kathleen", repo="loudreader/loudr-1", revision="v0.1.1")
 engine.synthesize_long("Hello from loudkit.", voice, seed=7).save("hello.wav")
 ```
 
-Audio in this Space, and from `Result.save`, carries C2PA provenance: the
-algorithm fingerprint, the recipe and the seed.
-
-## Voice sources
-
-Every voice is enrolled from a public-domain or openly licensed recording.
-`voices.json` in this repo carries the full record for each one: donor, source,
-licence, consent, and the SHA-256 of both the reference and the sample.
+Nothing is queued and nothing is metered.

app.py

@@ -1,24 +1,32 @@
-"""The loudkit demo Space: hear twenty voices, speak your own text, clone your own.
+"""The loudkit demo Space: twenty-eight voices, two models, one engine.
 
 ZeroGPU bills GPU time to the *visitor*, not to the owner: an anonymous visitor
 gets about two minutes a day, a signed-in free account about five. A demo whose
 first click spends that budget is one most people bounce off before they have
-heard anything at all. So the Listen tab is twenty pre-rendered files served
-straight out of this repo — no GPU, no queue, no quota — and the GPU is spent
-only on what a visitor types or records.
-
-The engine and the enroller are both built on `cuda` at module level, which is
-what ZeroGPU asks for: CUDA transfers are optimised for start-up placement, and
-lazy-loading inside a `@spaces.GPU` function is explicitly discouraged. Each
-decorated call then runs in a freshly forked, short-lived process, which is also
-why there is no `torch.compile` and no CUDA graph capture here: both pay their
-cost once per process and would never amortise.
-
-Cloning is exposed, which the CPU scaffold this replaces deliberately did not do.
-The reasoning that kept it out was about consent, not about capability, so the
-consent is built into the shape of the tab rather than written beside it: the
-microphone is the default path, an upload is secondary and gated on an explicit
-confirmation, and neither recording outlives the request that carried it.
+heard anything at all. So the Voices tab is fifty-six pre-rendered files served
+straight out of this repo, twenty-eight voices on each model, and the GPU is
+spent only on what a visitor types or records.
+
+Both models are here because the choice between them is the first real decision
+an adopter makes, and it is not one a table of numbers settles. Every voice
+reads the same passage on both, at the same seed, so switching the model is the
+only thing that changes. loudr-1 is the natural one; loudr-1-turbo renders
+about twice as fast from a two-token decode.
+
+Both are loaded at module level on `cuda`, which is what ZeroGPU asks for: CUDA
+transfers are optimised for start-up placement, and lazy-loading inside a
+`@spaces.GPU` function is explicitly discouraged. Each decorated call then runs
+in a freshly forked, short-lived process, which is also why there is no
+`torch.compile` and no CUDA graph capture here: both pay their cost once per
+process and would never amortise.
+
+Cloning is exposed, and the consent is built into the shape of the tab rather
+than written beside it: the microphone is the default path, an upload is
+secondary and gated on an explicit confirmation, and neither recording outlives
+the request that carried it.
+
+Every load is pinned to a Hub revision. A demo that says what a build does must
+be able to say which build, and `main` is not an answer that stays true.
 """
 
 from __future__ import annotations
@@ -43,10 +51,29 @@ import loudkit as lk
 from loudkit.backends.torch_backend import build_torch_enroller
 from loudkit.hub import resolve_enrollment_checkpoint, resolve_voice_encoder
 
-REPO = "loudreader/loudr-1"
 DEVICE = "cuda"
 HERE = Path(__file__).parent
 
+# The two published bundles, pinned. The tag moves when a release is cut; the
+# commit does not, and a demo that claims a fingerprint should be reproducible
+# from the same bytes a year from now.
+MODELS = {
+    "loudr-1": {
+        "repo": "loudreader/loudr-1",
+        "revision": "7516673ee74ab2228ffc4e99223d296d8904d7ff",
+        "label": "loudr-1 · the natural one",
+        "blurb": "Single-token decode. The reference model.",
+    },
+    "turbo": {
+        "repo": "loudreader/loudr-1-turbo",
+        "revision": "366f140a5f7ebe215e5b43cdd73384746c83bae6",
+        "label": "loudr-1-turbo · about twice as fast",
+        "blurb": "Two-token decode, one flow step. Same voices, same profiles.",
+    },
+}
+DEFAULT_MODEL = "loudr-1"
+MODEL_CHOICES = [(cfg["label"], key) for key, cfg in MODELS.items()]
+
 # The CPU scaffold capped text at 300 characters because CPU synthesis ran at
 # roughly a tenth of real time. On a GPU the cap is about the visitor's daily
 # quota instead, which is a far looser bound: 1000 characters is ~70 s of speech.
@@ -66,14 +93,14 @@ RESPONSIBLE_USE = f"{DOCS}/blob/main/RESPONSIBLE_USE.md"
 ROSTER = json.loads((HERE / "voices.json").read_text(encoding="utf-8"))
 BY_NAME = {entry["name"]: entry for entry in ROSTER}
 ORDERED = sorted(ROSTER, key=lambda e: (e["language"], e["name"]))
-VOICE_CHOICES = [(f"{e['name']} · {e['language']} ({e['gender']})", e["name"]) for e in ORDERED]
 
 # English leads. A visitor who does not read the other nine should not have to
 # hunt for the one they do, and alphabetical order put Danish first.
 FIRST_LANGUAGE = "en"
 _LANG_OF = {e["language_id"]: e["language"] for e in ROSTER}
 LANGUAGE_FILTER = [(_LANG_OF[FIRST_LANGUAGE], FIRST_LANGUAGE)] + [
-    (name, code) for code, name in sorted(_LANG_OF.items(), key=lambda kv: kv[1])
+    (name, code)
+    for code, name in sorted(_LANG_OF.items(), key=lambda kv: kv[1])
     if code != FIRST_LANGUAGE
 ]
 
@@ -101,24 +128,32 @@ EXAMPLE_CHOICES = [("Nothing selected", "")] + [
 # Module-level model placement, per the ZeroGPU contract.
 # --------------------------------------------------------------------------
 
-engine = lk.load(REPO, device=DEVICE)
+ENGINES = {
+    key: lk.load(cfg["repo"], revision=cfg["revision"], device=DEVICE)
+    for key, cfg in MODELS.items()
+}
 
 # Voice profiles are numpy, not torch, so they are device-agnostic and cost a
-# few hundred kilobytes each. Loading all twenty up front means switching voice
-# in the Speak tab never blocks on a download.
-PROFILES = {entry["name"]: lk.voice(entry["name"], repo=REPO) for entry in ROSTER}
+# few hundred kilobytes each. They are also identical in both bundles, which is
+# the point of a portable profile: one clone, either model.
+BASE = MODELS[DEFAULT_MODEL]
+PROFILES = {
+    entry["name"]: lk.voice(entry["name"], repo=BASE["repo"], revision=BASE["revision"])
+    for entry in ROSTER
+}
 
 # Enrollment reads the other half of the release: the speech tokenizer and the
 # speaker encoder, which synthesis never touches, plus the utterance voice
-# encoder that sits beside both. `lk.enroll()` builds this per call by design;
-# a Space would pay the load on every clone, so it is built once here instead.
+# encoder that sits beside both. One enroller serves both models, because the
+# profile it produces is the same file either way. `lk.enroll()` builds this per
+# call by design; a Space would pay the load on every clone.
 enroller = build_torch_enroller(
-    str(resolve_enrollment_checkpoint(REPO)),
+    str(resolve_enrollment_checkpoint(BASE["repo"], revision=BASE["revision"])),
     device=DEVICE,
-    voice_encoder_weights=str(resolve_voice_encoder(REPO)),
+    voice_encoder_weights=str(resolve_voice_encoder(BASE["repo"], revision=BASE["revision"])),
 )
 
-FINGERPRINT = engine.algorithm.fingerprint()
+FINGERPRINTS = {key: engine.algorithm.fingerprint() for key, engine in ENGINES.items()}
 
 _LANGUAGE_NAMES = {e["language_id"]: e["language"] for e in ROSTER}
 LANGUAGE_CHOICES = [("Follow the voice", "")] + [
@@ -153,11 +188,11 @@ def _write(result: lk.Result, *, voice: str, language: str) -> str:
     return out.name
 
 
-def _stats(result: lk.Result) -> str:
+def _stats(result: lk.Result, model: str) -> str:
     seconds = len(result.audio) / result.sample_rate
     return (
         f"**{seconds:.1f} s of audio.** {result.timings.describe(seconds)}\n\n"
-        f"`algo[{result.algorithm_fingerprint}]` · seed `{result.seed}` · "
+        f"`{model}` · `algo[{result.algorithm_fingerprint}]` · seed `{result.seed}` · "
         f"speed `{result.speed:g}x` · {result.sample_rate} Hz"
     )
 
@@ -183,21 +218,26 @@ def _check(text: str, limit: int) -> str:
     return text
 
 
+def _engine(model: str) -> lk.Engine:
+    return ENGINES[model if model in ENGINES else DEFAULT_MODEL]
+
+
 # --------------------------------------------------------------------------
 # Listen. No GPU: these files were rendered ahead of time and ship in the repo.
 # --------------------------------------------------------------------------
 
 
-def listen(name: str):
+def listen(name: str, model: str):
     entry = BY_NAME[name]
     sample, reference, source = entry["sample"], entry["reference"], entry["source"]
+    model = model if model in MODELS else DEFAULT_MODEL
 
     lines = [
         f"### {entry['name']}. {entry['language']} ({entry['gender']}).",
         "",
         f"> {sample['text']}",
         "",
-        f"From *{sample['work']}*, seed `{sample['seed']}`.",
+        f"From *{sample['work']}*, seed `{sample['seed']}`, rendered on `{model}`.",
         "",
         f"- Reference recording: {reference['duration_s']:.1f} s, {reference['construction']}.",
         f"- Source: [{source['name']}]({source['url']}), {source['license']}.",
@@ -206,10 +246,10 @@ def listen(name: str):
     similarity = entry.get("speaker_similarity")
     if similarity is not None:
         lines.append(f"- Speaker similarity to the reference: {similarity:.3f}.")
-    lines.append(f"- Voice profile: `{entry['profile']['hf_path']}`.")
+    lines.append(f"- Voice profile: `{entry['profile']['hf_path']}`, the same file in both models.")
 
     return (
-        str(HERE / sample["audio"]),
+        str(HERE / sample["audio"][model]),
         str(HERE / reference["public_preview"]),
         "\n".join(lines),
     )
@@ -232,14 +272,14 @@ ROSTER_TABLE = [
 # --------------------------------------------------------------------------
 
 
-def _speak_duration(text, name, language, seed, speed):
+def _speak_duration(text, name, model, language, seed, speed):
     return _estimate(text, overhead=15.0)
 
 
 @spaces.GPU(duration=_speak_duration)
-def speak(text: str, name: str, language: str, seed: float, speed: float):
+def speak(text: str, name: str, model: str, language: str, seed: float, speed: float):
     text = _check(text, MAX_CHARS)
-    result = engine.synthesize_long(
+    result = _engine(model).synthesize_long(
         text,
         PROFILES[name],
         seed=int(seed),
@@ -247,7 +287,46 @@ def speak(text: str, name: str, language: str, seed: float, speed: float):
         speed=float(speed),
     )
     label = language or BY_NAME[name]["language_id"]
-    return _write(result, voice=name, language=label), _stats(result)
+    return _write(result, voice=name, language=label), _stats(result, model)
+
+
+# --------------------------------------------------------------------------
+# Both models on one text. GPU. The comparison the model choice is really about.
+# --------------------------------------------------------------------------
+
+
+def _compare_duration(text, name, seed):
+    return _estimate(text, passes=2, overhead=20.0)
+
+
+@spaces.GPU(duration=_compare_duration)
+def compare(text: str, name: str, seed: float):
+    """The same words, the same voice, the same seed, on both models."""
+    text = _check(text, MAX_PROBE_CHARS)
+    profile = PROFILES[name]
+    out = {}
+    for key, engine in ENGINES.items():
+        result = engine.synthesize_long(text, profile, seed=int(seed))
+        out[key] = (
+            _write(result, voice=name, language=BY_NAME[name]["language_id"]),
+            len(result.audio) / result.sample_rate,
+            result.algorithm_fingerprint,
+        )
+
+    note = "\n".join(
+        [
+            "| model | audio | fingerprint |",
+            "|---|---:|---|",
+            *(
+                f"| `{key}` | {seconds:.2f} s | `{fingerprint}` |"
+                for key, (_, seconds, fingerprint) in out.items()
+            ),
+            "",
+            "Two models, two fingerprints, and the same voice profile in both. "
+            "Which one to ship is an ear question, not a table question.",
+        ]
+    )
+    return out["loudr-1"][0], out["turbo"][0], note
 
 
 # --------------------------------------------------------------------------
@@ -255,14 +334,14 @@ def speak(text: str, name: str, language: str, seed: float, speed: float):
 # --------------------------------------------------------------------------
 
 
-def _clone_duration(example, mic, upload, consent, text, language, seed, speed):
+def _clone_duration(example, mic, upload, consent, text, model, language, seed, speed):
     # Enrollment is a fixed cost on top of the render: two encoders and a
     # tokenizer over at most 20 s of audio.
     return _estimate(text, overhead=30.0)
 
 
 @spaces.GPU(duration=_clone_duration)
-def clone(example, mic, upload, consent: bool, text: str, language: str, seed, speed):
+def clone(example, mic, upload, consent: bool, text: str, model: str, language: str, seed, speed):
     """Enroll a voice, speak with it, keep nothing.
 
     Three ways in, and they do not carry the same consent story, so they are
@@ -315,10 +394,10 @@ def clone(example, mic, upload, consent: bool, text: str, language: str, seed, s
         # and read its text through the English funnel.
         profile = dataclasses.replace(profile, language=language or "en")
 
-        result = engine.synthesize_long(
+        result = _engine(model).synthesize_long(
             text, profile, seed=int(seed), language=language or None, speed=float(speed)
         )
-        return _write(result, voice=label, language=profile.language), _stats(result)
+        return _write(result, voice=label, language=profile.language), _stats(result, model)
     finally:
         # Nothing the visitor recorded outlives the request that carried it.
         # A shipped example is not the visitor's and is not ours to delete.
@@ -332,13 +411,14 @@ def clone(example, mic, upload, consent: bool, text: str, language: str, seed, s
 # --------------------------------------------------------------------------
 
 
-def _probe_duration(text, name, seed):
+def _probe_duration(text, name, model, seed):
     return _estimate(text, passes=2, overhead=20.0)
 
 
 @spaces.GPU(duration=_probe_duration)
-def probe(text: str, name: str, seed: float):
+def probe(text: str, name: str, model: str, seed: float):
     text = _check(text, MAX_PROBE_CHARS)
+    engine = _engine(model)
     profile = PROFILES[name]
     first = engine.synthesize_long(text, profile, seed=int(seed))
     second = engine.synthesize_long(text, profile, seed=int(seed))
@@ -353,12 +433,13 @@ def probe(text: str, name: str, seed: float):
             "```",
             f"render 1  sha256  {left}",
             f"render 2  sha256  {right}",
-            f"          algo[{first.algorithm_fingerprint}]  seed {int(seed)}",
+            f"          algo[{first.algorithm_fingerprint}]  seed {int(seed)}  {model}",
             "```",
             "",
             "Identical within this build and this device. loudkit promises a "
             "bit-identical waveform for the same seed, build, backend and input. "
-            "It does not promise that your laptop matches this GPU. "
+            "It does not promise that your laptop matches this GPU, and the two "
+            "models are two different builds by construction. "
             f"[Read the identity contract]({IDENTITY_CONTRACT}).",
         ]
     )
@@ -416,14 +497,17 @@ THEME = gr.themes.Soft(
 with gr.Blocks(title="loudkit", theme=THEME, css=CSS, js=FORCE_LIGHT, fill_width=False) as demo:
     gr.Markdown(
         f"""
-# Twenty voices. Ten languages. One engine.
+# Twenty-eight voices. Ten languages. Two models.
 
 On-device text to speech, running here on ZeroGPU.
-[Model](https://huggingface.co/{REPO}) · [Code]({DOCS}) · [Responsible use]({RESPONSIBLE_USE})
+[loudr-1](https://huggingface.co/{MODELS["loudr-1"]["repo"]}) ·
+[loudr-1-turbo](https://huggingface.co/{MODELS["turbo"]["repo"]}) ·
+[Code]({DOCS}) · [Responsible use]({RESPONSIBLE_USE})
 
 <span class="lk-pill">Listening costs no GPU</span>
 <span class="lk-pill">Speaking and cloning spend your daily quota</span>
-<span class="lk-pill">algo[{FINGERPRINT}]</span>
+<span class="lk-pill">algo[{FINGERPRINTS["loudr-1"]}]</span>
+<span class="lk-pill">algo[{FINGERPRINTS["turbo"]}]</span>
 """,
         elem_id="lk-head",
     )
@@ -432,18 +516,23 @@ On-device text to speech, running here on ZeroGPU.
         # ------------- Voices: listen for free, then type your own -------------
         with gr.Tab("Voices"):
             gr.Markdown(
-                "Pick a voice and the sample plays at once. Those are rendered "
-                "ahead of time and use no GPU. Type your own text underneath."
+                "Pick a voice and the sample plays at once. Every voice is here "
+                "twice, once per model, reading the same passage at the same "
+                "seed. Those files were rendered ahead of time and use no GPU."
             )
             with gr.Row():
                 with gr.Column(scale=1):
+                    model_pick = gr.Radio(
+                        MODEL_CHOICES,
+                        value=DEFAULT_MODEL,
+                        label="Model",
+                        info="Switching this changes the sample and what the buttons below run.",
+                    )
                     with gr.Row():
                         lang_pick = gr.Dropdown(
                             LANGUAGE_FILTER, value=FIRST_LANGUAGE, label="Language"
                         )
-                        pick = gr.Dropdown(
-                            FIRST_VOICES, value=FIRST_VOICE, label="Voice"
-                        )
+                        pick = gr.Dropdown(FIRST_VOICES, value=FIRST_VOICE, label="Voice")
                     made = gr.Audio(label="loudkit", type="filepath", interactive=False)
                     ref = gr.Audio(
                         label="Reference recording", type="filepath", interactive=False
@@ -484,22 +573,49 @@ On-device text to speech, running here on ZeroGPU.
             say_stats = gr.Markdown()
 
             say_go.click(
-                speak, [say, pick, say_lang, say_seed, say_speed], [say_out, say_stats]
+                speak,
+                [say, pick, model_pick, say_lang, say_seed, say_speed],
+                [say_out, say_stats],
             )
 
-            def on_language(language):
+            def on_language(language, model):
                 choices = voices_in(language)
                 name = choices[0][1]
-                return (gr.Dropdown(choices=choices, value=name), *listen(name))
+                return (gr.Dropdown(choices=choices, value=name), *listen(name, model))
+
+            lang_pick.change(on_language, [lang_pick, model_pick], [pick, made, ref, card])
+            pick.change(listen, [pick, model_pick], [made, ref, card])
+            model_pick.change(listen, [pick, model_pick], [made, ref, card])
+            demo.load(listen, [pick, model_pick], [made, ref, card])
 
-            lang_pick.change(on_language, lang_pick, [pick, made, ref, card])
-            pick.change(listen, pick, [made, ref, card])
-            demo.load(listen, pick, [made, ref, card])
+            with gr.Accordion("Hear both models on your own words", open=False):
+                gr.Markdown(
+                    "The same text, the same voice, the same seed, rendered on "
+                    "both. This is the comparison the model choice is about, and "
+                    "it costs two renders of your quota."
+                )
+                with gr.Row():
+                    cmp_text = gr.Textbox(
+                        value="The same words, on both models.",
+                        label="Text",
+                        lines=1,
+                        max_lines=2,
+                        max_length=MAX_PROBE_CHARS,
+                        scale=3,
+                    )
+                    cmp_seed = gr.Number(value=7, precision=0, label="Seed", scale=1)
+                cmp_go = gr.Button("Render on both")
+                with gr.Row():
+                    cmp_base = gr.Audio(label="loudr-1", type="filepath")
+                    cmp_turbo = gr.Audio(label="loudr-1-turbo", type="filepath")
+                cmp_note = gr.Markdown()
+                cmp_go.click(compare, [cmp_text, pick, cmp_seed], [cmp_base, cmp_turbo, cmp_note])
 
             with gr.Accordion("Determinism check", open=False):
                 gr.Markdown(
-                    "This renders the same text twice at the same seed and hashes "
-                    "both waveforms. The digests must match."
+                    "This renders the same text twice at the same seed on the "
+                    "selected model and hashes both waveforms. The digests must "
+                    "match."
                 )
                 with gr.Row():
                     probe_text = gr.Textbox(
@@ -513,16 +629,18 @@ On-device text to speech, running here on ZeroGPU.
                     probe_seed = gr.Number(value=7, precision=0, label="Seed", scale=1)
                 probe_go = gr.Button("Render twice")
                 probe_out = gr.Markdown()
-                probe_go.click(probe, [probe_text, pick, probe_seed], probe_out)
+                probe_go.click(probe, [probe_text, pick, model_pick, probe_seed], probe_out)
 
         # ---------------------------- Clone ----------------------------
         with gr.Tab("Clone"):
             gr.Markdown(
                 f"""
-Clone a voice from a short recording, then speak with it.
+Clone a voice from a short recording, then speak with it on either model.
 
 - Try one of the shipped examples, or record yourself.
 - Clone only your own voice, or a voice you have permission to use.
+- One profile serves both models. That is what a portable voice profile means:
+  enroll once, and the file works wherever the engine does.
 - Nothing is kept. The recording and the voice embeddings are discarded when the
   request ends, and neither is offered for download.
 - See [Responsible use]({RESPONSIBLE_USE}).
@@ -558,6 +676,9 @@ Clone a voice from a short recording, then speak with it.
                             ),
                         )
                 with gr.Column(scale=1):
+                    clone_model = gr.Radio(
+                        MODEL_CHOICES, value=DEFAULT_MODEL, label="Speak it with"
+                    )
                     clone_text = gr.Textbox(
                         label="Text to speak",
                         placeholder="Now in my own voice.",
@@ -596,7 +717,17 @@ Clone a voice from a short recording, then speak with it.
 
             clone_go.click(
                 clone,
-                [example, mic, upload, consent, clone_text, clone_lang, clone_seed, clone_speed],
+                [
+                    example,
+                    mic,
+                    upload,
+                    consent,
+                    clone_text,
+                    clone_model,
+                    clone_lang,
+                    clone_seed,
+                    clone_speed,
+                ],
                 [clone_out, clone_stats],
             )
 
@@ -612,16 +743,22 @@ pip install "loudkit[torch,audio,enroll,hub]"
 ```python
 import loudkit as lk
 
-engine = lk.load("{REPO}")
-voice = lk.voice("kathleen", repo="{REPO}")
+engine = lk.load("{MODELS["loudr-1"]["repo"]}", revision="v0.1.1")
+voice = lk.voice("kathleen", repo="{MODELS["loudr-1"]["repo"]}", revision="v0.1.1")
 engine.synthesize_long("Hello from loudkit.", voice, seed=7).save("hello.wav")
 ```
 
+The same profile reads on the faster model by changing one string:
+
+```python
+engine = lk.load("{MODELS["turbo"]["repo"]}", revision="v0.1.1")
+```
+
 Output files carry C2PA provenance: the fingerprint, the recipe and the seed.
 """
     )
 
-# The engine holds one set of weights and renders with an internal producer
+# Each engine holds one set of weights and renders with an internal producer
 # thread. One render at a time keeps two requests off the same buffers.
 demo.queue(default_concurrency_limit=1, max_size=24)
 

audio/loudr-1/clara.opus

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d218b620146d5954adefb4dbf631c169b4647967bf49b7383e03997468a636e3
+size 132921

audio/loudr-1/colette.opus

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04a10c727da4572bb53cf7919fa3404c3a46376a7603fe370ddcd1d62dfb977a
+size 106160

audio/loudr-1/emma.opus

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a89a1dda44d632f9a32bf08db296e3a17cafb28f73aa7b354f7882c502dd9340
+size 125680

audio/loudr-1/henri.opus

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fd1de078ca5bffece9b03b6cc11100a6ea88125ab90ca64337ce0e5ce08fac2
+size 102335

audio/loudr-1/henry.opus

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:816ac99dcadf1b6132675b8e8f9444f19346c13e271bb42c0298735835c7c691
+size 159500

audio/loudr-1/lucy.opus

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34d32240a95c4765c0e38b12a031f0d054be0d1c29de6739069454523d2b6a5e
+size 124298

audio/loudr-1/miles.opus

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81734391dc7570f8b632244ee948b2736b7f02b3449ca88522caa5304a1973f0
+size 166129

audio/loudr-1/oliver.opus

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:920cb343127a0bca928c1b67a846dd431f9e63b696210dd693007f8efcaa8319
+size 141153

audio/loudr-1/oscar.opus

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e696f00b74d4fe3cc1d89f95d40c6999756f33269b002c50f181c6658667257c
+size 140099

audio/loudr-1/sophie.opus

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b44b159cc733894d77a14c97105442092c65d42bb2e2422927af2e631704d149
+size 147289