# Supertonic Future Roadmap: On-Device TTS Expansion and Edge Optimization

> Discover Supertonic's future roadmap: expanding on-device TTS, adding voice cloning APIs, and optimizing edge inference for broader language support and efficient performance.

- Repository: [Supertone Inc./supertonic](https://github.com/supertone-inc/supertonic)
- Tags: getting-started
- Published: 2026-06-13

---

**Supertonic’s future roadmap prioritizes expanding language support beyond the current 31 languages, introducing advanced voice cloning APIs, and optimizing edge inference through lightweight runtimes, as evidenced by TODO comments in [`py/helper.py`](https://github.com/supertone-inc/supertonic/blob/main/py/helper.py) and recent Update News entries.**

While the supertone-inc/supertonic repository does not publish a formal roadmap document, the project’s trajectory is clearly visible through its Update News section, incremental release cadence, and explicit TODO comments scattered across language bindings. This on-device text-to-speech engine, built around a compact 99M-parameter ONNX model, is rapidly evolving toward broader linguistic coverage, richer voice customization, and deeper edge-device integration.

## Where the Roadmap Evidence Lives

Instead of a static markdown file, Supertonic’s roadmap surfaces dynamically through three primary sources: the **Update News** section in [`README.md`](https://github.com/supertone-inc/supertonic/blob/main/README.md), which chronicles the jump from 5 to 31 languages and the introduction of Voice Builder support; the **source code TODOs** found in every language binding from Python to Swift; and the **multi-runtime SDK** structure that necessitates feature parity across Python, Node.js, Java, C++, C#, Go, Rust, and Flutter.

## Planned Features and Strategic Directions

### Expanded Language Coverage for Low-Resource Locales

The project currently supports 31 languages after the Supertonic 3 update, but the momentum suggests aggressive expansion into low-resource languages. The Update News entries highlight this pattern, having already scaled from 5 languages in earlier versions to 31 in the current release. Future iterations will likely target underrepresented linguistic communities to complete the project's global coverage.

### Advanced Voice Styles and On-Device Voice Cloning

December 2025 brought six new voice styles (M3-M5, F3-F5), yet the infrastructure hints at deeper customization. The Voice Builder UI already generates version-specific JSON files, and the May 2026 Update News explicitly mentions Voice Builder support for Supertonic 3. This foundation suggests an upcoming API for on-device voice cloning, allowing developers to load custom voice JSONs directly into the synthesizer.

### Improved Text Normalization Across All Bindings

Every language binding contains an identical marker of future work: the text normalizer enhancement. In [`py/helper.py`](https://github.com/supertone-inc/supertonic/blob/main/py/helper.py) at line 22, a comment reads `# TODO: Need advanced normalizer for better performance`. This same TODO appears in the Node.js, Java, Go, Rust, C++, C#, and Swift implementations, indicating a coordinated effort to improve preprocessing performance across the entire multi-runtime SDK.

### Edge-Optimized Inference and Alternative Runtimes

Supertonic already demonstrates viability on Raspberry Pi and e-readers, but the trajectory points toward additional lightweight runtimes such as MNN and TensorRT. The current reliance on ONNX runtime will likely expand to accommodate these alternatives, further reducing memory footprint for deployments on microcontrollers and low-power edge devices.

### Server-Side Deployment via the `serve` CLI

The May 2026 release introduced `supertonic serve`, a local HTTP server with OpenAI-compatible endpoints shipped with the Python SDK. Future development will likely extend this server-side capability to other language runtimes and introduce batch-processing features, bridging the gap between edge and server deployment models.

## Code Examples: Testing Tomorrow’s Features Today

Developers can already experiment with roadmap features using the current SDK. Below are practical implementations of the `serve` CLI and Voice Builder integration that will remain stable as the project evolves.

### Launching the Local HTTP Server with `supertonic serve`

The following Python script demonstrates the OpenAI-compatible HTTP server introduced in the May 2026 update:

```python
import subprocess
import requests

# Launch the local server (requires supertonic[serve] extras)

subprocess.run(
    ["supertonic", "serve", "--host", "127.0.0.1", "--port", "7788"],
    check=True,
)

# POST to the OpenAI-compatible endpoint

payload = {
    "model": "supertonic-3",
    "input": "Future roadmaps are exciting!",
    "voice_style": "M1",
    "lang": "en",
    "speed": 1.0,
}
resp = requests.post("http://127.0.0.1:7788/v1/audio/speech", json=payload)

with open("future.wav", "wb") as f:
    f.write(resp.content)

```

### Integrating Custom Voice Styles from Voice Builder

This example shows how to load a custom voice style JSON exported from the Voice Builder UI, a format expected to become central to the voice cloning API:

```python
import json
from supertonic import TTS

tts = TTS(auto_download=True)

# Load custom voice style from Voice Builder export

with open("my_custom_voice.json") as fp:
    custom_style = json.load(fp)

# Synthesize using the custom style

wav, duration = tts.synthesize(
    text="Supertonic’s future sounds brighter than ever.",
    lang="en",
    voice_style=custom_style,
    total_steps=10,
    speed=1.1,
)

tts.save_audio(wav, "custom_voice.wav")
print(f"Generated {duration[0]:.2f}s")

```

## Summary

- **Language expansion** will push beyond the current 31 languages into low-resource locales, following the rapid growth pattern documented in the Update News.
- **Voice cloning APIs** are emerging from the Voice Builder JSON infrastructure, with on-device custom voice loading already possible via the Python SDK.
- **Text normalization improvements** are explicitly planned across all language bindings, as indicated by TODO comments in [`py/helper.py`](https://github.com/supertone-inc/supertonic/blob/main/py/helper.py) and equivalent files.
- **Edge optimization** targets additional runtimes like MNN and TensorRT, alongside continued support for Raspberry Pi and e-reader deployments.
- **Server deployment** capabilities introduced via `supertonic serve` will likely expand to other runtimes and gain batch processing features.

## Frequently Asked Questions

### Is there a formal roadmap document for Supertonic?

No, the supertone-inc/supertonic repository does not maintain a standalone roadmap.md file. Instead, strategic direction is communicated through the Update News section in [`README.md`](https://github.com/supertone-inc/supertonic/blob/main/README.md), inline TODO comments in source files like [`py/helper.py`](https://github.com/supertone-inc/supertonic/blob/main/py/helper.py), and the incremental release cadence of the multi-runtime SDK.

### When will voice cloning be available via API?

While no specific date is committed, the May 2026 Update News highlights Voice Builder support for Supertonic 3, and the current SDK already accepts custom voice JSONs exported from the Voice Builder UI. This infrastructure suggests that a formal voice cloning API is in active development and will likely surface in upcoming releases.

### Which new runtimes are planned for edge deployment?

The project currently utilizes ONNX runtime, but demonstrations on Raspberry Pi and e-readers indicate plans for additional lightweight backends. Based on common edge-AI patterns and the project’s optimization goals, future support likely includes MNN and TensorRT to further reduce memory footprint on resource-constrained devices.

### How can I contribute to the Supertonic roadmap?

Contributors should monitor the TODO comments across language bindings—such as the normalizer enhancement noted in [`py/helper.py`](https://github.com/supertone-inc/supertonic/blob/main/py/helper.py) line 22—and participate in the community through the repository’s issue tracker. The rapid iteration cycle (multiple updates per year) suggests the maintainers actively incorporate community feedback into priority planning.