Inflect v2

Inflect v2 is a pair of open-weight, English-only text-to-speech models built to prove that a genuinely small model can still produce natural-sounding speech: Inflect-Micro-v2 at 9.36 million parameters (37.53 MB in FP32) and Inflect-Nano-v2 at 3.97 million parameters (15.97 MB in FP32). Both are complete text-to-waveform systems, meaning a single forward pass takes raw English text in and produces a finished 24kHz mono audio waveform out, with no separate vocoder stage and no dependency on a remote API. Developed independently by Owen Song and released under Apache-2.0, Inflect v2 targets the opposite end of the spectrum from frontier voice models like Kokoro TTS or Orpheus TTS: instead of maximizing voice quality or expressiveness at whatever parameter cost that takes, it asks how much natural speech a model can produce inside a footprint small enough to run comfortably on a laptop CPU, or eventually, a phone.

Architecture: A VITS-Family Pipeline

Inflect v2 follows the VITS (Variational Inference Text-to-Speech) family of end-to-end architectures, which collapse what used to be a three-stage pipeline (text-to-phoneme frontend, acoustic model, separate neural vocoder) into a single trained system:

graph TD
    classDef default fill:#ffffff,stroke:#4338CA,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef data    fill:#EEF0F7,stroke:#0D9488,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef process fill:#F7F8FC,stroke:#6366F1,stroke-width:2px,color:#0F172A,rx:8px,ry:8px;
    classDef output  fill:#4338CA,stroke:#4338CA,stroke-width:2px,color:#ffffff,rx:8px,ry:8px;

    IN([Raw English text]):::data --> NORM[Text Normalization + Phoneme Conversion]:::process
    NORM --> ENC[Transformer Text Encoder]:::process
    ENC --> DUR[Stochastic Duration Predictor]:::process
    DUR --> ALIGN[Monotonic Alignment]:::process
    ALIGN --> LAT[Latent-Variable Speech Generation]:::process
    LAT --> FLOW[Residual Coupling Flow]:::process
    FLOW --> DEC[Alias-Reduced 24kHz Decoder]:::process
    DEC --> OUT([Complete waveform, no external vocoder]):::output

• Frontend: normalizes raw English text (numbers, abbreviations, punctuation) and converts it to phonemes.
• Text encoder: a transformer that turns the phoneme sequence into contextual representations.
• Duration & alignment: a stochastic duration predictor estimates how long each phoneme should last, and monotonic alignment enforces that phonemes map to audio frames in the same left-to-right order they appear in the text, the constraint that keeps synthesized speech from garbling word order.
• Latent-variable generation: rather than predicting a single deterministic spectrogram, the model samples from a learned latent distribution, which is where the variation parameter’s effect on delivery comes from.
• Vocoding: a residual coupling flow feeds an integrated, alias-reduced 24kHz decoder, producing the finished waveform directly, with no separate vocoder network (like HiFi-GAN) bolted on afterward.

# Scenario: illustrating why "no external vocoder" matters operationally.
# A classic three-stage TTS pipeline needs two models in memory and two
# forward passes; Inflect v2 needs one of each.
def classic_pipeline(text):
    mel_spectrogram = acoustic_model(text)      # model #1
    waveform = vocoder_model(mel_spectrogram)   # model #2, separate weights
    return waveform

def inflect_v2_pipeline(text):
    waveform = inflect_model(text)              # one model, one forward pass
    return waveform

Micro vs. Nano: The Size/Quality Trade-off

The two variants sit on either side of a real trade-off between footprint and perceived quality:

The gap in perceptual quality between the two is small, a few tenths of a point on UTMOS22 and community preference, while Nano runs 70% faster on CPU and is less than half the size. That makes the choice largely about deployment constraints rather than a hard quality cliff: Nano is the better fit when memory or CPU headroom is genuinely tight (embedded devices, high-concurrency batch synthesis), and Micro is the better fit whenever there is a little more room to spend on the last increment of naturalness.

Interactive: Footprint vs. Throughput

Model size and CPU throughput trade against each other here in a way a reader can check directly rather than taking on faith. Drag the slider between the two released checkpoints to see how parameter count, weight size, and CPU throughput move together.

Try it: click each button to compare Nano-v2’s smaller, faster profile against Micro-v2’s slightly larger, slightly higher-quality profile.

