Ming-3.0 TTS Ships Inference Code for Controllable Speech

inclusionAI released Ming-3.0 TTS inference code on October 19, giving developers a documented runtime for its multilingual speech models. The release includes model implementations, dependency files, a Docker setup, inference scripts and a task cookbook. The available models support seven languages, voice creation and several ways to control how a line is spoken.

The timing needs a distinction. The initial GitHub code release is dated October 19, while the Hugging Face weight-upload history for 0.5B and Tiny goes back to September 24. Today's practical event is the inference-code release, rather than the first appearance of the checkpoint files.

That is a meaningful step for a team evaluating self-hosted speech. Weights are only part of a working system. The surrounding code must load the checkpoint correctly, prepare reference audio, apply the right control tokens and decode the result. A published runtime gives developers a concrete implementation to inspect and test.

Two models with different deployment needs

The 0.5B checkpoint uses a dense Qwen2.5-0.5B backbone. The Tiny version uses a Ling V3 mixture-of-experts backbone with 7.9 billion total parameters and 1.3 billion active. Despite its name, Tiny is the larger of these two options.

The release bundles more than the language backbone: its components include an audio tokenizer, a speech-generation head, a speaker encoder and a text tokenizer. A backbone's parameter label therefore should not be treated as the complete application's storage or memory requirement.

The 0.5B card specifies 44.1kHz speech output. The family’s documented languages are Chinese, English, German, Spanish, French, Korean and Japanese, with additional Sichuanese and Cantonese modes. Tiny also has a multi-speaker dialogue mode that takes a script and speaker references. That feature should not be assumed to exist in the smaller model.

Speech controls are separate task modes

The project cookbook separates several jobs that can sound similar in a product description:

• Voice cloning uses reference audio to establish a speaker
• Voice design creates a voice from a text description
• Free-form control uses a natural-language instruction for voice and delivery
• Dedicated modes control emotion, dialect, or speed, pitch and volume
• Paralinguistic tags add vocal events such as laughter or sighs

These are structured interfaces, with different required inputs. They are not a promise that every control can be combined in one request. The free-form mode, for example, is documented separately from built-in voices, emotion and dialect controls. The project supports 14 paralinguistic tags in Chinese or English; that does not establish equivalent tag support across all seven languages.

For a speech product, this affects the interface above the model. A voice picker, a delivery instruction and an emotion slider cannot simply be forwarded together unless the selected task accepts them. It is worth deciding which combinations the product will offer before exposing all the underlying controls to users.

The code release does not remove deployment work

The installation guide uses separate environments for the two models. Its 0.5B setup was tested on NVIDIA H800-80GB and H20-96GB hardware. Tiny has its own pinned dependencies and an H800 recommendation. Those are documented test and recommendation points, not established minimum GPU requirements.

For 0.5B, FlashAttention is optional and inference can fall back to PyTorch SDPA. Text normalization also needs attention: the project uses grammars for numbers, dates, units and symbols, with a separate dependency that can be skipped explicitly.

That makes an application-specific trial more useful than a single attractive voice sample. Test the exact kinds of text the product will speak: names, abbreviations, prices, dates, mixed-language sentences and punctuation. Keep the model version, task, reference audio and settings fixed so a change in output can be traced to a change in the system.

Quality needs more than one score

The model card's limitations distinguish content accuracy from speaker similarity. It identifies weaker French speaker similarity, less stable results when several vocal events occur in one sentence, and difficulty expressing an emotion when the words themselves provide no emotional signal.

There is also independent preference evidence. At this check, Artificial Analysis's Provider Voice open-weight board lists Ming-3.0-tts third with an Elo of 1188, a 95% interval of 1173 to 1203 and 1,957 samples. That board compares each system's own voices. Its family-level label should not be treated as a separate validation of both released checkpoints, or of their performance in every supported language.

For a deployment decision, judge at least three things separately: whether the words are correct, whether the speaker identity is consistent, and whether the delivery follows the requested control. A model can perform well on one and disappoint on another. Multi-speaker output needs an additional check that identities remain attached to the correct lines.

What developers can use now

The repository and model cards provide code and weights under MIT terms. Self-hosting still carries compute, integration and evaluation costs; this release does not establish a hosted price or a universal hardware budget.

The useful next step is a bounded trial of the specific speech workflow being built. Start with one model and one task mode, compare it with the current system, and expand only after checking correctness and delivery. For reference voices, use recordings with appropriate consent and label synthetic output where listeners could mistake it for a real recording, as the project's usage guidance requires.

Ming-3.0 TTS now has a more concrete path from checkpoint to application. The value of this release will depend on how reliably that path handles the language, speaker and control combinations a product actually needs.

I'm Paras. I work at the intersection of AI, engineering and distribution.

I help AI and developer-tool teams turn model capabilities, deployment choices and real product tradeoffs into clear technical stories that reach the right users.

Book a 30-minute call.