# What Are the Core Components of Supertonic?

> Discover Supertonic's core components. This multi-language TTS library uses minimal helper modules and a unified API to abstract ONNX inference for seamless text-to-speech generation.

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

---

**Supertonic is a multi-language Text-to-Speech library that provides minimal "Helper" modules for each supported programming language, abstracting ONNX inference behind a unified API surface.**

Supertonic by supertone-inc/supertonic is a cross-platform TTS solution designed to deliver consistent Text-to-Speech functionality across diverse programming ecosystems. The architecture follows a deliberately minimal design pattern where each language implementation wraps the core ONNX inference workflow. This approach allows developers to switch between languages without rewriting their TTS integration logic.

## Language-Specific Helper Modules

The repository organizes code by language, with each directory containing a compact **Helper** module that handles model loading, tensor preparation, inference execution, and audio post-processing.

### Go Implementation

The Go helper is implemented in [[`go/helper.go`](https://github.com/supertone-inc/supertonic/blob/main/go/helper.go)](https://github.com/supertone-inc/supertonic/blob/main/go/helper.go). It utilizes the `onnxruntime-go` bindings to load the ONNX model and return PCM audio data. The module exposes methods like `Synthesize()` that handle the full inference pipeline from text input to audio output.

### Rust Implementation

Located at [[`rust/src/helper.rs`](https://github.com/supertone-inc/supertonic/blob/main/rust/src/helper.rs)](https://github.com/supertone-inc/supertonic/blob/main/rust/src/helper.rs), the Rust helper wraps the `ort` crate (ONNX Runtime for Rust). This provides a memory-safe, idiomatic Rust API while maintaining the same public interface as other language implementations.

### Python Implementation

The Python helper in [[`py/helper.py`](https://github.com/supertone-inc/supertonic/blob/main/py/helper.py)](https://github.com/supertone-inc/supertonic/blob/main/py/helper.py) uses the standard `onnxruntime` package. It exposes a straightforward `synthesize(text)` function that abstracts the tensor manipulation and returns raw audio bytes.

### Node.js Implementation

Found in [[`nodejs/helper.js`](https://github.com/supertone-inc/supertonic/blob/main/nodejs/helper.js)](https://github.com/supertone-inc/supertonic/blob/main/nodejs/helper.js), this JavaScript wrapper leverages `onnxruntime-node`. It returns audio data as a `Float32Array`, making it compatible with Web Audio API and Node.js buffer operations.

### Java Implementation

The Java API resides in [[`java/Helper.java`](https://github.com/supertone-inc/supertonic/blob/main/java/Helper.java)](https://github.com/supertone-inc/supertonic/blob/main/java/Helper.java). It provides JNI bindings to ONNX Runtime, exposing a `byte[] synthesize(String text)` method that handles the native inference calls and returns PCM audio data.

### Swift Implementation

For iOS and macOS development, [[`swift/Sources/Helper.swift`](https://github.com/supertone-inc/supertonic/blob/main/swift/Sources/Helper.swift)](https://github.com/supertone-inc/supertonic/blob/main/swift/Sources/Helper.swift) offers a Swift-friendly wrapper. This implementation uses Apple's `MLModel` bridge to load the ONNX model and returns `Data` objects containing PCM audio samples.

### C++ Implementation

The native C++ interface consists of [[`cpp/helper.h`](https://github.com/supertone-inc/supertonic/blob/main/cpp/helper.h)](https://github.com/supertone-inc/supertonic/blob/main/cpp/helper.h) and [[`cpp/helper.cpp`](https://github.com/supertone-inc/supertonic/blob/main/cpp/helper.cpp)](https://github.com/supertone-inc/supertonic/blob/main/cpp/helper.cpp). These files implement the ONNX Runtime C API directly, providing maximum performance for embedded applications and systems programming.

### C# Implementation

The .NET helper in [[`csharp/Helper.cs`](https://github.com/supertone-inc/supertonic/blob/main/csharp/Helper.cs)](https://github.com/supertone-inc/supertonic/blob/main/csharp/Helper.cs) wraps the ONNX Runtime NuGet package. It exposes async synthesis methods that integrate naturally with C# async/await patterns while maintaining parity with the synchronous APIs in other languages.

### Flutter Integration

Supertonic does not include a dedicated Dart helper. Instead, the Flutter example demonstrates integration via platform channels, calling the native Android (Java) and iOS (Swift) helpers from Dart code. Configuration details are documented in the [[`flutter/README.md`](https://github.com/supertone-inc/supertonic/blob/main/flutter/README.md)](https://github.com/supertone-inc/supertonic/blob/main/flutter/README.md).

## Shared Architecture and Configuration

All Helper modules rely on the same **ONNX model** (`model.onnx`) bundled with repository releases. They share a **common configuration schema** that defines voice characteristics, sample rates, and inference parameters. This standardization ensures that a `synthesize()` call in Python produces identical output to a `synthesize()` call in Rust or Go, given the same input text and configuration.

## Implementation Examples

The following examples demonstrate the consistent three-step workflow across languages: instantiate the Helper, call `synthesize()`, and write the resulting PCM data.

### Go Usage

```go
package main

import (
	"log"
	"os"
	"supertonic/go"
)

func main() {
	helper, err := go.NewHelper("model.onnx")
	if err != nil {
		log.Fatalf("init error: %v", err)
	}
	audio, err := helper.Synthesize("Hello, Supertonic!")
	if err != nil {
		log.Fatalf("synthesis error: %v", err)
	}
	_ = os.WriteFile("output.wav", audio, 0644)
}

```

### Python Usage

```python
from supertonic import Helper

helper = Helper("model.onnx")
audio = helper.synthesize("Hello, Supertonic!")
with open("output.wav", "wb") as f:
    f.write(audio)

```

### Node.js Usage

```javascript
const { Helper } = require('supertonic-node');

(async () => {
  const helper = new Helper('model.onnx');
  const audio = await helper.synthesize('Hello, Supertonic!');
  const fs = require('fs');
  fs.writeFileSync('output.wav', Buffer.from(audio));
})();

```

## Summary

- **Multi-language support**: Supertonic provides dedicated Helper modules for Go, Rust, Python, Node.js, Java, Swift, C++, and C#.
- **Unified API**: Each implementation exposes consistent methods like `synthesize()`, `runModel()`, and `setConfig()` across all languages.
- **ONNX-based**: All helpers interface with the same `model.onnx` file using language-specific ONNX Runtime bindings.
- **Minimal abstraction**: Each Helper module is intentionally small, handling only model loading, inference, and audio output.
- **Flutter via platform channels**: Dart/Flutter integration occurs through native platform channels rather than a dedicated Dart helper.

## Frequently Asked Questions

### What is the primary purpose of Supertonic's Helper modules?

The Helper modules abstract the complex ONNX inference workflow into simple, language-idiomatic APIs. They handle model initialization, input tensor preparation, inference execution, and audio post-processing, allowing developers to generate speech with minimal code.

### How does Supertonic maintain API consistency across different programming languages?

According to the supertone-inc/supertonic source code, each Helper implements the same public method signatures—particularly `synthesize()`, `runModel()`, and `setConfig()`—ensuring that switching from Python to Go or Rust requires only syntax changes, not architectural changes.

### Which ONNX Runtime bindings does Supertonic use for different languages?

Supertonic selects language-appropriate ONNX Runtime bindings: `onnxruntime-go` for Go, the `ort` crate for Rust, `onnxruntime` pip package for Python, `onnxruntime-node` for JavaScript, JNI bindings for Java, the ONNX Runtime C API for C++, and the NuGet package for C#.

### Is there a native Dart or Flutter helper in the Supertonic repository?

No, Supertonic does not include a dedicated Dart helper. Instead, the Flutter implementation uses platform channels to invoke the native Java (Android) and Swift (iOS) helpers, as documented in the Flutter example directory.