Deterministic Output and Prosody Control

Inflect v2 exposes three controls at inference time: speed (0.5x-2.0x playback rate), variation (how much the latent-variable sampling perturbs delivery, defaulting around 0.667), and seed (fixes the latent sample for fully reproducible output). Fixing the seed matters for any workflow that needs the same line to come out identical on every run, regression-testing a voice pipeline, or regenerating a single corrected sentence in a longer narration without the surrounding audio’s prosody drifting.

# Scenario: regenerating one corrected sentence in an already-recorded
# narration without the fix sounding different in delivery from the rest.
from inference import InflectTTS

tts = InflectTTS(".", device="cpu")

# Same seed as the original recording -> matching delivery for the fix
_, original_style_take = tts.synthesize(
    "The deployment completed successfully.",
    speed=1.0,
    variation=0.667,
    seed=42,
)

Long-form input is handled by chunking text at punctuation boundaries and inserting controlled pauses between chunks, which keeps memory bounded on long documents without requiring a streaming architecture, since the model processes each chunk as a complete unit rather than token-by-token.

# Scenario: narrating a multi-paragraph help article. The model chunks
# at sentence/punctuation boundaries internally; a caller can also
# pre-chunk explicitly if finer control over pause placement is needed.
paragraphs = [
    "First, open the settings panel.",
    "Next, select your workspace from the dropdown.",
    "Finally, click save to apply your changes.",
]

waveforms = [tts.synthesize(p, speed=1.0, seed=7)[1] for p in paragraphs]

What Inflect v2 Does Not Do

The model card is explicit about scope: no voice cloning, no speaker selection (each model ships a single fixed English male voice), no multilingual support, no streaming (audio is generated as complete chunks, not incrementally as tokens arrive), and no quantized export formats (GGUF, CoreML, TFLite, FP16) as of the v2 release, only FP32 PyTorch weights for CPU or CUDA inference. Teams that need any of those, a cloned or selectable voice, non-English output, or token-level streaming for live agents, should look at models built specifically for that: Kokoro TTS and Orpheus TTS both target broader voice and language coverage at a larger parameter budget.

Comparison with Other Small/Efficient Voice Models

Getting Started

Both variants are public on Hugging Face (owensong/Inflect-Micro-v2, owensong/Inflect-Nano-v2) and installable via hf download owensong/Inflect-Micro-v2 --local-dir Inflect-Micro-v2, followed by installing requirements.txt inside the downloaded directory. The GitHub repository (owenawsong/Inflect) hosts the shared inference code both variants use, along with a CLI entry point (python inference.py --text "..." --output out.wav) for quick one-off synthesis without writing a Python script. Code and released weights are Apache-2.0; training infrastructure and the corpus construction pipeline are not published, only the trained weights and inference path.

What’s New (2025-2026)

• Sub-10M-parameter TTS crossed from novelty into “actually usable.” Inflect v2’s UTMOS22 scores (4.39+) sit close to systems many times its size, part of a 2025-2026 pattern of efficient end-to-end TTS architectures closing the perceived-quality gap with much larger models faster than raw parameter-scaling would predict.
• CPU-only, fully local voice synthesis is becoming a realistic default for lightweight applications, not just an edge case for offline-first apps, as VITS-family architectures mature past the point where a GPU is assumed necessary for natural-sounding output.
• The size/quality trade-off is being published explicitly rather than papered over. Releasing Micro and Nano side by side, with a shared API and a documented UTMOS/preference gap between them, lets a team pick a point on the curve instead of guessing whether a smaller model is “good enough.”

Practical Guidance

# Scenario: an offline desktop app needs a narrator voice for
# onboarding text, with no network call and a reproducible take.

# pip install --upgrade huggingface_hub
# hf download owensong/Inflect-Micro-v2 --local-dir Inflect-Micro-v2
# cd Inflect-Micro-v2 && pip install -r requirements.txt

from inference import InflectTTS

tts = InflectTTS(".", device="cpu")

sample_rate, waveform = tts.synthesize(
    "Welcome. Let's get your workspace set up in under a minute.",
    speed=1.0,        # 0.5-2.0x playback speed
    variation=0.667,  # prosody/delivery variation
    seed=7,           # fixed seed -> deterministic, repeatable output
)

import soundfile as sf
sf.write("welcome.wav", waveform, sample_rate)