diff --git a/apps/speech/screens/TextToSpeechScreen.tsx b/apps/speech/screens/TextToSpeechScreen.tsx
index 919076dc35..1bdeb9f542 100644
--- a/apps/speech/screens/TextToSpeechScreen.tsx
+++ b/apps/speech/screens/TextToSpeechScreen.tsx
@@ -14,34 +14,95 @@ import {
   models,
   useTextToSpeech,
   TextToSpeechModelConfig,
+  TextToSpeechSupertonicLanguage,
 } from 'react-native-executorch';
 import { ModelPicker, ModelOption } from '../components/ModelPicker';
 
-const tts = models.text_to_speech.kokoro;
+// Supertonic 3: a single multilingual model with 10 built-in voices. Each voice
+// works for any of the supported languages, and both the language and the
+// number of flow-matching steps are set per synthesis call (no model reload) —
+// see the LANGUAGES / STEPS pickers below.
+const tts = models.text_to_speech.supertonic;
 
 const VOICES: ModelOption<TextToSpeechModelConfig>[] = [
-  { label: '🇺🇸 AF Heart', value: tts.en_us.heart() },
-  { label: '🇺🇸 AF River', value: tts.en_us.river() },
-  { label: '🇺🇸 AF Sarah', value: tts.en_us.sarah() },
-  { label: '🇺🇸 AM Adam', value: tts.en_us.adam() },
-  { label: '🇺🇸 AM Michael', value: tts.en_us.michael() },
-  { label: '🇺🇸 AM Santa', value: tts.en_us.santa() },
-  { label: '🇬🇧 BF Emma', value: tts.en_gb.emma() },
-  { label: '🇬🇧 BM Daniel', value: tts.en_gb.daniel() },
-  { label: '🇫🇷 FF Siwis', value: tts.fr.siwis() },
-  { label: '🇪🇸 EF Dora', value: tts.es.dora() },
-  { label: '🇪🇸 EM Alex', value: tts.es.alex() },
-  { label: '🇮🇹 IF Sara', value: tts.it.sara() },
-  { label: '🇮🇹 IM Nicola', value: tts.it.nicola() },
-  { label: '🇵🇹 PF Dora', value: tts.pt.dora() },
-  { label: '🇵🇹 PM Santa', value: tts.pt.santa() },
-  { label: '🇩🇪 DF Anna', value: tts.de.anna() },
-  { label: '🇵🇱 PM Mateusz', value: tts.pl.mateusz() },
-  { label: '🇮🇳 HF Alpha', value: tts.hi.alpha() },
-  { label: '🇮🇳 HM Omega', value: tts.hi.omega() },
-  { label: '🇮🇳 HM Psi', value: tts.hi.psi() },
+  { label: '👨 Male 1', value: tts.m1() },
+  { label: '👨 Male 2', value: tts.m2() },
+  { label: '👨 Male 3', value: tts.m3() },
+  { label: '👨 Male 4', value: tts.m4() },
+  { label: '👨 Male 5', value: tts.m5() },
+  { label: '👩 Female 1', value: tts.f1() },
+  { label: '👩 Female 2', value: tts.f2() },
+  { label: '👩 Female 3', value: tts.f3() },
+  { label: '👩 Female 4', value: tts.f4() },
+  { label: '👩 Female 5', value: tts.f5() },
 ];
 
+// A per-call hyperparameter: the `<lang>` token. 'na' = unknown/other.
+const LANGUAGES: ModelOption<TextToSpeechSupertonicLanguage>[] = [
+  { label: '🇺🇸 English', value: 'en' },
+  { label: '🇪🇸 Spanish', value: 'es' },
+  { label: '🇫🇷 French', value: 'fr' },
+  { label: '🇩🇪 German', value: 'de' },
+  { label: '🇮🇹 Italian', value: 'it' },
+  { label: '🇵🇹 Portuguese', value: 'pt' },
+  { label: '🇵🇱 Polish', value: 'pl' },
+  { label: '🇷🇺 Russian', value: 'ru' },
+  { label: '🇯🇵 Japanese', value: 'ja' },
+  { label: '🇰🇷 Korean', value: 'ko' },
+  { label: '🇮🇳 Hindi', value: 'hi' },
+  { label: '🌐 Other (na)', value: 'na' },
+];
+
+// A per-call hyperparameter: number of flow-matching steps (quality vs. speed).
+const STEPS: ModelOption<number>[] = [
+  { label: '6 (fastest)', value: 6 },
+  { label: '8 (default)', value: 8 },
+  { label: '16 (best quality)', value: 16 },
+];
+
+// Kokoro: language-specific voices. Each voice bundles its own phonemizer
+// config, so only the voice picker is shown (no language/steps controls).
+const KOKORO_LANG_LABELS: Record<string, string> = {
+  en_us: '🇺🇸 US English',
+  en_gb: '🇬🇧 UK English',
+  fr: '🇫🇷 French',
+  es: '🇪🇸 Spanish',
+  it: '🇮🇹 Italian',
+  pt: '🇵🇹 Portuguese',
+  hi: '🇮🇳 Hindi',
+  pl: '🇵🇱 Polish',
+  de: '🇩🇪 German',
+};
+
+const capitalize = (s: string) => s.charAt(0).toUpperCase() + s.slice(1);
+
+// `models.text_to_speech.kokoro.<lang>.<voice>` are factory functions
+// (`() => TextToSpeechModelConfig`); call them to get the actual configs.
+const kokoroVoicesByLang = models.text_to_speech.kokoro as unknown as Record<
+  string,
+  Record<string, () => TextToSpeechModelConfig>
+>;
+
+const KOKORO_VOICES: ModelOption<TextToSpeechModelConfig>[] = Object.entries(
+  kokoroVoicesByLang
+).flatMap(([lang, voices]) =>
+  Object.entries(voices).map(([name, factory]) => ({
+    label: `${KOKORO_LANG_LABELS[lang] ?? lang} · ${capitalize(name)}`,
+    value: factory(),
+  }))
+);
+
+type TtsModelType = 'supertonic' | 'kokoro';
+
+const TTS_MODEL_OPTIONS: ModelOption<TtsModelType>[] = [
+  { label: 'Supertonic', value: 'supertonic' },
+  { label: 'Kokoro', value: 'kokoro' },
+];
+
+// Supertonic renders at 44.1 kHz, Kokoro at 24 kHz.
+const SUPERTONIC_SAMPLE_RATE = 44100;
+const KOKORO_SAMPLE_RATE = 24000;
+
 import FontAwesome from '@expo/vector-icons/FontAwesome';
 import {
   AudioManager,
@@ -56,13 +117,13 @@ import ErrorBanner from '../components/ErrorBanner';
  * Converts an audio vector (Float32Array) to an AudioBuffer for playback
  * @param audioVector - The generated audio samples from the model
  * @param audioContext - An optional AudioContext to create the buffer in. If not provided, a new one will be created.
- * @param sampleRate - The sample rate (default: 24000 Hz for Kokoro)
+ * @param sampleRate - The sample rate (default: 44100 Hz for Supertonic)
  * @returns AudioBuffer ready for playback
  */
 const createAudioBufferFromVector = (
   audioVector: Float32Array,
   audioContext: AudioContext | null = null,
-  sampleRate: number = 24000
+  sampleRate: number = SUPERTONIC_SAMPLE_RATE
 ): AudioBuffer => {
   if (audioContext == null) audioContext = new AudioContext({ sampleRate });
 
@@ -78,11 +139,29 @@ const createAudioBufferFromVector = (
 };
 
 export const TextToSpeechScreen = ({ onBack }: { onBack: () => void }) => {
+  const [selectedTtsModel, setSelectedTtsModel] =
+    useState<TtsModelType>('supertonic');
   const [selectedSpeaker, setSelectedSpeaker] =
-    useState<TextToSpeechModelConfig>(tts.en_us.heart());
+    useState<TextToSpeechModelConfig>(tts.m1());
+  const [selectedLang, setSelectedLang] =
+    useState<TextToSpeechSupertonicLanguage>('en');
+  const [totalSteps, setTotalSteps] = useState<number>(8);
 
   const model = useTextToSpeech(selectedSpeaker);
 
+  const sampleRate =
+    selectedTtsModel === 'supertonic'
+      ? SUPERTONIC_SAMPLE_RATE
+      : KOKORO_SAMPLE_RATE;
+
+  const handleSelectTtsModel = (type: TtsModelType) => {
+    if (type === selectedTtsModel) return;
+    setSelectedTtsModel(type);
+    setSelectedSpeaker(
+      type === 'supertonic' ? VOICES[0].value : KOKORO_VOICES[0].value
+    );
+  };
+
   const [inputText, setInputText] = useState('');
   const [isPlaying, setIsPlaying] = useState(false);
   const [readyToGenerate, setReadyToGenerate] = useState(false);
@@ -99,7 +178,7 @@ export const TextToSpeechScreen = ({ onBack }: { onBack: () => void }) => {
       iosOptions: ['defaultToSpeaker'],
     });
 
-    const context = new AudioContext({ sampleRate: 24000 });
+    const context = new AudioContext({ sampleRate });
     audioContextRef.current = context;
     context.suspend();
 
@@ -114,7 +193,7 @@ export const TextToSpeechScreen = ({ onBack }: { onBack: () => void }) => {
       audioContextRef.current = null;
       gainNodeRef.current = null;
     };
-  }, []);
+  }, [sampleRate]);
 
   useEffect(() => {
     setReadyToGenerate(!model.isGenerating && model.isReady && !isPlaying);
@@ -141,7 +220,7 @@ export const TextToSpeechScreen = ({ onBack }: { onBack: () => void }) => {
           const audioBuffer = createAudioBufferFromVector(
             audioVec,
             audioContext,
-            24000
+            sampleRate
           );
 
           const source = (sourceRef.current =
@@ -167,8 +246,10 @@ export const TextToSpeechScreen = ({ onBack }: { onBack: () => void }) => {
 
       await model.stream({
         text: inputText,
-        speed: 0.9,
-        phonemize: true,
+        speed: 1.0,
+        ...(selectedTtsModel === 'supertonic'
+          ? { totalSteps, lang: selectedLang }
+          : {}),
         onNext,
         onEnd,
       });
@@ -209,14 +290,42 @@ export const TextToSpeechScreen = ({ onBack }: { onBack: () => void }) => {
           </View>
           <ErrorBanner message={error} onDismiss={() => setError(null)} />
 
+          <ModelPicker
+            label="Model"
+            models={TTS_MODEL_OPTIONS}
+            selectedModel={selectedTtsModel}
+            disabled={model.isGenerating || isPlaying}
+            onSelect={handleSelectTtsModel}
+          />
+
           <ModelPicker
             label="Voice"
-            models={VOICES}
+            models={selectedTtsModel === 'supertonic' ? VOICES : KOKORO_VOICES}
             selectedModel={selectedSpeaker}
             disabled={model.isGenerating}
             onSelect={(m) => setSelectedSpeaker(m)}
           />
 
+          {selectedTtsModel === 'supertonic' && (
+            <>
+              <ModelPicker
+                label="Language"
+                models={LANGUAGES}
+                selectedModel={selectedLang}
+                disabled={isPlaying}
+                onSelect={(l) => setSelectedLang(l)}
+              />
+
+              <ModelPicker
+                label="Steps"
+                models={STEPS}
+                selectedModel={totalSteps}
+                disabled={isPlaying}
+                onSelect={(s) => setTotalSteps(s)}
+              />
+            </>
+          )}
+
           <View style={styles.inputContainer}>
             <Text style={styles.inputLabel}>Enter text to synthesize</Text>
             <TextInput
diff --git a/apps/speech/screens/VoiceActivityDetectionScreen.tsx b/apps/speech/screens/VoiceActivityDetectionScreen.tsx
index 724ea52500..e3e72caf87 100644
--- a/apps/speech/screens/VoiceActivityDetectionScreen.tsx
+++ b/apps/speech/screens/VoiceActivityDetectionScreen.tsx
@@ -8,10 +8,7 @@ import {
   Platform,
 } from 'react-native';
 import { SafeAreaProvider, SafeAreaView } from 'react-native-safe-area-context';
-import {
-  models,
-  useVAD 
-} from 'react-native-executorch';
+import { models, useVAD } from 'react-native-executorch';
 import FontAwesome from '@expo/vector-icons/FontAwesome';
 import { AudioManager, AudioRecorder } from 'react-native-audio-api';
 import SWMIcon from '../assets/swm_icon.svg';
diff --git a/docs/docs/03-hooks/01-natural-language-processing/useTextToSpeech.md b/docs/docs/03-hooks/01-natural-language-processing/useTextToSpeech.md
index 9598ab75a6..b4f672a4cf 100644
--- a/docs/docs/03-hooks/01-natural-language-processing/useTextToSpeech.md
+++ b/docs/docs/03-hooks/01-natural-language-processing/useTextToSpeech.md
@@ -6,6 +6,7 @@ keywords: [
     voice synthesizer,
     transcription,
     kokoro,
+    supertonic,
     react native,
     executorch,
     ai,
@@ -19,7 +20,10 @@ description: "Learn how to use text-to-speech models in your React Native applic
 Text to speech is a task that allows to transform written text into spoken language. It is commonly used to implement features such as voice assistants, accessibility tools, or audiobooks.
 
 :::info
-It is recommended to use models provided by us, which are available at our [Hugging Face repository](https://huggingface.co/software-mansion/react-native-executorch-kokoro). You can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
+It is recommended to use models provided by us, which are available at our Hugging Face repositories:
+[Kokoro](https://huggingface.co/software-mansion/react-native-executorch-kokoro) and
+[Supertonic 3](https://huggingface.co/software-mansion/react-native-executorch-supertonic).
+You can also use [constants](https://github.com/software-mansion/react-native-executorch/blob/main/packages/react-native-executorch/src/constants/modelUrls.ts) shipped with our library.
 :::
 
 ## API Reference
@@ -32,6 +36,35 @@ It is recommended to use models provided by us, which are available at our [Hugg
 
 You can play the generated waveform in any way most suitable to you; however, in the snippet below we utilize the react-native-audio-api library to play synthesized speech.
 
+### Supertonic 3
+
+```typescript
+import { models, useTextToSpeech } from 'react-native-executorch';
+import { AudioContext } from 'react-native-audio-api';
+
+const model = useTextToSpeech(models.text_to_speech.supertonic.m1());
+
+const audioContext = new AudioContext({ sampleRate: 44100 });
+
+const handleSpeech = async (text: string) => {
+  const waveform = await model.forward({
+    text,
+    totalSteps: 8,
+    lang: 'en',
+  });
+
+  const audioBuffer = audioContext.createBuffer(1, waveform.length, 44100);
+  audioBuffer.getChannelData(0).set(waveform);
+
+  const source = audioContext.createBufferSource();
+  source.buffer = audioBuffer;
+  source.connect(audioContext.destination);
+  source.start();
+};
+```
+
+### Kokoro
+
 ```typescript
 import { models, useTextToSpeech } from 'react-native-executorch';
 import { AudioContext } from 'react-native-audio-api';
@@ -58,9 +91,10 @@ const handleSpeech = async (text: string) => {
 
 `useTextToSpeech` takes [`TextToSpeechModelConfig`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md) that consists of:
 
-- `model` of type [`TextToSpeechModelSources`](../../06-api-reference/type-aliases/TextToSpeechModelSources.md) containing the [`durationPredictorSource`](../../06-api-reference/type-aliases/TextToSpeechModelSources.md#durationpredictorsource), [`synthesizerSource`](../../06-api-reference/type-aliases/TextToSpeechModelSources.md#synthesizersource), and [`modelName`](../../06-api-reference/type-aliases/TextToSpeechModelSources.md#modelname).
-- [`voiceSource`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#voicesource) of type [`ResourceSource`](../../06-api-reference/type-aliases/ResourceSource.md) - configuration of specific voice used in TTS.
-- [`phonemizerConfig`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#phonemizerconfig) of type [`TextToSpeechPhonemizerConfig`](../../06-api-reference/interfaces/TextToSpeechPhonemizerConfig.md) - configuration of the phonemizer.
+- `model` of type [`TextToSpeechModelSources`](../../06-api-reference/type-aliases/TextToSpeechModelSources.md) — model configuration.
+- [`voiceSource`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#voicesource) of type [`ResourceSource`](../../06-api-reference/type-aliases/ResourceSource.md) — the voice tensor used for synthesis.
+- [`phonemizerConfig`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#phonemizerconfig) of type [`TextToSpeechPhonemizerConfig`](../../06-api-reference/interfaces/TextToSpeechPhonemizerConfig.md) — Kokoro only: phonemizer configuration. Unused by Supertonic.
+- [`lang`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#lang) of type [`TextToSpeechSupertonicLanguage`](../../06-api-reference/type-aliases/TextToSpeechSupertonicLanguage.md) — Supertonic only: default language token (e.g. `'en'`, `'na'`). Unused by Kokoro.
 
 `useTextToSpeech`'s second optional argument is an object with:
 
@@ -79,21 +113,28 @@ You need more details? Check the following resources:
 
 ## Running the model
 
-The module provides two ways to generate speech using either raw text or pre-generated phonemes:
+The module provides two ways to generate speech. The available parameters differ by model family:
+
+| Parameter    | Kokoro | Supertonic |
+| ------------ | ------ | ---------- |
+| `speed`      | ✓      |            |
+| `phonemize`  | ✓      |            |
+| `totalSteps` |        | ✓          |
+| `lang`       |        | ✓          |
 
 ### Using Text
 
-1.  [**`forward({ text, speed, phonemize })`**](../../06-api-reference/interfaces/TextToSpeechType.md#forward): Generates the complete audio waveform at once. Returns a promise resolving to a `Float32Array`.
-2.  [**`stream({ speed, phonemize, stopAutomatically, onNext, ... })`**](../../06-api-reference/interfaces/TextToSpeechType.md#stream): An async generator-like functionality (managed via callbacks like `onNext`) that yields chunks of audio as they are computed.
+1.  [**`forward({ text, speed, phonemize, totalSteps, lang })`**](../../06-api-reference/interfaces/TextToSpeechType.md#forward): Generates the complete audio waveform at once. Returns a promise resolving to a `Float32Array`.
+2.  [**`stream({ speed, phonemize, totalSteps, lang, stopAutomatically, onNext, ... })`**](../../06-api-reference/interfaces/TextToSpeechType.md#stream): An async generator-like functionality (managed via callbacks like `onNext`) that yields chunks of audio as they are computed.
     This is ideal for reducing the "time to first audio" for long sentences. You can also dynamically insert text during the generation process using `streamInsert(text)`, force-partition trailing content without an end-of-sentence character via `streamFlush()`, and stop the stream with `streamStop(instant)`.
 
 :::tip Recommendation
 In most cases, the **`stream()`** method is recommended over `forward()`. It significantly reduces latency by allowing audio playback to begin as soon as the first chunk is synthesized, rather than waiting for the entire text to be processed.
 :::
 
-Both methods accept a `phonemize` parameter (defaults to `true`). When set to `true`, the input `text` is treated as raw text and converted to phonemes internally. When set to `false`, the input is expected to be a string of IPA phonemes.
+Both methods accept a `phonemize` parameter (defaults to `true`). This applies to **Kokoro only** — Supertonic maps text directly through a unicode indexer and does not use phonemization. When set to `true`, the input `text` is treated as raw text and converted to phonemes internally. When set to `false`, the input is expected to be a string of IPA phonemes.
 
-### Using Phonemes
+### Using Phonemes (Kokoro only)
 
 If you have pre-computed phonemes (e.g., from an external dictionary or a custom G2P model), you can skip the internal phoneme generation step:
 
@@ -106,7 +147,7 @@ Since `forward` and `stream` process the input, they might take a significant am
 
 ## Example
 
-### Speech Synthesis
+### Raw Synthesis (forward)
 
 ```tsx
 import React from 'react';
@@ -115,16 +156,24 @@ import { models, useTextToSpeech } from 'react-native-executorch';
 import { AudioContext } from 'react-native-audio-api';
 
 export default function App() {
-  const tts = useTextToSpeech(models.text_to_speech.kokoro.en_us.heart());
+  // Supertonic 3 — multilingual, any voice works for any language
+  const tts = useTextToSpeech(models.text_to_speech.supertonic.m1());
+  // Kokoro — language-specific voice bundle:
+  // const tts = useTextToSpeech(models.text_to_speech.kokoro.en_us.heart());
 
   const generateAudio = async () => {
     const audioData = await tts.forward({
       text: 'Hello world! This is a sample text.',
+      totalSteps: 8,
+      lang: 'en',
+      // Kokoro: text only (no totalSteps/lang):
+      // text: 'Hello world! This is a sample text.',
     });
 
-    // Playback example
-    const ctx = new AudioContext({ sampleRate: 24000 });
-    const buffer = ctx.createBuffer(1, audioData.length, 24000);
+    // Playback — sample rate depends on the model
+    const ctx = new AudioContext({ sampleRate: 44100 });
+    // Kokoro: sampleRate: 24000
+    const buffer = ctx.createBuffer(1, audioData.length, ctx.sampleRate);
     buffer.getChannelData(0).set(audioData);
 
     const source = ctx.createBufferSource();
@@ -150,18 +199,25 @@ import { models, useTextToSpeech } from 'react-native-executorch';
 import { AudioContext } from 'react-native-audio-api';
 
 export default function App() {
-  const tts = useTextToSpeech(models.text_to_speech.kokoro.en_us.heart());
+  // Supertonic 3
+  const tts = useTextToSpeech(models.text_to_speech.supertonic.m1());
+  // Kokoro:
+  // const tts = useTextToSpeech(models.text_to_speech.kokoro.en_us.heart());
 
-  const contextRef = useRef(new AudioContext({ sampleRate: 24000 }));
+  const contextRef = useRef(new AudioContext({ sampleRate: 44100 }));
+  // Kokoro: sampleRate: 24000
 
   const generateStream = async () => {
     const ctx = contextRef.current;
 
     await tts.stream({
       text: "This is a longer text, which is being streamed chunk by chunk. Let's see how it works!",
+      totalSteps: 8,
+      lang: 'en',
+      // Kokoro: use speed: 1.0 instead of totalSteps/lang
       onNext: async (chunk) => {
         return new Promise((resolve) => {
-          const buffer = ctx.createBuffer(1, chunk.length, 24000);
+          const buffer = ctx.createBuffer(1, chunk.length, ctx.sampleRate);
           buffer.getChannelData(0).set(chunk);
 
           const source = ctx.createBufferSource();
@@ -182,42 +238,9 @@ export default function App() {
 }
 ```
 
-### Synthesis from Phonemes
-
-If you already have a phoneme string obtained from an external source (e.g. the Python `phonemizer` library,
-`espeak-ng`, or any custom phonemizer), you can use `forward` or `stream` with the `phonemize: false` flag to synthesize audio directly, skipping the phoneme generation stage.
-
-```tsx
-import React from 'react';
-import { Button, View } from 'react-native';
-import { models, useTextToSpeech } from 'react-native-executorch';
-export default function App() {
-  const tts = useTextToSpeech(models.text_to_speech.kokoro.en_us.heart());
-
-  const synthesizePhonemes = async () => {
-    // Example phonemes for "Hello"
-    const audioData = await tts.forward({
-      text: 'ɐ mˈæn hˌu dˈʌzᵊnt tɹˈʌst hɪmsˈɛlf, kæn nˈɛvəɹ ɹˈiᵊli tɹˈʌst ˈɛniwˌʌn ˈɛls.',
-      phonemize: false,
-    });
-
-    // ... process or play audioData ...
-  };
-
-  return (
-    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
-      <Button
-        title="Synthesize Phonemes"
-        onPress={synthesizePhonemes}
-        disabled={!tts.isReady}
-      />
-    </View>
-  );
-}
-```
-
 ## Supported models
 
-| Model                                                                            |                               Language                               |
-| -------------------------------------------------------------------------------- | :------------------------------------------------------------------: |
-| [Kokoro](https://huggingface.co/software-mansion/react-native-executorch-kokoro) | English, French, German, Spanish, Portuguese, Italian, Polish, Hindi |
+| Model                                                                                      |                                                                                                                                                     Language                                                                                                                                                     |
+| ------------------------------------------------------------------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| [Supertonic 3](https://huggingface.co/software-mansion/react-native-executorch-supertonic) | 31 languages + `na` (unknown) — Arabic, Bulgarian, Czech, Danish, Dutch, English, Finnish, French, German, Greek, Hindi, Hungarian, Indonesian, Italian, Japanese, Korean, Malay, Norwegian, Polish, Portuguese, Romanian, Russian, Slovak, Spanish, Swahili, Swedish, Tagalog, Tamil, Thai, Turkish, Vietnamese |
+| [Kokoro](https://huggingface.co/software-mansion/react-native-executorch-kokoro)           |                                                                                                                       English, French, German, Spanish, Portuguese, Italian, Polish, Hindi                                                                                                                       |
diff --git a/docs/docs/04-typescript-api/01-natural-language-processing/TextToSpeechModule.md b/docs/docs/04-typescript-api/01-natural-language-processing/TextToSpeechModule.md
index f18abe1029..9d20919acf 100644
--- a/docs/docs/04-typescript-api/01-natural-language-processing/TextToSpeechModule.md
+++ b/docs/docs/04-typescript-api/01-natural-language-processing/TextToSpeechModule.md
@@ -12,6 +12,20 @@ TypeScript API implementation of the [useTextToSpeech](../../03-hooks/01-natural
 
 ## High Level Overview
 
+### Supertonic 3
+
+```typescript
+import { models, TextToSpeechModule } from 'react-native-executorch';
+const model = await TextToSpeechModule.fromModelName(
+  models.text_to_speech.supertonic.m1(),
+  (progress) => console.log(progress)
+);
+
+await model.forward('Hello world!', 1.0, true, 8, 'en');
+```
+
+### Kokoro
+
 ```typescript
 import { models, TextToSpeechModule } from 'react-native-executorch';
 const model = await TextToSpeechModule.fromModelName(
@@ -33,7 +47,8 @@ Use the static [`fromModelName`](../../06-api-reference/classes/TextToSpeechModu
 - [`config`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md) - Object containing:
   - [`model`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#model) - Model configuration.
   - [`voiceSource`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#voicesource) - Voice resource source.
-  - [`phonemizerConfig`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#phonemizerconfig) - Phonemizer configuration.
+  - [`phonemizerConfig`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#phonemizerconfig) - Phonemizer configuration. Kokoro only; unused by Supertonic.
+  - [`lang`](../../06-api-reference/interfaces/TextToSpeechModelConfig.md#lang) - Default language token. Supertonic only; unused by Kokoro.
 
 - [`onDownloadProgress`](../../06-api-reference/classes/TextToSpeechModule.md#frommodelname) - Optional callback to track download progress (value between 0 and 1).
 
@@ -43,15 +58,22 @@ For more information on resource sources, see [loading models](../../01-fundamen
 
 ## Running the model
 
-The module provides a way to generate speech using either raw text or pre-generated phonemes.
+The module provides two ways to generate speech. The available parameters differ by model family:
+
+| Parameter    | Kokoro | Supertonic |
+| ------------ | ------ | ---------- |
+| `speed`      | ✓      |            |
+| `phonemize`  | ✓      |            |
+| `totalSteps` |        | ✓          |
+| `lang`       |        | ✓          |
 
 ### Methods
 
-1.  [**`forward(text, speed, phonemize)`**](../../06-api-reference/classes/TextToSpeechModule.md#forward): Generates the complete audio waveform at once. Returns a promise resolving to a `Float32Array`.
-    - `phonemize` defaults to `true`. When set to `false`, the input is expected to be a string of IPA phonemes.
-2.  [**`stream({ speed, phonemize, stopAutomatically, ... })`**](../../06-api-reference/classes/TextToSpeechModule.md#stream): An async generator that yields chunks of audio as they are computed. This is ideal for reducing the "time to first audio" for long sentences. In contrast to `forward`, it enables inserting text chunks dynamically into the processing buffer with [**`streamInsert(text)`**](../../06-api-reference/classes/TextToSpeechModule.md#streaminsert), force-partitioning trailing un-terminated content via [**`streamFlush()`**](../../06-api-reference/classes/TextToSpeechModule.md#streamflush), and stopping generation early with [**`streamStop(instant)`**](../../06-api-reference/classes/TextToSpeechModule.md#streamstop).
+1.  [**`forward(text, speed, phonemize, totalSteps, lang)`**](../../06-api-reference/classes/TextToSpeechModule.md#forward): Generates the complete audio waveform at once. Returns a promise resolving to a `Float32Array`.
+    - `phonemize` (Kokoro only) defaults to `true`. When set to `false`, the input is expected to be a string of IPA phonemes.
+2.  [**`stream({ speed, phonemize, totalSteps, lang, stopAutomatically, ... })`**](../../06-api-reference/classes/TextToSpeechModule.md#stream): An async generator that yields chunks of audio as they are computed. This is ideal for reducing the "time to first audio" for long sentences. In contrast to `forward`, it enables inserting text chunks dynamically into the processing buffer with [**`streamInsert(text)`**](../../06-api-reference/classes/TextToSpeechModule.md#streaminsert), force-partitioning trailing un-terminated content via [**`streamFlush()`**](../../06-api-reference/classes/TextToSpeechModule.md#streamflush), and stopping generation early with [**`streamStop(instant)`**](../../06-api-reference/classes/TextToSpeechModule.md#streamstop).
 
-### Using Phonemes
+### Using Phonemes (Kokoro only)
 
 If you have pre-computed phonemes (e.g., from an external dictionary or a custom G2P model), you can skip the internal phoneme generation step by setting `phonemize: false` in the `forward` or `stream` methods.
 
@@ -61,22 +83,42 @@ Since `forward` processes the entire input at once, it might take a significant
 
 ## Example
 
-### Speech Synthesis
+### Raw Synthesis (forward)
 
 ```typescript
 import { models, TextToSpeechModule } from 'react-native-executorch';
 import { AudioContext } from 'react-native-audio-api';
 
+// Supertonic 3 — multilingual, any voice works for any language
 const tts = await TextToSpeechModule.fromModelName(
-  models.text_to_speech.kokoro.en_us.heart()
+  models.text_to_speech.supertonic.m1(),
+  (progress) => console.log(progress)
 );
-const audioContext = new AudioContext({ sampleRate: 24000 });
+// Kokoro — language-specific voice bundle:
+// const tts = await TextToSpeechModule.fromModelName(
+//   models.text_to_speech.kokoro.en_us.heart(),
+//   (progress) => console.log(progress)
+// );
+
+const audioContext = new AudioContext({ sampleRate: 44100 });
+// Kokoro: sampleRate: 24000
 
 try {
-  const waveform = await tts.forward('Hello from ExecuTorch!', 1.0);
+  const waveform = await tts.forward(
+    'Hello from ExecuTorch!',
+    1.0,
+    true,
+    8,
+    'en'
+  );
+  // Kokoro: tts.forward('Hello from ExecuTorch!', 1.0)
 
   // Create audio buffer and play
-  const audioBuffer = audioContext.createBuffer(1, waveform.length, 24000);
+  const audioBuffer = audioContext.createBuffer(
+    1,
+    waveform.length,
+    audioContext.sampleRate
+  );
   audioBuffer.getChannelData(0).set(waveform);
 
   const source = audioContext.createBufferSource();
@@ -94,19 +136,34 @@ try {
 import { models, TextToSpeechModule } from 'react-native-executorch';
 import { AudioContext } from 'react-native-audio-api';
 
+// Supertonic 3
 const tts = await TextToSpeechModule.fromModelName(
-  models.text_to_speech.kokoro.en_us.heart()
+  models.text_to_speech.supertonic.m1(),
+  (progress) => console.log(progress)
 );
-const audioContext = new AudioContext({ sampleRate: 24000 });
+// Kokoro:
+// const tts = await TextToSpeechModule.fromModelName(
+//   models.text_to_speech.kokoro.en_us.heart(),
+//   (progress) => console.log(progress)
+// );
+
+const audioContext = new AudioContext({ sampleRate: 44100 });
+// Kokoro: sampleRate: 24000
 
 try {
   for await (const chunk of tts.stream({
     text: 'This is a streaming test, with a sample input.',
-    speed: 1.0,
+    totalSteps: 8,
+    lang: 'en',
+    // Kokoro: use speed: 1.0 instead of totalSteps/lang
   })) {
     // Play each chunk sequentially
     await new Promise<void>((resolve) => {
-      const audioBuffer = audioContext.createBuffer(1, chunk.length, 24000);
+      const audioBuffer = audioContext.createBuffer(
+        1,
+        chunk.length,
+        audioContext.sampleRate
+      );
       audioBuffer.getChannelData(0).set(chunk);
 
       const source = audioContext.createBufferSource();
@@ -120,26 +177,3 @@ try {
   console.error('Streaming failed:', error);
 }
 ```
-
-### Synthesis from Phonemes
-
-If you already have a phoneme string (e.g., from an external library), you can use `forward` or `stream` with the `phonemize: false` flag to synthesize audio directly, skipping the internal phonemizer stage.
-
-```typescript
-import { models, TextToSpeechModule } from 'react-native-executorch';
-const tts = await TextToSpeechModule.fromModelName(
-  models.text_to_speech.kokoro.en_us.heart()
-);
-
-// Example phonemes for "ExecuTorch"
-const waveform = await tts.forward('həlˈO wˈɜɹld!', 1.0, false);
-
-// Or stream from phonemes
-for await (const chunk of tts.stream({
-  text: 'ɐ mˈæn hˌu dˈʌzᵊnt tɹˈʌst hɪmsˈɛlf, kæn nˈɛvəɹ ɹˈiᵊli tɹˈʌst ˈɛniwˌʌn ˈɛls.',
-  speed: 1.0,
-  phonemize: false,
-})) {
-  // ... process chunk ...
-}
-```
diff --git a/docs/docs/05-utilities/model-registry.md b/docs/docs/05-utilities/model-registry.md
index 1f135ea43c..7f0e305eea 100644
--- a/docs/docs/05-utilities/model-registry.md
+++ b/docs/docs/05-utilities/model-registry.md
@@ -20,23 +20,23 @@ Each leaf is a **function**. Call it (optionally with `{ quant, backend }`) to g
 
 `models` is grouped by capability. Each leaf is a callable accessor.
 
-| Group                   | Examples                                                                                                                                                                                                                                                                                    |
-| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `llm`                   | `llama3_2_3b`, `qwen3_4b`, `smollm2_1_1_7b`, `phi_4_mini_4b`, `bielik_v3_0_1_5b`, `lfm2_5_1_2b_instruct`, `lfm2_5_vl_1_6b`, `lfm2_5_vl_450m`, …                                                                                                                                             |
-| `classification`        | `efficientnet_v2_s`                                                                                                                                                                                                                                                                         |
-| `privacy_filter`        | `openai`, `nemotron`                                                                                                                                                                                                                                                                        |
-| `object_detection`      | `ssdlite_320_mobilenet_v3_large`, `yolo26n` … `yolo26x`, `rf_detr_nano`                                                                                                                                                                                                                     |
-| `pose_estimation`       | `yolo26n`, `rfdetr_keypoint_preview` _(beta)_                                                                                                                                                                                                                                               |
-| `semantic_segmentation` | `deeplab_v3_resnet50`, `lraspp_mobilenet_v3_large`, `fcn_resnet101`, `selfie_segmentation`, …                                                                                                                                                                                               |
-| `instance_segmentation` | `yolo26n` … `yolo26x`, `rf_detr_nano`, `fastsam_s`, `fastsam_x`                                                                                                                                                                                                                             |
-| `style_transfer`        | `candy`, `mosaic`, `rain_princess`, `udnie`                                                                                                                                                                                                                                                 |
-| `speech_to_text`        | `whisper_tiny_en`, `whisper_base`, `whisper_small_en`, …                                                                                                                                                                                                                                    |
-| `text_to_speech`        | nested by model family + language: `kokoro.en_us.{heart, river, sarah, adam, …}`, `kokoro.en_gb.{emma, daniel}`, `kokoro.fr.siwis`, `kokoro.es.{dora, alex}`, `kokoro.it.{sara, nicola}`, `kokoro.pt.{dora, santa}`, `kokoro.hi.{alpha, omega, psi}`, `kokoro.pl.mateusz`, `kokoro.de.anna` |
-| `text_embedding`        | `all_minilm_l6_v2`, `all_mpnet_base_v2`, `clip_vit_base_patch32_text`, …                                                                                                                                                                                                                    |
-| `image_embedding`       | `clip_vit_base_patch32_image`                                                                                                                                                                                                                                                               |
-| `image_generation`      | `bk_sdm_tiny_vpred_256`, `bk_sdm_tiny_vpred_512`                                                                                                                                                                                                                                            |
-| `vad`                   | `fsmn_vad`                                                                                                                                                                                                                                                                                  |
-| `ocr`                   | nested by detector: `craft({ language: 'en' })` — see [§OCR](#ocr) below                                                                                                                                                                                                                    |
+| Group                   | Examples                                                                                                                                                                                                                                                                                                        |
+| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `llm`                   | `llama3_2_3b`, `qwen3_4b`, `smollm2_1_1_7b`, `phi_4_mini_4b`, `bielik_v3_0_1_5b`, `lfm2_5_1_2b_instruct`, `lfm2_5_vl_1_6b`, `lfm2_5_vl_450m`, …                                                                                                                                                                 |
+| `classification`        | `efficientnet_v2_s`                                                                                                                                                                                                                                                                                             |
+| `privacy_filter`        | `openai`, `nemotron`                                                                                                                                                                                                                                                                                            |
+| `object_detection`      | `ssdlite_320_mobilenet_v3_large`, `yolo26n` … `yolo26x`, `rf_detr_nano`                                                                                                                                                                                                                                         |
+| `pose_estimation`       | `yolo26n`, `rfdetr_keypoint_preview` _(beta)_                                                                                                                                                                                                                                                                   |
+| `semantic_segmentation` | `deeplab_v3_resnet50`, `lraspp_mobilenet_v3_large`, `fcn_resnet101`, `selfie_segmentation`, …                                                                                                                                                                                                                   |
+| `instance_segmentation` | `yolo26n` … `yolo26x`, `rf_detr_nano`, `fastsam_s`, `fastsam_x`                                                                                                                                                                                                                                                 |
+| `style_transfer`        | `candy`, `mosaic`, `rain_princess`, `udnie`                                                                                                                                                                                                                                                                     |
+| `speech_to_text`        | `whisper_tiny_en`, `whisper_base`, `whisper_small_en`, …                                                                                                                                                                                                                                                        |
+| `text_to_speech`        | nested by model family: `kokoro.en_us.{heart, river, sarah, adam, …}`, `kokoro.en_gb.{emma, daniel}`, `kokoro.fr.siwis`, `kokoro.es.{dora, alex}`, `kokoro.it.{sara, nicola}`, `kokoro.pt.{dora, santa}`, `kokoro.hi.{alpha, omega, psi}`, `kokoro.pl.mateusz`, `kokoro.de.anna`, `supertonic.{m1..m5, f1..f5}` |
+| `text_embedding`        | `all_minilm_l6_v2`, `all_mpnet_base_v2`, `clip_vit_base_patch32_text`, …                                                                                                                                                                                                                                        |
+| `image_embedding`       | `clip_vit_base_patch32_image`                                                                                                                                                                                                                                                                                   |
+| `image_generation`      | `bk_sdm_tiny_vpred_256`, `bk_sdm_tiny_vpred_512`                                                                                                                                                                                                                                                                |
+| `vad`                   | `fsmn_vad`                                                                                                                                                                                                                                                                                                      |
+| `ocr`                   | nested by detector: `craft({ language: 'en' })` — see [§OCR](#ocr) below                                                                                                                                                                                                                                        |
 
 ## Options
 
@@ -91,16 +91,24 @@ const styled = useStyleTransfer({
 
 ### Text-to-speech
 
-`text_to_speech` is grouped by model family then by language code (`kokoro.en_us`, `kokoro.en_gb`, `kokoro.fr`, `kokoro.es`, `kokoro.it`, `kokoro.pt`, `kokoro.hi`, `kokoro.pl`, `kokoro.de`). Each leaf returns a complete Kokoro preset bundling the model, voice, and phonemizer — pass the whole result to `useTextToSpeech`. The `kokoro` level reserves room for a future TTS family without forcing a breaking rename.
+`text_to_speech` is grouped by model family:
+
+- **`kokoro.*`** — grouped by language code (`kokoro.en_us`, `kokoro.en_gb`, `kokoro.fr`, …). Each leaf returns a complete Kokoro preset bundling the model, voice, and phonemizer — pass the whole result to `useTextToSpeech`.
+- **`supertonic`** — a single multilingual model with 10 built-in voices (`supertonic.{m1..m5, f1..f5}`). No phonemizer needed; language is selected per-call.
 
 ```typescript
 import { models, useTextToSpeech } from 'react-native-executorch';
 
+// Kokoro — language-specific voice bundles
 const tts = useTextToSpeech(models.text_to_speech.kokoro.en_us.heart());
 // Other languages:
 //   models.text_to_speech.kokoro.en_gb.emma()
 //   models.text_to_speech.kokoro.fr.siwis()
 //   models.text_to_speech.kokoro.pl.mateusz()
+
+// Supertonic 3 — multilingual, any voice works for any language
+const tts2 = useTextToSpeech(models.text_to_speech.supertonic.m1());
+// Available voices: m1, m2, m3, m4, m5, f1, f2, f3, f4, f5
 ```
 
 ### OCR
diff --git a/packages/react-native-executorch/common/rnexecutorch/RnExecutorchInstaller.cpp b/packages/react-native-executorch/common/rnexecutorch/RnExecutorchInstaller.cpp
index 53ee65a904..b79cbc677d 100644
--- a/packages/react-native-executorch/common/rnexecutorch/RnExecutorchInstaller.cpp
+++ b/packages/react-native-executorch/common/rnexecutorch/RnExecutorchInstaller.cpp
@@ -130,6 +130,12 @@ void RnExecutorchInstaller::injectJSIBindings(
       RnExecutorchInstaller::loadModel<models::text_to_speech::kokoro::Kokoro>(
           jsiRuntime, jsCallInvoker, "loadTextToSpeechKokoro"));
 
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadTextToSpeechSupertonic",
+      RnExecutorchInstaller::loadModel<
+          models::text_to_speech::supertonic::Supertonic>(
+          jsiRuntime, jsCallInvoker, "loadTextToSpeechSupertonic"));
+
   jsiRuntime->global().setProperty(
       *jsiRuntime, "loadVAD",
       RnExecutorchInstaller::loadModel<
diff --git a/packages/react-native-executorch/common/rnexecutorch/host_objects/ModelHostObject.h b/packages/react-native-executorch/common/rnexecutorch/host_objects/ModelHostObject.h
index cb631e5fba..422a6741e6 100644
--- a/packages/react-native-executorch/common/rnexecutorch/host_objects/ModelHostObject.h
+++ b/packages/react-native-executorch/common/rnexecutorch/host_objects/ModelHostObject.h
@@ -236,6 +236,24 @@ template <typename Model> class ModelHostObject : public JsiHostObject {
           "streamFlush"));
     }
 
+    if constexpr (meta::SameAs<
+                      Model, models::text_to_speech::supertonic::Supertonic>) {
+      addFunctions(
+          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::stream>,
+                                       "stream"));
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, synchronousHostFunction<&Model::streamStop>,
+          "streamStop"));
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, synchronousHostFunction<&Model::streamInsert>,
+          "streamInsert"));
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, synchronousHostFunction<&Model::streamFlush>,
+          "streamFlush"));
+    }
+
     if constexpr (meta::HasGenerateFromString<Model>) {
       addFunctions(
           JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/TextToSpeech.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/TextToSpeech.h
index 2fb17c95f5..856f21ad62 100644
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/TextToSpeech.h
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/TextToSpeech.h
@@ -1,3 +1,4 @@
 #pragma once
 
-#include "kokoro/Kokoro.h"
\ No newline at end of file
+#include "kokoro/Kokoro.h"
+#include "supertonic/Supertonic.h"
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/Constants.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/Constants.h
new file mode 100644
index 0000000000..f06ff757bd
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/Constants.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <cstdint>
+#include <unordered_set>
+
+namespace rnexecutorch::models::text_to_speech::constants {
+
+// Special text characters - end of sentence markers
+inline const std::unordered_set<char32_t> kEndOfSentenceCharacters = {
+    U'.', U'?', U'!', U';',
+    U'…', // Ellipsis
+    U'|', // ASCII Pipe (often used as Hindi Purna Viram)
+    U'।', // Hindi Purna Viram (U+0964)
+    U'॥', // Hindi Deergh Viram (U+0965)
+    U'¿', // Spanish Inverted Question Mark (U+00BF)
+    U'¡', // Spanish Inverted Exclamation Mark (U+00A1)
+};
+
+// Special text characters - mid-sentence pause markers
+inline const std::unordered_set<char32_t> kPauseCharacters = {
+    U',', U':', U'-',
+    U'—', // Em Dash (U+2014)
+    U'«', // Left Guillemet (U+00AB)
+    U'»', // Right Guillemet (U+00BB)
+};
+
+} // namespace rnexecutorch::models::text_to_speech::constants
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/TextPartitioner.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/TextPartitioner.cpp
new file mode 100644
index 0000000000..a3ca972535
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/TextPartitioner.cpp
@@ -0,0 +1,105 @@
+#include "TextPartitioner.h"
+#include "Constants.h"
+
+#include <algorithm>
+#include <deque>
+#include <limits>
+#include <ranges>
+
+namespace rnexecutorch::models::text_to_speech {
+
+constexpr TextPartitioner::Cost INF = 1e7;
+
+TextPartitioner::TextPartitioner(const TextPartitionerConfig &cfg)
+    : config_(cfg) {}
+
+TextPartitioner::Partition TextPartitioner::partition(std::u32string_view input,
+                                                      size_t limit) const {
+  if (input.empty()) {
+    return {input, {}};
+  }
+
+  size_t n = input.size();
+  std::vector<std::pair<Cost, int64_t>> dp(n, {INF, -1});
+
+  std::deque<size_t> eosPoints, pausePoints, whitePoints;
+
+  // Helper function to estimate the cost of given partitioning.
+  auto costFn = [this, limit](Cost acc, size_t beg, int64_t prevBp, int64_t bp,
+                              size_t end, Separator sep) -> Cost {
+    if (end - bp > limit) {
+      return INF;
+    }
+
+    Cost sepPenalty = sep == Separator::EOS     ? config_.eosCost
+                      : sep == Separator::PAUSE ? config_.pauseCost
+                      : sep == Separator::WHITE ? config_.whiteCost
+                                                : 0;
+
+    int64_t rightmostRangeLength = end - bp;
+    int64_t prevRangeLength = bp - prevBp;
+
+    int64_t latency = std::max(static_cast<int64_t>(0),
+                               rightmostRangeLength - prevRangeLength);
+    int64_t discount =
+        config_.tokenDiscountFactor *
+        std::max(static_cast<int64_t>(0), config_.tokenDiscountRange - bp - 1);
+
+    return acc +
+           static_cast<Cost>(latency * discount / config_.tokenDiscountRange) +
+           sepPenalty;
+  };
+
+  for (size_t i = 0; i < n; ++i) {
+    auto &[bestCost, prevBpIdx] = dp[i];
+
+    bestCost = costFn(0, 0, -1, -1, i + 1, Separator::NO_SEP);
+
+    for (auto *q : {&eosPoints, &pausePoints, &whitePoints}) {
+      while (!q->empty() && q->front() + limit < i) {
+        q->pop_front();
+      }
+
+      Separator sep = q == &eosPoints     ? Separator::EOS
+                      : q == &pausePoints ? Separator::PAUSE
+                                          : Separator::WHITE;
+      for (size_t breakIdx : (*q)) {
+        auto cost = costFn(dp[breakIdx].first, 0, dp[breakIdx].second, breakIdx,
+                           i, sep);
+        if (cost < bestCost && breakIdx > 0) {
+          bestCost = cost;
+          prevBpIdx = breakIdx;
+        }
+      }
+    }
+
+    char32_t c = input[i];
+    if (constants::kEndOfSentenceCharacters.contains(c)) {
+      eosPoints.push_back(i);
+    } else if (constants::kPauseCharacters.contains(c)) {
+      pausePoints.push_back(i);
+    } else if (c < 256 && std::isspace(static_cast<char>(c))) {
+      whitePoints.push_back(i);
+    }
+  }
+
+  std::vector<std::pair<size_t, size_t>> segments;
+  int64_t currBp = dp.back().second;
+  size_t lastIdx = n;
+
+  // Backtracking
+  while (currBp != -1) {
+    size_t start = static_cast<size_t>(currBp + 1);
+    segments.emplace_back(start, lastIdx - start);
+    lastIdx = currBp + 1;
+    currBp = dp[currBp].second;
+  }
+  segments.emplace_back(0, lastIdx);
+
+  // Because of backtracking, the segments are placed in reversed order.
+  std::ranges::reverse(segments);
+
+  return {input, std::move(segments)};
+}
+
+} // namespace rnexecutorch::models::text_to_speech
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/TextPartitioner.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/TextPartitioner.h
new file mode 100644
index 0000000000..e3491e70c6
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/TextPartitioner.h
@@ -0,0 +1,94 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace rnexecutorch::models::text_to_speech {
+
+// Controls the behavior of partitioning algorithm.
+struct TextPartitionerConfig {
+  /**
+   * Penalty applied when splitting at an end-of-sentence breakpoint (e.g., '.',
+   * '!', '?'). Lower values make the algorithm prefer splitting at these
+   * points.
+   */
+  uint64_t eosCost = 5;
+
+  /**
+   * Penalty applied when splitting at a mid-sentence pause breakpoint (e.g.,
+   * ',', ';', ':'). Lower values make the algorithm prefer splitting at these
+   * points.
+   */
+  uint64_t pauseCost = 18;
+
+  /**
+   * Penalty applied when splitting at a whitespace breakpoint.
+   * Lower values make the algorithm prefer splitting at these points.
+   */
+  uint64_t whiteCost = 1000;
+
+  /**
+   * Decides on how much more are big latencies in the beginning phase of
+   * an input text penalized.
+   */
+  int64_t tokenDiscountFactor = 1;
+
+  /**
+   * Decides on how quickly latency penalties (linearly interpolated) evaporate
+   * with each processed token.
+   * For example, using tokenDiscountRange = 128 means that after reaching
+   * 128 tokens, the latency is completely omitted and not penalized.
+   */
+  int64_t tokenDiscountRange = 128;
+};
+
+// Main partitioning mechanism.
+class TextPartitioner {
+public:
+  /**
+   * Represents the logical separator types.
+   */
+  enum class Separator {
+    EOS = 1, // End of sentence marker (e.g., '.', '!', '?').
+    PAUSE,   // Mid-sentence pause (e.g., ',', ';', ':').
+    WHITE,   // Whitespace or other weak separators.
+
+    NO_SEP // No separation
+  };
+
+  /**
+   * Represents a heuristic evaluation of given partition.
+   * The lower it is, the better partition is.
+   */
+  using Cost = uint64_t;
+
+  /**
+   * Holds the result of text partitioning.
+   * The content is stored as logical views to avoid copying. Segments
+   * defines ranges of the content views for smaller segments.
+   */
+  struct Partition {
+    std::u32string_view content;
+    std::vector<std::pair<size_t, size_t>>
+        segments; // Pairs of {offset, length} for each segment.
+  };
+
+  TextPartitioner(const TextPartitionerConfig &config);
+
+  /**
+   * Partitions the input text into segments.
+   *
+   * @param input The source text to be partitioned.
+   * @param limit The maximum available size of a single segment.
+   * @return A Partition object containing the original content view and
+   * breakpoints.
+   */
+  Partition partition(std::u32string_view input, size_t limit) const;
+
+private:
+  TextPartitionerConfig config_;
+};
+
+} // namespace rnexecutorch::models::text_to_speech
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/Utils.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/Utils.cpp
new file mode 100644
index 0000000000..44ddb4d909
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/Utils.cpp
@@ -0,0 +1,69 @@
+#include "Utils.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace rnexecutorch::models::text_to_speech::utils {
+
+namespace {
+
+float normalize(float sample, float silenceThreshold) {
+  return std::max(0.0F, std::abs(sample) - silenceThreshold);
+}
+
+template <bool reverse>
+size_t findAudioBound(std::span<const float> audio, uint32_t croppingSteps,
+                      float silenceThreshold) {
+  if (audio.empty()) {
+    return 0;
+  }
+
+  const size_t length = audio.size();
+  float windowSum = 0.0F;
+  size_t processedCount = 0;
+  size_t currentIndex = reverse ? length - 1 : 0;
+
+  while (processedCount < length) {
+    processedCount++;
+    windowSum += normalize(audio[currentIndex], silenceThreshold);
+
+    // Maintain the sliding window sum
+    if (processedCount > croppingSteps) {
+      const size_t oldIndex =
+          reverse ? currentIndex + croppingSteps : currentIndex - croppingSteps;
+      windowSum -= normalize(audio[oldIndex], silenceThreshold);
+    }
+
+    // Check if moving average exceeds threshold
+    if (processedCount >= croppingSteps &&
+        (windowSum / croppingSteps) >= silenceThreshold) {
+      return currentIndex;
+    }
+
+    currentIndex += reverse ? -1 : 1;
+  }
+
+  return reverse ? 0 : length - 1;
+}
+
+} // namespace
+
+std::span<const float> stripAudio(std::span<const float> audio, size_t margin,
+                                  uint32_t croppingSteps,
+                                  float silenceThreshold) {
+  if (audio.empty()) {
+    return {};
+  }
+
+  size_t lbound = findAudioBound<false>(audio, croppingSteps, silenceThreshold);
+  size_t rbound = findAudioBound<true>(audio, croppingSteps, silenceThreshold);
+
+  // Apply margins
+  lbound = (lbound > margin) ? lbound - margin : 0;
+  rbound = std::min(rbound + margin, audio.size() - 1);
+
+  const size_t strippedLength = (rbound >= lbound) ? (rbound - lbound + 1) : 0;
+  return audio.subspan(lbound, strippedLength);
+}
+
+} // namespace rnexecutorch::models::text_to_speech::utils
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/Utils.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/Utils.h
new file mode 100644
index 0000000000..3c4be04649
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/common/Utils.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <cstdint>
+#include <span>
+
+namespace rnexecutorch::models::text_to_speech::utils {
+
+/**
+ * Strips silence from audio edges using a sliding-window moving average.
+ * @param audio The input audio samples.
+ * @param margin Number of silence samples to preserve at each edge.
+ * @param croppingSteps Number of steps in the moving average window.
+ * @param silenceThreshold Amplitude threshold below which audio is considered
+ * silence.
+ */
+std::span<const float> stripAudio(std::span<const float> audio,
+                                  size_t margin = 0,
+                                  uint32_t croppingSteps = 10,
+                                  float silenceThreshold = 0.005F);
+
+} // namespace rnexecutorch::models::text_to_speech::utils
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Constants.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Constants.h
index 21f0e11501..5e35f2dbdf 100644
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Constants.h
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Constants.h
@@ -36,24 +36,6 @@ inline constexpr int32_t kSamplingRate =
     24000; // Corresponds to Kokoro's model audio frequency
 inline constexpr int32_t kSamplesPerMilisecond = kSamplingRate / 1000;
 
-// Special text characters
-inline const std::unordered_set<char32_t> kEndOfSentenceCharacters = {
-    U'.', U'?', U'!', U';',
-    U'…', // Ellipsis
-    U'|', // ASCII Pipe (often used as Hindi Purna Viram)
-    U'।', // Hindi Purna Viram (U+0964)
-    U'॥', // Hindi Deergh Viram (U+0965)
-    U'¿', // Spanish Inverted Question Mark (U+00BF)
-    U'¡', // Spanish Inverted Exclamation Mark (U+00A1)
-};
-
-inline const std::unordered_set<char32_t> kPauseCharacters = {
-    U',', U':', U'-',
-    U'—', // Em Dash (U+2014)
-    U'«', // Left Guillemet (U+00AB)
-    U'»', // Right Guillemet (U+00BB)
-};
-
 // Phoneme to token mappings
 inline constexpr int32_t kVocabSize = 178;
 inline const std::unordered_map<char32_t, Token> kVocab = {
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.cpp
index aa8486c276..18774e4ded 100644
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.cpp
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.cpp
@@ -2,6 +2,9 @@
 #include "Params.h"
 #include "Utils.h"
 
+#include "../common/Constants.h"
+#include "../common/Utils.h"
+
 #include <algorithm>
 #include <fstream>
 #include <phonemis/utils/strings.h>
@@ -12,6 +15,9 @@
 
 namespace rnexecutorch::models::text_to_speech::kokoro {
 
+namespace common_constants = ::rnexecutorch::models::text_to_speech::constants;
+namespace common_utils = ::rnexecutorch::models::text_to_speech::utils;
+
 Kokoro::Kokoro(const std::string &lang, const std::string &taggerDataSource,
                const std::string &lexiconSource,
                const std::string &neuralModelSource,
@@ -36,6 +42,13 @@ Kokoro::Kokoro(const std::string &lang, const std::string &taggerDataSource,
                       neuralModelSource.empty()
                           ? std::nullopt
                           : std::make_optional(neuralModelSource)}}),
+      partitioner_(TextPartitionerConfig{
+          .eosCost = params::partitioning::kEosCost,
+          .pauseCost = params::partitioning::kPauseCost,
+          .whiteCost = params::partitioning::kWhiteCost,
+          .tokenDiscountFactor = params::partitioning::kTokenDiscountFactor,
+          .tokenDiscountRange = params::partitioning::kTokenDiscountRange,
+      }),
       durationPredictor_(durationPredictorSource, context_, callInvoker_),
       synthesizer_(synthesizerSource, context_, callInvoker_) {
   // Populate the voice array by reading given file
@@ -119,8 +132,7 @@ std::vector<float> Kokoro::generate(std::u32string input, float speed,
 
   // Divide the phonemes string into substrings, minimizing the amount of
   // breaks.
-  auto partition = partitioner_.partition(phonemes, context_.inputTokensLimit,
-                                          Partitioner::Mode::MIN_BREAKS);
+  auto partition = partitioner_.partition(phonemes, context_.inputTokensLimit);
 
   std::vector<float> audio = {};
   for (const auto &[offset, length] : partition.segments) {
@@ -200,8 +212,9 @@ void Kokoro::stream(std::shared_ptr<jsi::Function> callback, float speed,
           std::min(inputTextBuffer_.size(), params::kMaxTextSize);
       auto eosIt = std::find_first_of(
           inputTextBuffer_.rbegin() + (inputTextBuffer_.size() - searchLimit),
-          inputTextBuffer_.rend(), constants::kEndOfSentenceCharacters.begin(),
-          constants::kEndOfSentenceCharacters.end());
+          inputTextBuffer_.rend(),
+          common_constants::kEndOfSentenceCharacters.begin(),
+          common_constants::kEndOfSentenceCharacters.end());
       size_t chunkSize = (eosIt != inputTextBuffer_.rend())
                              ? std::distance(eosIt, inputTextBuffer_.rend())
                              : 0;
@@ -237,8 +250,8 @@ void Kokoro::stream(std::shared_ptr<jsi::Function> callback, float speed,
         // Since we do not phonemize the entire input before partitioning, there
         // is a possibility that some segment might exceed the token limit after
         // phonemization. This is being handled later.
-        auto partition = partitioner_.partition(
-            buffer, context_.inputTokensLimit, Partitioner::Mode::MIN_LATENCY);
+        auto partition =
+            partitioner_.partition(buffer, context_.inputTokensLimit);
 
         for (size_t i = 0; i < partition.segments.size(); i++) {
           if (!isStreaming_) {
@@ -406,8 +419,8 @@ std::vector<float> Kokoro::synthesize(std::u32string_view phonemes, float speed,
   }
 
   // Now additional stripping of a (hopefully) pure silence.
-  audio =
-      utils::stripAudio(audio, paddingMs * constants::kSamplesPerMilisecond);
+  audio = common_utils::stripAudio(audio, paddingMs *
+                                              constants::kSamplesPerMilisecond);
 
   return {audio.begin(), audio.end()};
 }
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.h
index ef9fa432b6..cc17f7aac1 100644
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.h
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Kokoro.h
@@ -7,8 +7,8 @@
 #include <string>
 #include <vector>
 
+#include "../common/TextPartitioner.h"
 #include "DurationPredictor.h"
-#include "Partitioner.h"
 #include "Synthesizer.h"
 #include "Types.h"
 #include <phonemis/base/pipeline.h>
@@ -99,7 +99,7 @@ class Kokoro {
   // --- Model Components ---
   // Arranged in order of appearance in the generation pipeline
   phonemis::Pipeline phonemizer_;
-  Partitioner partitioner_;
+  ::rnexecutorch::models::text_to_speech::TextPartitioner partitioner_;
   DurationPredictor durationPredictor_;
   Synthesizer synthesizer_;
 
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Params.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Params.h
index 5f61287f02..5419ab09d5 100644
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Params.h
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Params.h
@@ -33,9 +33,16 @@ inline constexpr int32_t kStreamPause = 200;
  * (ms).
  */
 inline const std::unordered_map<char32_t, int32_t> kPauseValues = {
-    {U'.', 375}, {U'?', 500}, {U'!', 250}, {U';', 400}, {U'…', 600}, // Ellipsis
-    {U',', 130}, {U':', 250}, {U'-', 200}, {U'—', 250}, // Em Dash (slightly
-                                                        // longer than hyphen)
+    {U'.', 375},
+    {U'?', 500},
+    {U'!', 250},
+    {U';', 400},
+    {U'…', 600}, // Ellipsis
+    {U',', 130},
+    {U':', 250},
+    {U'-', 200},
+    {U'—', 250}, // Em Dash (slightly
+                 // longer than hyphen)
     {U'|', 375}, // ASCII Pipe (treated as full stop)
     {U'।', 375}, // Hindi Purna Viram
     {U'॥', 500}, // Hindi Deergh Viram (typically longer than Purna Viram)
@@ -53,49 +60,18 @@ inline constexpr int32_t kDefaultPause = 0; // [ms]
 
 // Audio cropping related hyperparameters
 namespace cropping {
-/**
- * The audio cropping algorithm is a moving average variant.
- * This value controls the number of steps in moving average.
- */
 inline constexpr uint32_t kAudioCroppingSteps = 10;
-
-/**
- * Determines silent audio fragments in audio cropping algorithm.
- * The audio fragment is considered as a silence, if the moving average with K
- * steps does not exceed this threshold.
- */
 inline constexpr float kAudioSilenceThreshold = 0.005F;
 } // namespace cropping
 
 // Partitioning related hyperparameters
 namespace partitioning {
-/**
- * Used in latency-focused partitioning variant. Decides on
- * how much more are big latencies in the beginning phase of
- * an input text penalized.
- */
 inline constexpr int64_t kTokenDiscountFactor = 1;
-
-/**
- * Used in latency-focused partitioning variant. Decides on
- * how quickly latency penalties (linearly interpolated) evaporate
- * with each processed token.
- * For example, using kTokenDiscountRange = 128 means that after reaching
- * 128 tokens, the latency is completely omited and not penalized.
- */
 inline constexpr int64_t kTokenDiscountRange = 128;
 
-/**
- * A set of weights used by partition algorithm to penalize dividing sentences
- * on different breakpoints.
- */
-inline constexpr uint64_t kEosMinBreaksCost = 1;
-inline constexpr uint64_t kPauseMinBreaksCost = 3;
-inline constexpr uint64_t kWhiteMinBreaksCost = 1000;
-
-inline constexpr uint64_t kEosMinLatencyCost = 5;
-inline constexpr uint64_t kPauseMinLatencyCost = 18;
-inline constexpr uint64_t kWhiteMinLatencyCost = 1000;
+inline constexpr uint64_t kEosCost = 5;
+inline constexpr uint64_t kPauseCost = 18;
+inline constexpr uint64_t kWhiteCost = 1000;
 
 } // namespace partitioning
 
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Partitioner.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Partitioner.cpp
deleted file mode 100644
index d994d98d74..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Partitioner.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-#include "Partitioner.h"
-#include "Constants.h"
-#include "Params.h"
-
-#include <algorithm>
-#include <deque>
-#include <limits>
-#include <ranges>
-
-namespace rnexecutorch::models::text_to_speech::kokoro {
-
-using namespace params::partitioning;
-
-// Custom infinity definition
-constexpr Partitioner::Cost INF = 1e7;
-
-Partitioner::Partition Partitioner::partition(std::u32string_view input,
-                                              size_t limit, Mode mode) const {
-  if (mode == Mode::MIN_BREAKS) {
-    auto minBreakCostFn = [limit](Cost acc, size_t beg, int64_t prevBp,
-                                  int64_t bp, size_t end,
-                                  Separator sep) -> Cost {
-      if (end - bp > limit) {
-        return INF;
-      }
-
-      Cost sepPenalty = sep == Separator::EOS     ? kEosMinBreaksCost
-                        : sep == Separator::PAUSE ? kPauseMinBreaksCost
-                        : sep == Separator::WHITE ? kWhiteMinBreaksCost
-                                                  : 0;
-
-      return acc + sepPenalty + static_cast<Cost>(end - bp);
-    };
-
-    return partition(input, limit, minBreakCostFn);
-  }
-
-  if (mode == Mode::MIN_LATENCY) {
-    auto minLatencyCostFn = [limit](Cost acc, size_t beg, int64_t prevBp,
-                                    int64_t bp, size_t end,
-                                    Separator sep) -> Cost {
-      if (end - bp > limit) {
-        return INF;
-      }
-
-      Cost sepPenalty = sep == Separator::EOS     ? kEosMinLatencyCost
-                        : sep == Separator::PAUSE ? kPauseMinLatencyCost
-                        : sep == Separator::WHITE ? kWhiteMinLatencyCost
-                                                  : 0;
-
-      int64_t rightmostRangeLength = end - bp;
-      int64_t prevRangeLength = bp - prevBp;
-
-      int64_t latency = std::max(static_cast<int64_t>(0),
-                                 rightmostRangeLength - prevRangeLength);
-      int64_t discount =
-          kTokenDiscountFactor *
-          std::max(static_cast<int64_t>(0), kTokenDiscountRange - bp - 1);
-
-      return acc + static_cast<Cost>(latency * discount / kTokenDiscountRange) +
-             sepPenalty;
-    };
-
-    return partition(input, limit, minLatencyCostFn);
-  }
-
-  return {input, {}};
-}
-
-Partitioner::Partition Partitioner::partition(std::u32string_view input,
-                                              size_t limit,
-                                              CostFn costFn) const {
-  if (input.empty()) {
-    return {input, {}};
-  }
-
-  size_t n = input.size();
-  std::vector<std::pair<Cost, int64_t>> dp(n, {INF, -1});
-
-  std::deque<size_t> eosPoints, pausePoints, whitePoints;
-
-  for (size_t i = 0; i < n; ++i) {
-    auto &[bestCost, prevBpIdx] = dp[i];
-
-    bestCost = costFn(0, 0, -1, -1, i + 1, Separator::NO_SEP);
-
-    for (auto *q : {&eosPoints, &pausePoints, &whitePoints}) {
-      while (!q->empty() && q->front() + limit < i) {
-        q->pop_front();
-      }
-
-      Separator sep = q == &eosPoints     ? Separator::EOS
-                      : q == &pausePoints ? Separator::PAUSE
-                                          : Separator::WHITE;
-      for (size_t breakIdx : (*q)) {
-        auto cost = costFn(dp[breakIdx].first, 0, dp[breakIdx].second, breakIdx,
-                           i, sep);
-        if (cost < bestCost && breakIdx > 0) {
-          bestCost = cost;
-          prevBpIdx = breakIdx;
-        }
-      }
-    }
-
-    char32_t c = input[i];
-    if (constants::kEndOfSentenceCharacters.contains(c)) {
-      eosPoints.push_back(i);
-    } else if (constants::kPauseCharacters.contains(c)) {
-      pausePoints.push_back(i);
-    } else if (c < 256 && std::isspace(static_cast<char>(c))) {
-      whitePoints.push_back(i);
-    }
-  }
-
-  std::vector<std::pair<size_t, size_t>> segments;
-  int64_t currBp = dp.back().second;
-  size_t lastIdx = n;
-
-  while (currBp != -1) {
-    size_t start = static_cast<size_t>(currBp + 1);
-    segments.emplace_back(start, lastIdx - start);
-    lastIdx = currBp + 1;
-    currBp = dp[currBp].second;
-  }
-  // Add the first segment
-  segments.emplace_back(0, lastIdx);
-
-  std::ranges::reverse(segments);
-
-  return {input, std::move(segments)};
-}
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Partitioner.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Partitioner.h
deleted file mode 100644
index 93f2b97c84..0000000000
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Partitioner.h
+++ /dev/null
@@ -1,88 +0,0 @@
-#pragma once
-
-#include "Types.h"
-
-#include <cstdint>
-#include <functional>
-#include <optional>
-#include <string>
-#include <vector>
-
-namespace rnexecutorch::models::text_to_speech::kokoro {
-
-class Partitioner {
-public:
-  /**
-   * Partitioning strategy.
-   * Affects the cost function choice, which changes the way input text is
-   * divided.
-   */
-  enum class Mode {
-    MIN_BREAKS = 0, // Minimizes number of substrings (best quality)
-    MIN_LATENCY =
-        1, // Minimizes the processing latency (best speed - streaming mode)
-  };
-
-  /**
-   * Represents the logical separator types.
-   */
-  enum class Separator {
-    EOS = 1, // End of sentence marker (e.g., '.', '!', '?').
-    PAUSE,   // Mid-sentence pause (e.g., ',', ';', ':').
-    WHITE,   // Whitespace or other weak separators.
-
-    NO_SEP // No separation
-  };
-
-  /**
-   * Represents a heuristic evaluation of given partition.
-   * The lower it is, the better partition is.
-   */
-  using Cost = uint64_t;
-
-  /**
-   * A cost function type to evaluate given partition.
-   *
-   * @param acc Total cost accumulated from previous segments.
-   * @param beg Start index of the current range.
-   * @param prevBp Previous breakpoint index - useful for calculating some
-   * formulas.
-   * @param bp Breakpoint index (the split point, and the last character of the
-   * left-most subrange). -1 if there are no bps.
-   * @param end End index of the current range (inclusive).
-   * @param sep The type of the breakpoint.
-   */
-  using CostFn = std::function<Cost(Cost acc, size_t beg, int64_t prevBp,
-                                    int64_t bp, size_t end, Separator sep)>;
-
-  /**
-   * Holds the result of text partitioning.
-   * The content is stored as logical views to avoid copying. Segments
-   * defines ranges of the content views for smaller segments.
-   */
-  struct Partition {
-    std::u32string_view content;
-    std::vector<std::pair<size_t, size_t>>
-        segments; // Pairs of {offset, length} for each segment.
-  };
-
-  /**
-   * Partitions the input text into segments according to the specified
-   * strategy.
-   *
-   * @param input The source text to be partitioned.
-   * @param limit The maximum available size of a single segment.
-   * @param mode The partitioning strategy to use (defaults to MIN_LATENCY).
-   * @return A Partition object containing the original content view and
-   * breakpoints.
-   */
-  Partition partition(std::u32string_view input, size_t limit,
-                      Mode mode = Mode::MIN_LATENCY) const;
-
-private:
-  // Internal partition implementation that uses a specific cost function.
-  Partition partition(std::u32string_view input, size_t limit,
-                      CostFn costFn) const;
-};
-
-} // namespace rnexecutorch::models::text_to_speech::kokoro
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.cpp
index f1bf7f8d4d..6119bdfe05 100644
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.cpp
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.cpp
@@ -1,72 +1,11 @@
 #include "Utils.h"
 #include "Constants.h"
-#include "Params.h"
 #include <rnexecutorch/Error.h>
 
 #include <algorithm>
-#include <cmath>
 
 namespace rnexecutorch::models::text_to_speech::kokoro::utils {
 
-using namespace params::cropping;
-
-namespace {
-
-float normalize(float sample) {
-  return std::max(0.0F, std::abs(sample) - kAudioSilenceThreshold);
-}
-
-template <bool reverse> size_t findAudioBound(std::span<const float> audio) {
-  if (audio.empty()) {
-    return 0;
-  }
-
-  const size_t length = audio.size();
-  float windowSum = 0.0F;
-  size_t processedCount = 0;
-  size_t currentIndex = reverse ? length - 1 : 0;
-
-  while (processedCount < length) {
-    processedCount++;
-    windowSum += normalize(audio[currentIndex]);
-
-    // Maintain the sliding window sum
-    if (processedCount > kAudioCroppingSteps) {
-      const size_t oldIndex = reverse ? currentIndex + kAudioCroppingSteps
-                                      : currentIndex - kAudioCroppingSteps;
-      windowSum -= normalize(audio[oldIndex]);
-    }
-
-    // Check if moving average exceeds threshold
-    if (processedCount >= kAudioCroppingSteps &&
-        (windowSum / kAudioCroppingSteps) >= kAudioSilenceThreshold) {
-      return currentIndex;
-    }
-
-    currentIndex += reverse ? -1 : 1;
-  }
-
-  return reverse ? 0 : length - 1;
-}
-
-} // namespace
-
-std::span<const float> stripAudio(std::span<const float> audio, size_t margin) {
-  if (audio.empty()) {
-    return {};
-  }
-
-  size_t lbound = findAudioBound<false>(audio);
-  size_t rbound = findAudioBound<true>(audio);
-
-  // Apply margins
-  lbound = (lbound > margin) ? lbound - margin : 0;
-  rbound = std::min(rbound + margin, audio.size() - 1);
-
-  const size_t strippedLength = (rbound >= lbound) ? (rbound - lbound + 1) : 0;
-  return audio.subspan(lbound, strippedLength);
-}
-
 std::vector<Token> tokenize(std::u32string_view phonemes,
                             std::optional<size_t> expectedSize) {
   if (expectedSize.has_value() && expectedSize.value() < 2) {
@@ -104,4 +43,4 @@ std::vector<Token> tokenize(std::u32string_view phonemes,
   return tokens;
 }
 
-} // namespace rnexecutorch::models::text_to_speech::kokoro::utils
+} // namespace rnexecutorch::models::text_to_speech::kokoro::utils
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.h
index c6996a3f40..0a7f0346e8 100644
--- a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.h
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/kokoro/Utils.h
@@ -8,14 +8,6 @@
 
 namespace rnexecutorch::models::text_to_speech::kokoro::utils {
 
-/**
- * Strips silence from audio edges using a sliding window.
- * @param audio The input audio samples.
- * @param margin Number of silence samples to preserve at each edge.
- */
-std::span<const float> stripAudio(std::span<const float> audio,
-                                  size_t margin = 0);
-
 /**
  * Maps phonemes to vocabulary tokens with start/end padding.
  * @param phonemes UTF-32 phoneme sequence.
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Constants.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Constants.h
new file mode 100644
index 0000000000..aa49663bfa
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Constants.h
@@ -0,0 +1,59 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <unordered_set>
+
+namespace rnexecutorch::models::text_to_speech::supertonic::constants {
+
+// --- Audio ----------------------------------------------------------------
+inline constexpr int32_t kSamplingRate = 44100; // ae.sample_rate
+inline constexpr int32_t kSamplesPerMillisecond = kSamplingRate / 1000;
+
+// --- Latent geometry (from tts.json) --------------------------------------
+inline constexpr int32_t kBaseChunkSize = 512;     // ae.base_chunk_size
+inline constexpr int32_t kChunkCompressFactor = 6; // ttl.chunk_compress_factor
+inline constexpr int32_t kLatentDim = 24;          // ttl.latent_dim
+inline constexpr int32_t kSamplesPerLatentFrame =
+    kBaseChunkSize * kChunkCompressFactor; // 3072
+inline constexpr int32_t kLatentChannels =
+    kLatentDim * kChunkCompressFactor; // 144
+
+// --- Style vectors --------------------------------------------------------
+inline constexpr int32_t kStyleTtlTokens = 50;
+inline constexpr int32_t kStyleTtlDim = 256;
+inline constexpr int32_t kStyleTtlSize =
+    kStyleTtlTokens * kStyleTtlDim; // 12800
+inline constexpr int32_t kStyleDpTokens = 8;
+inline constexpr int32_t kStyleDpDim = 16;
+inline constexpr int32_t kStyleDpSize = kStyleDpTokens * kStyleDpDim; // 128
+
+// Channel dim of the text embedding produced by the text encoder.
+inline constexpr int32_t kTextEmbDim = 256;
+
+// --- Inference defaults / limits ------------------------------------------
+inline constexpr int32_t kDefaultTotalSteps = 8;
+inline constexpr int32_t kMinTotalSteps = 1;
+inline constexpr int32_t kMaxTotalSteps = 32;
+inline constexpr float kDefaultSpeed = 1.05F;
+inline constexpr float kMinValidSpeed = 0.7F;
+inline constexpr float kMaxValidSpeed = 2.0F;
+
+// The rotary-position buffer inside vector_estimator caps the latent length
+// (≈ kMaxLatentFrames * kSamplesPerLatentFrame / kSamplingRate seconds).
+inline constexpr size_t kMaxLatentFrames = 1000;
+
+// Text-length bounds of the exported (dynamic-shape) models. Inputs are padded
+// up to kMinTokens or truncated down to kMaxTokens to stay within the range the
+// .pte files were exported for (see scripts/export/export_xnnpack.py).
+inline constexpr size_t kMinTokens = 8;
+inline constexpr size_t kMaxTokens = 256;
+inline constexpr int64_t kPadToken =
+    0; // valid embedding row; masked out anyway
+
+// Unicode indexer: fixed BMP-sized table; entry == -1 means unsupported.
+inline constexpr size_t kIndexerSize = 65536;
+inline constexpr int64_t kUnsupportedIndex = -1;
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic::constants
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/DurationPredictor.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/DurationPredictor.cpp
new file mode 100644
index 0000000000..2d5ddf2480
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/DurationPredictor.cpp
@@ -0,0 +1,49 @@
+#include "DurationPredictor.h"
+#include "Constants.h"
+
+#include <executorch/extension/tensor/tensor.h>
+#include <rnexecutorch/Error.h>
+#include <rnexecutorch/metaprogramming/ContainerHelpers.h>
+
+namespace rnexecutorch::models::text_to_speech::supertonic {
+
+using ::executorch::aten::ScalarType;
+using ::executorch::extension::make_tensor_ptr;
+
+DurationPredictor::DurationPredictor(
+    const std::string &modelSource,
+    std::shared_ptr<react::CallInvoker> callInvoker)
+    : BaseModel(modelSource, callInvoker) {
+  auto shapes = getAllInputShapes("forward");
+  if (shapes.empty()) {
+    throw RnExecutorchError(
+        RnExecutorchErrorCode::UnknownError,
+        "[Supertonic::DurationPredictor] 'forward' method not found");
+  }
+  CHECK_SIZE(shapes, 3);
+}
+
+float DurationPredictor::generate(std::span<Token> ids, std::span<float> mask,
+                                  std::span<float> styleDp, float speed) const {
+  const auto tLen = static_cast<int32_t>(ids.size());
+
+  auto idsTensor = make_tensor_ptr({1, tLen}, ids.data(), ScalarType::Long);
+  auto maskTensor =
+      make_tensor_ptr({1, 1, tLen}, mask.data(), ScalarType::Float);
+  auto styleDpTensor =
+      make_tensor_ptr({1, constants::kStyleDpTokens, constants::kStyleDpDim},
+                      styleDp.data(), ScalarType::Float);
+
+  auto results = forward({idsTensor, styleDpTensor, maskTensor});
+  if (!results.ok()) {
+    throw RnExecutorchError(
+        RnExecutorchErrorCode::InvalidModelOutput,
+        "[Supertonic::DurationPredictor] forward failed, error: " +
+            std::to_string(static_cast<uint32_t>(results.error())));
+  }
+
+  auto durTensor = results->at(0).toTensor();
+  return durTensor.const_data_ptr<float>()[0] / speed;
+}
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/DurationPredictor.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/DurationPredictor.h
new file mode 100644
index 0000000000..adfeeb4cf0
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/DurationPredictor.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <memory>
+#include <span>
+#include <string>
+
+#include <rnexecutorch/models/BaseModel.h>
+
+#include "Types.h"
+
+namespace rnexecutorch::models::text_to_speech::supertonic {
+
+/**
+ * Wraps the duration_predictor submodule.
+ *
+ * Receives token ids, an attention mask, and the duration-predictor
+ * style vector; returns the predicted utterance length in seconds.
+ */
+class DurationPredictor : public BaseModel {
+public:
+  DurationPredictor(const std::string &modelSource,
+                    std::shared_ptr<react::CallInvoker> callInvoker);
+
+  /**
+   * Predicts the duration of the utterance in seconds.
+   *
+   * @param ids      Token ids for the input, shape [tLen].
+   * @param mask     Float attention mask, shape [tLen], 1.0 for valid tokens.
+   * @param styleDp  Duration-predictor style vector, flat (kStyleDpSize).
+   * @param speed    Playback speed multiplier (duration is divided by speed).
+   * @return         Predicted duration in seconds.
+   */
+  float generate(std::span<Token> ids, std::span<float> mask,
+                 std::span<float> styleDp, float speed) const;
+};
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Params.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Params.h
new file mode 100644
index 0000000000..6682030c9a
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Params.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <cstdint>
+#include <unordered_map>
+
+/**
+ * Tunable hyperparameters for the Supertonic pipeline. Mirrors the structure of
+ * the Kokoro params so the streaming/partitioning behaviour is familiar.
+ */
+namespace rnexecutorch::models::text_to_speech::supertonic::params {
+
+// Hard cap on a single synthesis input (characters). The partitioner can
+// handle any length, so this is a safety valve only.
+inline constexpr size_t kMaxTextSize = 2048;
+
+// Max characters per synthesized segment.
+inline constexpr size_t kMaxSegmentChars = 256;
+
+inline constexpr float kDefaultSpeedF = 1.05F;
+inline constexpr int32_t kDefaultStepsI = 8;
+
+// Pause inserted between streaming iterations to avoid busy-spinning.
+inline constexpr int32_t kStreamPause = 200; // [ms]
+
+// Silence appended after a segment based on its terminating punctuation.
+inline const std::unordered_map<char32_t, int32_t> kPauseValues = {
+    {U'.', 300}, {U'?', 400}, {U'!', 300}, {U';', 300}, {U'…', 500},
+    {U',', 120}, {U':', 200}, {U'-', 150}, {U'—', 200},
+}; // [ms]
+
+// Default inter-segment silence (mirrors DEFAULT_SILENCE_DURATION = 0.3 s).
+inline constexpr int32_t kDefaultPause = 300; // [ms]
+
+// Audio cropping (trailing-silence trim) hyperparameters.
+namespace cropping {
+inline constexpr uint32_t kAudioCroppingSteps = 16;
+inline constexpr float kAudioSilenceThreshold = 0.0005F;
+} // namespace cropping
+
+// Partitioning cost weights (identical scheme to Kokoro).
+namespace partitioning {
+inline constexpr int64_t kTokenDiscountFactor = 1;
+inline constexpr int64_t kTokenDiscountRange = 128;
+
+inline constexpr uint64_t kEosCost = 5;
+inline constexpr uint64_t kPauseCost = 18;
+inline constexpr uint64_t kWhiteCost = 1000;
+} // namespace partitioning
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic::params
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Supertonic.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Supertonic.cpp
new file mode 100644
index 0000000000..0ca7f77283
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Supertonic.cpp
@@ -0,0 +1,308 @@
+#include "Supertonic.h"
+#include "Constants.h"
+#include "Params.h"
+
+#include "../common/Constants.h"
+#include "../common/Utils.h"
+
+#include <rnexecutorch/Error.h>
+#include <rnexecutorch/host_objects/JsiConversions.h>
+
+#include <algorithm>
+#include <chrono>
+#include <fstream>
+#include <thread>
+
+namespace rnexecutorch::models::text_to_speech::supertonic {
+
+namespace common_constants = ::rnexecutorch::models::text_to_speech::constants;
+namespace common_utils = ::rnexecutorch::models::text_to_speech::utils;
+
+namespace {
+
+// Returns the last non-space character of a view (for pause selection).
+char32_t lastMeaningfulChar(std::u32string_view s) {
+  for (auto it = s.rbegin(); it != s.rend(); ++it) {
+    if (*it != U' ') {
+      return *it;
+    }
+  }
+  return s.empty() ? U'.' : s.back();
+}
+
+int32_t pauseMsFor(char32_t c) {
+  auto it = params::kPauseValues.find(c);
+  return it != params::kPauseValues.end() ? it->second : params::kDefaultPause;
+}
+
+} // namespace
+
+Supertonic::Supertonic(const std::string &lang,
+                       const std::string &unicodeIndexerSource,
+                       const std::string &durationPredictorSource,
+                       const std::string &textEncoderSource,
+                       const std::string &vectorEstimatorSource,
+                       const std::string &vocoderSource,
+                       const std::string &voiceSource,
+                       std::shared_ptr<react::CallInvoker> callInvoker)
+    : callInvoker_(std::move(callInvoker)),
+      textProcessor_(unicodeIndexerSource, lang),
+      partitioner_(
+          ::rnexecutorch::models::text_to_speech::TextPartitionerConfig{
+              .eosCost = params::partitioning::kEosCost,
+              .pauseCost = params::partitioning::kPauseCost,
+              .whiteCost = params::partitioning::kWhiteCost,
+              .tokenDiscountFactor = params::partitioning::kTokenDiscountFactor,
+              .tokenDiscountRange = params::partitioning::kTokenDiscountRange,
+          }),
+      durationPredictor_(durationPredictorSource, callInvoker_),
+      textEncoder_(textEncoderSource, callInvoker_),
+      vectorEstimator_(vectorEstimatorSource, callInvoker_),
+      vocoder_(vocoderSource, callInvoker_) {
+  loadVoice(voiceSource);
+}
+
+void Supertonic::loadVoice(const std::string &voiceSource) {
+  // Flat little-endian float32 blob: kStyleTtlSize ttl values followed by
+  // kStyleDpSize dp values (see scripts/convert_voice.py).
+  constexpr size_t expectedFloats =
+      constants::kStyleTtlSize + constants::kStyleDpSize;
+  std::ifstream in(voiceSource, std::ios::binary);
+  if (!in) {
+    throw RnExecutorchError(RnExecutorchErrorCode::FileReadFailed,
+                            "[Supertonic::loadVoice] cannot open: " +
+                                voiceSource);
+  }
+  in.seekg(0, std::ios::end);
+  const auto fileSize = static_cast<size_t>(in.tellg());
+  in.seekg(0, std::ios::beg);
+  if (fileSize < expectedFloats * sizeof(float)) {
+    throw RnExecutorchError(
+        RnExecutorchErrorCode::FileReadFailed,
+        "[Supertonic::loadVoice] voice file too small: need " +
+            std::to_string(expectedFloats * sizeof(float)) + " bytes, got " +
+            std::to_string(fileSize));
+  }
+  in.read(reinterpret_cast<char *>(voice_.ttl.data()),
+          constants::kStyleTtlSize * sizeof(float));
+  in.read(reinterpret_cast<char *>(voice_.dp.data()),
+          constants::kStyleDpSize * sizeof(float));
+  if (!in) {
+    throw RnExecutorchError(RnExecutorchErrorCode::FileReadFailed,
+                            "[Supertonic::loadVoice] failed reading voice");
+  }
+}
+
+void Supertonic::validateSpeed(float speed) const {
+  if (speed < constants::kMinValidSpeed) {
+    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
+                            "Supertonic: speed too low (min " +
+                                std::to_string(constants::kMinValidSpeed) +
+                                ")");
+  }
+  if (speed > constants::kMaxValidSpeed) {
+    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
+                            "Supertonic: speed too high (max " +
+                                std::to_string(constants::kMaxValidSpeed) +
+                                ")");
+  }
+}
+
+std::vector<float> Supertonic::synthesize(std::u32string_view text, float speed,
+                                          int32_t totalSteps,
+                                          std::string_view lang,
+                                          size_t paddingMs) {
+  // 1. Preprocess + tokenize.
+  TokenizedText tok = textProcessor_.process(text, lang);
+  if (tok.ids.empty()) {
+    return {};
+  }
+  if (tok.ids.size() > constants::kMaxTokens) {
+    tok.ids.resize(constants::kMaxTokens);
+    tok.mask.resize(constants::kMaxTokens);
+  } else if (tok.ids.size() < constants::kMinTokens) {
+    tok.ids.resize(constants::kMinTokens, constants::kPadToken);
+    tok.mask.resize(constants::kMinTokens, 0.0F);
+  }
+  const auto tLen = static_cast<int32_t>(tok.ids.size());
+
+  // 2. Duration predictor.
+  float durationSec =
+      durationPredictor_.generate(tok.ids, tok.mask, voice_.dp, speed);
+  if (!(durationSec > 0.0F)) {
+    return {};
+  }
+
+  // 3. Text encoder.
+  auto textEmb = textEncoder_.generate(tok.ids, tok.mask, voice_.ttl);
+
+  // 4. Vector estimator (flow-matching Euler loop with latent geometry).
+  auto latent = vectorEstimator_.generate(textEmb, tLen, voice_.ttl, tok.mask,
+                                          tLen, durationSec, totalSteps);
+
+  // 5. Vocoder.
+  auto wav = vocoder_.generate(latent.xt, constants::kLatentChannels, latent.L);
+
+  // 6. Crop to the predicted duration, then strip trailing silence.
+  const auto totalSamples = wav.size();
+  const auto wavLen = static_cast<int64_t>(
+      durationSec * static_cast<double>(constants::kSamplingRate));
+  const size_t cropLen = std::min<size_t>(
+      static_cast<size_t>(std::max<int64_t>(wavLen, 0)), totalSamples);
+  std::span<const float> audio(wav.data(),
+                               cropLen > 0 ? cropLen : totalSamples);
+  audio = common_utils::stripAudio(
+      audio, paddingMs * constants::kSamplesPerMillisecond,
+      params::cropping::kAudioCroppingSteps,
+      params::cropping::kAudioSilenceThreshold);
+  return {audio.begin(), audio.end()};
+}
+
+std::vector<float> Supertonic::generate(std::u32string input, float speed,
+                                        int32_t totalSteps, std::string lang) {
+  validateSpeed(speed);
+  if (input.size() > params::kMaxTextSize) {
+    throw RnExecutorchError(RnExecutorchErrorCode::InvalidUserInput,
+                            "Supertonic: maximum input text size exceeded");
+  }
+  if (input.empty()) {
+    return {};
+  }
+
+  auto partition = partitioner_.partition(input, params::kMaxSegmentChars);
+
+  std::vector<float> audio;
+  for (const auto &[offset, length] : partition.segments) {
+    auto sub = partition.content.substr(offset, length);
+    auto audioPart = synthesize(sub, speed, totalSteps, lang);
+    if (audioPart.empty()) {
+      continue;
+    }
+    const size_t pause =
+        static_cast<size_t>(pauseMsFor(lastMeaningfulChar(sub))) *
+        constants::kSamplesPerMillisecond;
+    audio.insert(audio.end(), std::make_move_iterator(audioPart.begin()),
+                 std::make_move_iterator(audioPart.end()));
+    audio.resize(audio.size() + pause, 0.0F);
+  }
+  return audio;
+}
+
+void Supertonic::stream(std::shared_ptr<jsi::Function> callback, float speed,
+                        int32_t totalSteps, bool stopOnEmptyBuffer,
+                        std::string lang) {
+  validateSpeed(speed);
+
+  auto nativeCallback = [this, callback](std::vector<float> audioVec) {
+    if (this->isStreaming_) {
+      this->callInvoker_->invokeAsync(
+          [callback, audioVec = std::move(audioVec)](jsi::Runtime &rt) {
+            callback->call(
+                rt, rnexecutorch::jsi_conversion::getJsiValue(audioVec, rt));
+          });
+    }
+  };
+
+  isStreaming_ = true;
+  stopOnEmptyBuffer_ = stopOnEmptyBuffer;
+  flushPending_ = false;
+
+  while (isStreaming_) {
+    std::u32string input;
+    {
+      std::scoped_lock<std::mutex> lock(inputTextBufferMutex_);
+      if (inputTextBuffer_.empty() && stopOnEmptyBuffer_) {
+        break;
+      }
+
+      // Find the most recent end-of-sentence character within the window.
+      size_t searchLimit =
+          std::min(inputTextBuffer_.size(), params::kMaxTextSize);
+      auto eosIt = std::find_first_of(
+          inputTextBuffer_.rbegin() + (inputTextBuffer_.size() - searchLimit),
+          inputTextBuffer_.rend(),
+          common_constants::kEndOfSentenceCharacters.begin(),
+          common_constants::kEndOfSentenceCharacters.end());
+      size_t chunkSize = (eosIt != inputTextBuffer_.rend())
+                             ? std::distance(eosIt, inputTextBuffer_.rend())
+                             : 0;
+
+      // Hold back partial content until an EOS arrives, unless a flush/stop
+      // asked us to drain the tail.
+      if (chunkSize == 0 && flushPending_.load()) {
+        chunkSize = searchLimit;
+      }
+      if (chunkSize > 0) {
+        input = inputTextBuffer_.substr(0, chunkSize);
+        inputTextBuffer_.erase(0, chunkSize);
+        if (inputTextBuffer_.empty()) {
+          flushPending_ = false;
+        }
+      }
+    }
+
+    if (!input.empty()) {
+      auto partition = partitioner_.partition(input, params::kMaxSegmentChars);
+      for (const auto &[offset, length] : partition.segments) {
+        if (!isStreaming_) {
+          break;
+        }
+        auto sub = partition.content.substr(offset, length);
+        auto audioPart = synthesize(sub, speed, totalSteps, lang);
+        if (audioPart.empty()) {
+          continue;
+        }
+        const size_t pause =
+            static_cast<size_t>(pauseMsFor(lastMeaningfulChar(sub))) *
+            constants::kSamplesPerMillisecond;
+        audioPart.resize(audioPart.size() + pause, 0.0F);
+        nativeCallback(std::move(audioPart));
+      }
+    }
+
+    if (isStreaming_) {
+      std::this_thread::sleep_for(
+          std::chrono::milliseconds(params::kStreamPause));
+    }
+  }
+
+  {
+    std::scoped_lock<std::mutex> lock(inputTextBufferMutex_);
+    inputTextBuffer_.clear();
+    isStreaming_ = false;
+    flushPending_ = false;
+  }
+}
+
+void Supertonic::streamInsert(std::u32string chunk) noexcept {
+  std::scoped_lock<std::mutex> lock(inputTextBufferMutex_);
+  inputTextBuffer_.append(chunk);
+}
+
+void Supertonic::streamFlush() noexcept { flushPending_ = true; }
+
+void Supertonic::streamStop(bool instant) noexcept {
+  if (instant) {
+    isStreaming_ = false;
+  } else {
+    flushPending_ = true;
+    stopOnEmptyBuffer_ = true;
+  }
+}
+
+std::size_t Supertonic::getMemoryLowerBound() const noexcept {
+  return durationPredictor_.getMemoryLowerBound() +
+         textEncoder_.getMemoryLowerBound() +
+         vectorEstimator_.getMemoryLowerBound() +
+         vocoder_.getMemoryLowerBound() + textProcessor_.getMemoryLowerBound() +
+         sizeof(voice_);
+}
+
+void Supertonic::unload() noexcept {
+  durationPredictor_.unload();
+  textEncoder_.unload();
+  vectorEstimator_.unload();
+  vocoder_.unload();
+}
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Supertonic.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Supertonic.h
new file mode 100644
index 0000000000..b93e6f6057
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Supertonic.h
@@ -0,0 +1,108 @@
+#pragma once
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+
+#include "../common/TextPartitioner.h"
+#include "DurationPredictor.h"
+#include "Params.h"
+#include "TextEncoder.h"
+#include "TextProcessor.h"
+#include "Types.h"
+#include "VectorEstimator.h"
+#include "Vocoder.h"
+#include <rnexecutorch/metaprogramming/ConstructorHelpers.h>
+
+namespace rnexecutorch {
+namespace models::text_to_speech::supertonic {
+
+using namespace facebook;
+
+class Supertonic {
+public:
+  Supertonic(const std::string &lang, const std::string &unicodeIndexerSource,
+             const std::string &durationPredictorSource,
+             const std::string &textEncoderSource,
+             const std::string &vectorEstimatorSource,
+             const std::string &vocoderSource, const std::string &voiceSource,
+             std::shared_ptr<react::CallInvoker> callInvoker);
+
+  /**
+   * Synthesizes the full input in one pass.
+   * @param input UTF-32 text to synthesize.
+   * @param speed playback speed multiplier.
+   * @param totalSteps flow-matching steps (quality/latency trade-off).
+   * @param lang language-token code for this call (e.g. "en", "na"); empty
+   *        falls back to the default provided at construction. Changing it
+   *        needs no model reload.
+   */
+  std::vector<float> generate(std::u32string input,
+                              float speed = params::kDefaultSpeedF,
+                              int32_t totalSteps = params::kDefaultStepsI,
+                              std::string lang = "");
+
+  /**
+   * Streams synthesis of the internal buffer, invoking `callback` per segment.
+   * The buffer can grow during streaming via `streamInsert`.
+   * @param lang language-token code for this streaming session (empty → the
+   *        construction default).
+   */
+  void stream(std::shared_ptr<jsi::Function> callback,
+              float speed = params::kDefaultSpeedF,
+              int32_t totalSteps = params::kDefaultStepsI,
+              bool stopOnEmptyBuffer = false, std::string lang = "");
+
+  void streamInsert(std::u32string chunk) noexcept;
+  void streamFlush() noexcept;
+  void streamStop(bool instant) noexcept;
+
+  std::size_t getMemoryLowerBound() const noexcept;
+  void unload() noexcept;
+
+private:
+  void loadVoice(const std::string &voiceSource);
+
+  // Runs the four submodules for one already-partitioned text segment and
+  // returns the cropped PCM audio.
+  std::vector<float> synthesize(std::u32string_view text, float speed,
+                                int32_t totalSteps, std::string_view lang,
+                                size_t paddingMs = 40);
+
+  void validateSpeed(float speed) const;
+
+  // --- External dependencies ---
+  std::shared_ptr<react::CallInvoker> callInvoker_;
+
+  // --- Pipeline components (in order of use) ---
+  TextProcessor textProcessor_;
+  TextPartitioner partitioner_;
+  DurationPredictor durationPredictor_;
+  TextEncoder textEncoder_;
+  VectorEstimator vectorEstimator_;
+  Vocoder vocoder_;
+
+  // --- Voice ---
+  Voice voice_;
+
+  // --- Streaming buffer & control ---
+  std::u32string inputTextBuffer_;
+  mutable std::mutex inputTextBufferMutex_;
+  std::atomic<bool> isStreaming_{false};
+  std::atomic<bool> stopOnEmptyBuffer_{true};
+  std::atomic<bool> flushPending_{false};
+};
+
+} // namespace models::text_to_speech::supertonic
+
+REGISTER_CONSTRUCTOR(models::text_to_speech::supertonic::Supertonic,
+                     std::string, std::string, std::string, std::string,
+                     std::string, std::string, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+
+} // namespace rnexecutorch
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/TextEncoder.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/TextEncoder.cpp
new file mode 100644
index 0000000000..132e63f1ab
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/TextEncoder.cpp
@@ -0,0 +1,50 @@
+#include "TextEncoder.h"
+#include "Constants.h"
+
+#include <executorch/extension/tensor/tensor.h>
+#include <rnexecutorch/Error.h>
+#include <rnexecutorch/metaprogramming/ContainerHelpers.h>
+
+namespace rnexecutorch::models::text_to_speech::supertonic {
+
+using ::executorch::aten::ScalarType;
+using ::executorch::extension::make_tensor_ptr;
+
+TextEncoder::TextEncoder(const std::string &modelSource,
+                         std::shared_ptr<react::CallInvoker> callInvoker)
+    : BaseModel(modelSource, callInvoker) {
+  auto shapes = getAllInputShapes("forward");
+  if (shapes.empty()) {
+    throw RnExecutorchError(
+        RnExecutorchErrorCode::UnknownError,
+        "[Supertonic::TextEncoder] 'forward' method not found");
+  }
+  CHECK_SIZE(shapes, 3);
+}
+
+std::vector<float> TextEncoder::generate(std::span<Token> ids,
+                                         std::span<float> mask,
+                                         std::span<float> styleTtl) const {
+  const auto tLen = static_cast<int32_t>(ids.size());
+
+  auto idsTensor = make_tensor_ptr({1, tLen}, ids.data(), ScalarType::Long);
+  auto maskTensor =
+      make_tensor_ptr({1, 1, tLen}, mask.data(), ScalarType::Float);
+  auto styleTtlTensor =
+      make_tensor_ptr({1, constants::kStyleTtlTokens, constants::kStyleTtlDim},
+                      styleTtl.data(), ScalarType::Float);
+
+  auto results = forward({idsTensor, styleTtlTensor, maskTensor});
+  if (!results.ok()) {
+    throw RnExecutorchError(
+        RnExecutorchErrorCode::InvalidModelOutput,
+        "[Supertonic::TextEncoder] forward failed, error: " +
+            std::to_string(static_cast<uint32_t>(results.error())));
+  }
+
+  auto textEmbTensor = results->at(0).toTensor();
+  return {textEmbTensor.const_data_ptr<float>(),
+          textEmbTensor.const_data_ptr<float>() + textEmbTensor.numel()};
+}
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/TextEncoder.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/TextEncoder.h
new file mode 100644
index 0000000000..bbaef87eab
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/TextEncoder.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <memory>
+#include <span>
+#include <string>
+#include <vector>
+
+#include <rnexecutorch/models/BaseModel.h>
+
+#include "Types.h"
+
+namespace rnexecutorch::models::text_to_speech::supertonic {
+
+/**
+ * Wraps the text_encoder submodule.
+ *
+ * Encodes token ids together with the text-to-latent style vector into
+ * a text embedding. The output is copied to host memory so it remains
+ * valid across the vector-estimator flow loop.
+ */
+class TextEncoder : public BaseModel {
+public:
+  TextEncoder(const std::string &modelSource,
+              std::shared_ptr<react::CallInvoker> callInvoker);
+
+  /**
+   * Produces a text embedding from token ids and style.
+   *
+   * @param ids       Token ids for the input, shape [tLen].
+   * @param mask      Float attention mask, shape [tLen], 1.0 for valid tokens.
+   * @param styleTtl  Text-to-latent style vector, flat (kStyleTtlSize).
+   * @return          Flat text embedding vector of shape kTextEmbDim × tLen.
+   */
+  std::vector<float> generate(std::span<Token> ids, std::span<float> mask,
+                              std::span<float> styleTtl) const;
+};
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/TextProcessor.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/TextProcessor.cpp
new file mode 100644
index 0000000000..eaab58161f
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/TextProcessor.cpp
@@ -0,0 +1,215 @@
+#include "TextProcessor.h"
+#include "Constants.h"
+
+#include <rnexecutorch/Error.h>
+
+#include <algorithm>
+#include <array>
+#include <fstream>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+#include <nlohmann/json.hpp>
+
+namespace rnexecutorch::models::text_to_speech::supertonic {
+
+namespace {
+
+// --- 1. Emoji removal -----------------------------------------------------
+
+bool isEmoji(char32_t c) {
+  return (c >= 0x1F600 && c <= 0x1F64F) || (c >= 0x1F300 && c <= 0x1F5FF) ||
+         (c >= 0x1F680 && c <= 0x1F6FF) || (c >= 0x1F700 && c <= 0x1F77F) ||
+         (c >= 0x1F780 && c <= 0x1F7FF) || (c >= 0x1F800 && c <= 0x1F8FF) ||
+         (c >= 0x1F900 && c <= 0x1F9FF) || (c >= 0x1FA00 && c <= 0x1FA6F) ||
+         (c >= 0x1FA70 && c <= 0x1FAFF) || (c >= 0x2600 && c <= 0x26FF) ||
+         (c >= 0x2700 && c <= 0x27BF) || (c >= 0x1F1E6 && c <= 0x1F1FF);
+}
+
+// --- 3/4. Symbol normalization & decorative removal -----------------------
+
+const std::unordered_map<char32_t, char32_t> &symbolReplacements() {
+  static const std::unordered_map<char32_t, char32_t> m = {
+      {U'–', U'-'},  {U'‑', U'-'}, {U'—', U'-'},  {U'¯', U' '},  {U'_', U' '},
+      {U'“', U'"'},  {U'”', U'"'}, {U'‘', U'\''}, {U'’', U'\''}, {U'´', U'\''},
+      {U'`', U'\''}, {U'[', U' '}, {U']', U' '},  {U'|', U' '},  {U'/', U' '},
+      {U'#', U' '},  {U'→', U' '}, {U'←', U' '},
+  };
+  return m;
+}
+
+const std::unordered_set<char32_t> &specialSymbols() {
+  static const std::unordered_set<char32_t> s = {U'♥', U'☆', U'♡', U'©', U'\\'};
+  return s;
+}
+
+// --- helpers --------------------------------------------------------------
+
+void replaceAll(std::u32string &s, std::u32string_view from,
+                std::u32string_view to) {
+  if (from.empty()) {
+    return;
+  }
+  size_t pos = 0;
+  while ((pos = s.find(from, pos)) != std::u32string::npos) {
+    s.replace(pos, from.size(), to);
+    pos += to.size();
+  }
+}
+
+bool isAsciiSpace(char32_t c) {
+  return c == U' ' || c == U'\t' || c == U'\n' || c == U'\r' || c == U'\f' ||
+         c == U'\v';
+}
+
+const std::unordered_set<char32_t> &endingPunctuation() {
+  static const std::unordered_set<char32_t> s = {
+      U'.', U'!', U'?',  U';',  U':',  U',',  U'\'', U'"',  U')', U']',
+      U'}', U'…', U'。', U'」', U'』', U'】', U'〉', U'》', U'›', U'»'};
+  return s;
+}
+
+} // namespace
+
+TextProcessor::TextProcessor(const std::string &indexerSource,
+                             std::string defaultLang)
+    : defaultLang_(std::move(defaultLang)) {
+  loadIndexer(indexerSource);
+}
+
+void TextProcessor::loadIndexer(const std::string &indexerSource) {
+  std::ifstream in(indexerSource, std::ios::binary);
+  if (!in) {
+    throw RnExecutorchError(
+        RnExecutorchErrorCode::FileReadFailed,
+        "[Supertonic::TextProcessor] cannot open indexer: " + indexerSource);
+  }
+  nlohmann::json j;
+  try {
+    in >> j;
+  } catch (const std::exception &e) {
+    throw RnExecutorchError(
+        RnExecutorchErrorCode::InvalidUserInput,
+        std::string("[Supertonic::TextProcessor] malformed indexer json: ") +
+            e.what());
+  }
+  if (!j.is_array() || j.empty()) {
+    throw RnExecutorchError(
+        RnExecutorchErrorCode::InvalidUserInput,
+        "[Supertonic::TextProcessor] indexer must be a non-empty array");
+  }
+  indexer_ = j.get<std::vector<int32_t>>();
+}
+
+TokenizedText TextProcessor::process(std::u32string_view text,
+                                     std::string_view lang) const {
+  // 1. emoji removal, symbol normalization, decorative-symbol removal
+  std::u32string s(text);
+  const auto &repl = symbolReplacements();
+  const auto &special = specialSymbols();
+  std::u32string t;
+  t.reserve(s.size());
+  for (char32_t c : s) {
+    if (isEmoji(c) || special.contains(c)) {
+      continue;
+    }
+    auto it = repl.find(c);
+    t.push_back(it != repl.end() ? it->second : c);
+  }
+  s = std::move(t);
+
+  // 5. abbreviation expansion (order matters, mirrors Python dict order)
+  replaceAll(s, U"@", U" at ");
+  replaceAll(s, U"e.g.,", U"for example, ");
+  replaceAll(s, U"i.e.,", U"that is, ");
+
+  // 6. punctuation-spacing fixes
+  replaceAll(s, U" ,", U",");
+  replaceAll(s, U" .", U".");
+  replaceAll(s, U" !", U"!");
+  replaceAll(s, U" ?", U"?");
+  replaceAll(s, U" ;", U";");
+  replaceAll(s, U" :", U":");
+  replaceAll(s, U" '", U"'");
+
+  // 7. duplicate-quote collapsing (runs of the same ", ' or ` -> one)
+  {
+    std::u32string collapsed;
+    collapsed.reserve(s.size());
+    for (char32_t c : s) {
+      bool isQuote = (c == U'"' || c == U'\'' || c == U'`');
+      if (isQuote && !collapsed.empty() && collapsed.back() == c) {
+        continue;
+      }
+      collapsed.push_back(c);
+    }
+    s = std::move(collapsed);
+  }
+
+  // 8. whitespace cleanup (collapse runs to single space, strip)
+  {
+    std::u32string cleaned;
+    cleaned.reserve(s.size());
+    bool prevSpace = false;
+    for (char32_t c : s) {
+      if (isAsciiSpace(c)) {
+        if (!prevSpace) {
+          cleaned.push_back(U' ');
+        }
+        prevSpace = true;
+      } else {
+        cleaned.push_back(c);
+        prevSpace = false;
+      }
+    }
+    size_t b = cleaned.find_first_not_of(U' ');
+    size_t e = cleaned.find_last_not_of(U' ');
+    s = (b == std::u32string::npos) ? std::u32string()
+                                    : cleaned.substr(b, e - b + 1);
+  }
+
+  // 9. trailing period
+  if (s.empty() || !endingPunctuation().contains(s.back())) {
+    s.push_back(U'.');
+  }
+
+  // 10. language token (per-call lang overrides the construction default)
+  const std::string_view effectiveLang = lang.empty() ? defaultLang_ : lang;
+  if (!effectiveLang.empty()) {
+    std::u32string tag(effectiveLang.begin(), effectiveLang.end()); // ASCII
+    std::u32string wrapped;
+    wrapped.reserve(s.size() + 2 * tag.size() + 5);
+    wrapped.push_back(U'<');
+    wrapped += tag;
+    wrapped.push_back(U'>');
+    wrapped += s;
+    wrapped.push_back(U'<');
+    wrapped.push_back(U'/');
+    wrapped += tag;
+    wrapped.push_back(U'>');
+    s = std::move(wrapped);
+  }
+
+  TokenizedText out;
+  out.ids.reserve(s.size());
+  for (char32_t c : s) {
+    if (c >= constants::kIndexerSize) {
+      continue; // unsupported (astral) codepoint
+    }
+    int32_t id = indexer_[c];
+    if (id == constants::kUnsupportedIndex) {
+      continue; // unsupported codepoint — skip (Python would reject)
+    }
+    out.ids.push_back(static_cast<Token>(id));
+  }
+  out.mask.assign(out.ids.size(), 1.0F);
+
+  return out;
+}
+
+std::size_t TextProcessor::getMemoryLowerBound() const noexcept {
+  return indexer_.size() * sizeof(int32_t);
+}
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/TextProcessor.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/TextProcessor.h
new file mode 100644
index 0000000000..77ef5bb22e
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/TextProcessor.h
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "Types.h"
+
+namespace rnexecutorch::models::text_to_speech::supertonic {
+
+class TextProcessor {
+public:
+  /**
+   * @param indexerSource path to unicode_indexer.json (a flat array of length
+   *        65536; entry -1 means the codepoint is unsupported).
+   * @param defaultLang default language code for the ``<lang>...</lang>``
+   *        wrapper (e.g. "en"; "na" for unknown). Used whenever a per-call
+   *        ``lang`` is not supplied. Empty disables wrapping.
+   */
+  TextProcessor(const std::string &indexerSource, std::string defaultLang);
+
+  /**
+   * Preprocess + tokenize a single text chunk.
+   * @param text  input text.
+   * @param lang  language code for this call; if empty, the default provided at
+   *              construction is used. This is why language can be changed per
+   *              synthesis without reloading the model.
+   * @return token ids (language-token wrapped) and a matching all-ones mask.
+   */
+  TokenizedText process(std::u32string_view text,
+                        std::string_view lang = {}) const;
+
+  /** The default language used when a per-call lang is not supplied. */
+  const std::string &defaultLang() const noexcept { return defaultLang_; }
+
+  std::size_t getMemoryLowerBound() const noexcept;
+
+private:
+  void loadIndexer(const std::string &indexerSource);
+
+  std::vector<int32_t> indexer_; // codepoint -> token id (or -1)
+  std::string defaultLang_;
+};
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Types.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Types.h
new file mode 100644
index 0000000000..9fcc33dd4c
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Types.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "Constants.h"
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace rnexecutorch::models::text_to_speech::supertonic {
+
+// Model input token type (unicode-indexer id).
+using Token = int64_t;
+
+/**
+ * A Supertonic voice.
+ *
+ * Two style vectors drive the two conditioning paths of the model:
+ *   - ttl: text-to-latent style, shape [n_style(50) x style_dim(256)]
+ *   - dp:  duration-predictor style, shape [dp_style_tokens(8) x
+ * dp_style_dim(16)]
+ */
+struct Voice {
+  std::array<float, constants::kStyleTtlSize> ttl{};
+  std::array<float, constants::kStyleDpSize> dp{};
+};
+
+/**
+ * Result of preprocessing + tokenizing one text chunk.
+ *
+ * ``ids`` are the unicode-indexer token ids (already language-token wrapped);
+ * ``mask`` is the all-ones float attention mask of the same length. They are
+ * kept as owning vectors because the ExecuTorch tensors borrow their storage
+ * for the duration of a forward call.
+ */
+struct TokenizedText {
+  std::vector<Token> ids;
+  std::vector<float> mask;
+};
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/VectorEstimator.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/VectorEstimator.cpp
new file mode 100644
index 0000000000..ff80536d88
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/VectorEstimator.cpp
@@ -0,0 +1,107 @@
+#include "VectorEstimator.h"
+#include "Constants.h"
+
+#include <executorch/extension/tensor/tensor.h>
+#include <rnexecutorch/Error.h>
+#include <rnexecutorch/metaprogramming/ContainerHelpers.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+
+namespace rnexecutorch::models::text_to_speech::supertonic {
+
+using ::executorch::aten::ScalarType;
+using ::executorch::extension::make_tensor_ptr;
+
+VectorEstimator::VectorEstimator(
+    const std::string &modelSource,
+    std::shared_ptr<react::CallInvoker> callInvoker)
+    : BaseModel(modelSource, callInvoker) {
+  auto shapes = getAllInputShapes("forward");
+  if (shapes.empty()) {
+    throw RnExecutorchError(
+        RnExecutorchErrorCode::UnknownError,
+        "[Supertonic::VectorEstimator] 'forward' method not found");
+  }
+
+  CHECK_SIZE(shapes, 7);
+}
+
+VectorEstimator::Result
+VectorEstimator::generate(std::span<float> textEmb, int32_t textEmbLen,
+                          std::span<float> styleTtl, std::span<float> mask,
+                          int32_t tLen, float durationSec,
+                          int32_t totalSteps) const {
+  // How many waveform samples each latent frame covers and how many
+  // frames we need for the predicted duration.
+  const int64_t chunk = constants::kSamplesPerLatentFrame;
+  const auto sr = static_cast<double>(constants::kSamplingRate);
+  const auto wavLen = static_cast<int64_t>(durationSec * sr);
+  size_t L = static_cast<size_t>(std::ceil(durationSec * sr / chunk));
+  L = std::clamp<size_t>(L, 1, constants::kMaxLatentFrames);
+  const int32_t channels = constants::kLatentChannels;
+  const int32_t Li = static_cast<int32_t>(L);
+  const size_t latentSize =
+      static_cast<size_t>(channels) * static_cast<size_t>(L);
+
+  // Only the frames that actually produce audio samples are valid;
+  // the remainder is zero-padded for the static model shape.
+  const size_t latentValid =
+      std::min<size_t>(static_cast<size_t>((wavLen + chunk - 1) / chunk),
+                       static_cast<size_t>(L));
+
+  // Mask to silence invalid latent frames during the flow loop.
+  std::vector<float> latentMask(static_cast<size_t>(L), 0.0F);
+  std::fill(latentMask.begin(), latentMask.begin() + latentValid, 1.0F);
+
+  // Seed the latent space with masked Gaussian noise — the flow-matching
+  // process will iteratively transform this into a structured latent.
+  std::normal_distribution<float> gauss(0.0F, 1.0F);
+  std::vector<float> xt(latentSize);
+  for (int32_t c = 0; c < channels; ++c) {
+    for (int32_t i = 0; i < Li; ++i) {
+      xt[static_cast<size_t>(c) * static_cast<size_t>(L) +
+         static_cast<size_t>(i)] =
+          gauss(rng_) * latentMask[static_cast<size_t>(i)];
+    }
+  }
+
+  // Tensors that stay constant across the flow loop.
+  auto xtTensor =
+      make_tensor_ptr({1, channels, Li}, xt.data(), ScalarType::Float);
+  auto textEmbTensor = make_tensor_ptr({1, constants::kTextEmbDim, textEmbLen},
+                                       textEmb.data(), ScalarType::Float);
+  auto styleTtlTensor =
+      make_tensor_ptr({1, constants::kStyleTtlTokens, constants::kStyleTtlDim},
+                      styleTtl.data(), ScalarType::Float);
+  auto maskTensor =
+      make_tensor_ptr({1, 1, tLen}, mask.data(), ScalarType::Float);
+  auto latentMaskTensor =
+      make_tensor_ptr({1, 1, Li}, latentMask.data(), ScalarType::Float);
+
+  // Euler integration: starting from pure noise at step 0, the vector
+  // estimator predicts the velocity field at each step, and the latent
+  // is updated in place until we reach the final step.
+  float totalF = static_cast<float>(totalSteps);
+  auto totalTensor = make_tensor_ptr({1}, &totalF, ScalarType::Float);
+  for (int32_t step = 0; step < totalSteps; ++step) {
+    float curF = static_cast<float>(step);
+    auto curTensor = make_tensor_ptr({1}, &curF, ScalarType::Float);
+    auto results = forward({xtTensor, textEmbTensor, styleTtlTensor, maskTensor,
+                            latentMaskTensor, curTensor, totalTensor});
+    if (!results.ok()) {
+      throw RnExecutorchError(
+          RnExecutorchErrorCode::InvalidModelOutput,
+          "[Supertonic::VectorEstimator] forward failed, error: " +
+              std::to_string(static_cast<uint32_t>(results.error())));
+    }
+    auto out = results->at(0).toTensor();
+    std::memcpy(xt.data(), out.const_data_ptr<float>(),
+                xt.size() * sizeof(float));
+  }
+
+  return {std::move(xt), Li};
+}
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/VectorEstimator.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/VectorEstimator.h
new file mode 100644
index 0000000000..96f168e042
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/VectorEstimator.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <random>
+#include <span>
+#include <string>
+#include <vector>
+
+#include <rnexecutorch/models/BaseModel.h>
+
+namespace rnexecutorch::models::text_to_speech::supertonic {
+
+/**
+ * Wraps the vector_estimator submodule.
+ *
+ * Encapsulates the full flow-matching pipeline: computes latent frame
+ * geometry from the predicted duration, samples masked Gaussian latent
+ * noise, and iteratively refines it through an Euler integration loop.
+ */
+class VectorEstimator : public BaseModel {
+public:
+  struct Result {
+    std::vector<float> xt; // Final latent vector, flat (channels × L).
+    int32_t L;             // Number of latent frames.
+  };
+
+  VectorEstimator(const std::string &modelSource,
+                  std::shared_ptr<react::CallInvoker> callInvoker);
+
+  /**
+   * Computes latent frame geometry from the predicted duration, samples
+   * masked Gaussian noise, and runs the flow-matching Euler loop.
+   *
+   * @param textEmb     Flat text embedding from TextEncoder.
+   * @param textEmbLen  Number of tokens (T axis) in the text embedding.
+   * @param styleTtl    Text-to-latent style vector, flat (kStyleTtlSize).
+   * @param mask        Float attention mask, shape [tLen].
+   * @param tLen        Number of input tokens.
+   * @param durationSec Predicted utterance duration in seconds (from
+   * DurationPredictor).
+   * @param totalSteps  Number of flow-matching Euler steps.
+   * @return            Result with the final latent xt and the number of latent
+   * frames L.
+   */
+  Result generate(std::span<float> textEmb, int32_t textEmbLen,
+                  std::span<float> styleTtl, std::span<float> mask,
+                  int32_t tLen, float durationSec, int32_t totalSteps) const;
+
+private:
+  mutable std::mt19937 rng_{std::random_device{}()};
+};
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Vocoder.cpp b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Vocoder.cpp
new file mode 100644
index 0000000000..cdbab50cfe
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Vocoder.cpp
@@ -0,0 +1,43 @@
+#include "Vocoder.h"
+
+#include <executorch/extension/tensor/tensor.h>
+#include <rnexecutorch/Error.h>
+#include <rnexecutorch/metaprogramming/ContainerHelpers.h>
+
+namespace rnexecutorch::models::text_to_speech::supertonic {
+
+using ::executorch::aten::ScalarType;
+using ::executorch::extension::make_tensor_ptr;
+
+Vocoder::Vocoder(const std::string &modelSource,
+                 std::shared_ptr<react::CallInvoker> callInvoker)
+    : BaseModel(modelSource, callInvoker) {
+  auto shapes = getAllInputShapes("forward");
+  if (shapes.empty()) {
+    throw RnExecutorchError(RnExecutorchErrorCode::UnknownError,
+                            "[Supertonic::Vocoder] 'forward' method not found");
+  }
+  CHECK_SIZE(shapes, 1);
+}
+
+std::vector<float> Vocoder::generate(std::span<float> xt, int32_t channels,
+                                     int32_t L) const {
+  auto xtTensor =
+      make_tensor_ptr({1, channels, L}, xt.data(), ScalarType::Float);
+
+  auto results = forward(std::vector<EValue>{xtTensor});
+  if (!results.ok()) {
+    throw RnExecutorchError(
+        RnExecutorchErrorCode::InvalidModelOutput,
+        "[Supertonic::Vocoder] forward failed, error: " +
+            std::to_string(static_cast<uint32_t>(results.error())));
+  }
+
+  auto wavTensor = results->at(0).toTensor();
+  const auto totalSamples = static_cast<size_t>(wavTensor.numel());
+  const float *wavPtr = wavTensor.const_data_ptr<float>();
+
+  return {wavPtr, wavPtr + totalSamples};
+}
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic
\ No newline at end of file
diff --git a/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Vocoder.h b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Vocoder.h
new file mode 100644
index 0000000000..bda2f66a86
--- /dev/null
+++ b/packages/react-native-executorch/common/rnexecutorch/models/text_to_speech/supertonic/Vocoder.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <span>
+#include <string>
+#include <vector>
+
+#include <rnexecutorch/models/BaseModel.h>
+
+namespace rnexecutorch::models::text_to_speech::supertonic {
+
+/**
+ * Wraps the vocoder submodule.
+ *
+ * Decodes the final latent vector produced by VectorEstimator into
+ * a raw PCM waveform.
+ */
+class Vocoder : public BaseModel {
+public:
+  Vocoder(const std::string &modelSource,
+          std::shared_ptr<react::CallInvoker> callInvoker);
+
+  /**
+   * Decodes a latent vector into a waveform.
+   *
+   * @param xt        Final latent vector from VectorEstimator, flat (channels ×
+   * L).
+   * @param channels  Number of latent channels (kLatentChannels).
+   * @param L         Number of latent frames.
+   * @return          Raw PCM waveform samples.
+   */
+  std::vector<float> generate(std::span<float> xt, int32_t channels,
+                              int32_t L) const;
+};
+
+} // namespace rnexecutorch::models::text_to_speech::supertonic
\ No newline at end of file
diff --git a/packages/react-native-executorch/src/constants/modelRegistry.ts b/packages/react-native-executorch/src/constants/modelRegistry.ts
index 5cbc3d981b..64f963145c 100644
--- a/packages/react-native-executorch/src/constants/modelRegistry.ts
+++ b/packages/react-native-executorch/src/constants/modelRegistry.ts
@@ -28,6 +28,16 @@ import {
   KOKORO_HINDI_MALE_PSI,
   KOKORO_POLISH_MALE_MATEUSZ,
   KOKORO_GERMAN_FEMALE_ANNA,
+  SUPERTONIC_MALE_1,
+  SUPERTONIC_MALE_2,
+  SUPERTONIC_MALE_3,
+  SUPERTONIC_MALE_4,
+  SUPERTONIC_MALE_5,
+  SUPERTONIC_FEMALE_1,
+  SUPERTONIC_FEMALE_2,
+  SUPERTONIC_FEMALE_3,
+  SUPERTONIC_FEMALE_4,
+  SUPERTONIC_FEMALE_5,
 } from './tts/voices';
 import { TextToSpeechModelConfig } from '../types/tts';
 import { RnExecutorchError } from '../errors/errorUtils';
@@ -835,6 +845,20 @@ export const models = {
         anna: tts(KOKORO_GERMAN_FEMALE_ANNA),
       },
     },
+    // Supertonic 3: a single multilingual model; each voice works for any of
+    // the 31 supported languages (set via the config's `lang` field).
+    supertonic: {
+      m1: tts(SUPERTONIC_MALE_1),
+      m2: tts(SUPERTONIC_MALE_2),
+      m3: tts(SUPERTONIC_MALE_3),
+      m4: tts(SUPERTONIC_MALE_4),
+      m5: tts(SUPERTONIC_MALE_5),
+      f1: tts(SUPERTONIC_FEMALE_1),
+      f2: tts(SUPERTONIC_FEMALE_2),
+      f3: tts(SUPERTONIC_FEMALE_3),
+      f4: tts(SUPERTONIC_FEMALE_4),
+      f5: tts(SUPERTONIC_FEMALE_5),
+    },
   },
   text_embedding: {
     all_minilm_l6_v2: base(M.ALL_MINILM_L6_V2),
diff --git a/packages/react-native-executorch/src/constants/tts/models.ts b/packages/react-native-executorch/src/constants/tts/models.ts
index b21595e851..962e12db35 100644
--- a/packages/react-native-executorch/src/constants/tts/models.ts
+++ b/packages/react-native-executorch/src/constants/tts/models.ts
@@ -1,4 +1,4 @@
-import { URL_PREFIX, PREVIOUS_VERSION_TAG } from '../versions';
+import { URL_PREFIX, PREVIOUS_VERSION_TAG, VERSION_TAG } from '../versions';
 
 // Text to speech (tts) - Kokoro model(s)
 const KOKORO_MODEL_ROOT = `${URL_PREFIX}-kokoro/${PREVIOUS_VERSION_TAG}/xnnpack`;
@@ -36,3 +36,22 @@ export const KOKORO_GERMAN = {
   durationPredictorSource: `${KOKORO_GERMAN_MODEL_ROOT}/duration_predictor_de.pte`,
   synthesizerSource: `${KOKORO_GERMAN_MODEL_ROOT}/synthesizer_de.pte`,
 };
+
+// Text to speech (tts) - Supertonic 3 model
+const SUPERTONIC_MODEL_ROOT = `${URL_PREFIX}-supertonic/${VERSION_TAG}/xnnpack`;
+
+/**
+ * Supertonic 3 — a multilingual (31 languages + `na` fallback) flow-matching
+ * TTS. No phonemizer: text is mapped directly through a unicode indexer. Runs
+ * four ExecuTorch submodules in sequence (duration predictor, text encoder,
+ * vector estimator, vocoder) at 44.1 kHz.
+ * @category Models - Text to Speech
+ */
+export const SUPERTONIC = {
+  modelName: 'supertonic' as const,
+  unicodeIndexerSource: `${SUPERTONIC_MODEL_ROOT}/unicode_indexer.json`,
+  durationPredictorSource: `${SUPERTONIC_MODEL_ROOT}/duration_predictor.pte`,
+  textEncoderSource: `${SUPERTONIC_MODEL_ROOT}/text_encoder.pte`,
+  vectorEstimatorSource: `${SUPERTONIC_MODEL_ROOT}/vector_estimator.pte`,
+  vocoderSource: `${SUPERTONIC_MODEL_ROOT}/vocoder.pte`,
+};
diff --git a/packages/react-native-executorch/src/constants/tts/voices.ts b/packages/react-native-executorch/src/constants/tts/voices.ts
index 4bf9c4f80d..99f8969f2d 100644
--- a/packages/react-native-executorch/src/constants/tts/voices.ts
+++ b/packages/react-native-executorch/src/constants/tts/voices.ts
@@ -1,9 +1,15 @@
 import { TextToSpeechModelConfig } from '../../types/tts';
-import { PREVIOUS_VERSION_TAG, URL_PREFIX } from '../versions';
-import { KOKORO_STANDARD, KOKORO_POLISH, KOKORO_GERMAN } from './models';
+import { PREVIOUS_VERSION_TAG, URL_PREFIX, VERSION_TAG } from '../versions';
+import {
+  KOKORO_STANDARD,
+  KOKORO_POLISH,
+  KOKORO_GERMAN,
+  SUPERTONIC,
+} from './models';
 
 // Common prefixes - voices & phonemization data
 const KOKORO_VOICE_PREFIX = `${URL_PREFIX}-kokoro/${PREVIOUS_VERSION_TAG}/voices`;
+const SUPERTONIC_VOICE_PREFIX = `${URL_PREFIX}-supertonic/${VERSION_TAG}/voices`;
 const KOKORO_PHONEMIZER_PREFIX = `${URL_PREFIX}-kokoro/${PREVIOUS_VERSION_TAG}/phonemizer`;
 
 const KOKORO_PHONEMIZER_EN_US_PREFIX = `${KOKORO_PHONEMIZER_PREFIX}/en-us`;
@@ -300,3 +306,34 @@ export const KOKORO_GERMAN_FEMALE_ANNA = {
     neuralModelSource: KOKORO_PHONEMIZER_DE_MODEL,
   },
 } as TextToSpeechModelConfig;
+
+// Supertonic voices. Supertonic is multilingual — the same voice works for any
+// language; set the `<lang>` token via the config's `lang` field (default
+// 'en'). The 10 built-in voices are M1..M5 (male) and F1..F5 (female).
+const supertonicVoice = (name: string) =>
+  ({
+    model: SUPERTONIC,
+    voiceSource: `${SUPERTONIC_VOICE_PREFIX}/${name}.bin`,
+    lang: 'en' as const,
+  }) as TextToSpeechModelConfig;
+
+/** @category TTS Supported Voices */
+export const SUPERTONIC_MALE_1 = supertonicVoice('M1');
+/** @category TTS Supported Voices */
+export const SUPERTONIC_MALE_2 = supertonicVoice('M2');
+/** @category TTS Supported Voices */
+export const SUPERTONIC_MALE_3 = supertonicVoice('M3');
+/** @category TTS Supported Voices */
+export const SUPERTONIC_MALE_4 = supertonicVoice('M4');
+/** @category TTS Supported Voices */
+export const SUPERTONIC_MALE_5 = supertonicVoice('M5');
+/** @category TTS Supported Voices */
+export const SUPERTONIC_FEMALE_1 = supertonicVoice('F1');
+/** @category TTS Supported Voices */
+export const SUPERTONIC_FEMALE_2 = supertonicVoice('F2');
+/** @category TTS Supported Voices */
+export const SUPERTONIC_FEMALE_3 = supertonicVoice('F3');
+/** @category TTS Supported Voices */
+export const SUPERTONIC_FEMALE_4 = supertonicVoice('F4');
+/** @category TTS Supported Voices */
+export const SUPERTONIC_FEMALE_5 = supertonicVoice('F5');
diff --git a/packages/react-native-executorch/src/hooks/natural_language_processing/useTextToSpeech.ts b/packages/react-native-executorch/src/hooks/natural_language_processing/useTextToSpeech.ts
index 21576eb0f3..b71063ba67 100644
--- a/packages/react-native-executorch/src/hooks/natural_language_processing/useTextToSpeech.ts
+++ b/packages/react-native-executorch/src/hooks/natural_language_processing/useTextToSpeech.ts
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import { TextToSpeechModule } from '../../modules/natural_language_processing/TextToSpeechModule';
 import {
   TextToSpeechInput,
@@ -29,6 +29,15 @@ export const useTextToSpeech = (
   const [moduleInstance, setModuleInstance] =
     useState<TextToSpeechModule | null>(null);
 
+  const serializedModel = useMemo(
+    () => JSON.stringify(model.model),
+    [model.model]
+  );
+  const serializedPhonemizerConfig = useMemo(
+    () => JSON.stringify(model.phonemizerConfig),
+    [model.phonemizerConfig]
+  );
+
   useEffect(() => {
     if (preventLoad) return;
 
@@ -64,10 +73,10 @@ export const useTextToSpeech = (
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
     model.model.modelName,
-    model.model.durationPredictorSource,
-    model.model.synthesizerSource,
+    serializedModel,
     model.voiceSource,
-    model.phonemizerConfig,
+    model.lang,
+    serializedPhonemizerConfig,
     preventLoad,
   ]);
 
@@ -92,7 +101,9 @@ export const useTextToSpeech = (
       return await instance.forward(
         input.text ?? '',
         input.speed ?? 1.0,
-        input.phonemize ?? true
+        input.phonemize ?? true,
+        input.totalSteps ?? 8,
+        input.lang ?? ''
       );
     } finally {
       setIsGenerating(false);
@@ -115,6 +126,8 @@ export const useTextToSpeech = (
         for await (const audio of instance.stream({
           speed: input.speed ?? 1.0,
           phonemize: input.phonemize ?? true,
+          totalSteps: input.totalSteps ?? 8,
+          lang: input.lang,
           stopAutomatically: input.stopAutomatically ?? true,
         })) {
           if (input.onNext) {
diff --git a/packages/react-native-executorch/src/index.ts b/packages/react-native-executorch/src/index.ts
index ba7ac384f9..3e5a660a68 100644
--- a/packages/react-native-executorch/src/index.ts
+++ b/packages/react-native-executorch/src/index.ts
@@ -107,6 +107,15 @@ declare global {
     synthesizerSource: string,
     voice: string
   ) => Promise<any>;
+  var loadTextToSpeechSupertonic: (
+    lang: string,
+    unicodeIndexerSource: string,
+    durationPredictorSource: string,
+    textEncoderSource: string,
+    vectorEstimatorSource: string,
+    vocoderSource: string,
+    voice: string
+  ) => Promise<any>;
   var loadOCR: (
     detectorSource: string,
     recognizer: string,
@@ -140,6 +149,7 @@ if (
   global.loadPrivacyFilter == null ||
   global.loadSpeechToText == null ||
   global.loadTextToSpeechKokoro == null ||
+  global.loadTextToSpeechSupertonic == null ||
   global.loadOCR == null ||
   global.loadVerticalOCR == null ||
   global.__rne_isEmulator == null
diff --git a/packages/react-native-executorch/src/modules/natural_language_processing/TextToSpeechModule.ts b/packages/react-native-executorch/src/modules/natural_language_processing/TextToSpeechModule.ts
index df1aaa01c8..e00f70abc1 100644
--- a/packages/react-native-executorch/src/modules/natural_language_processing/TextToSpeechModule.ts
+++ b/packages/react-native-executorch/src/modules/natural_language_processing/TextToSpeechModule.ts
@@ -4,6 +4,7 @@ import { ResourceFetcher } from '../../utils/ResourceFetcher';
 import { ResourceSource } from '../../types/common';
 import {
   TextToSpeechModelConfig,
+  TextToSpeechModelName,
   TextToSpeechModelSources,
   TextToSpeechStreamingInput,
 } from '../../types/tts';
@@ -15,10 +16,12 @@ import { Logger } from '../../common/Logger';
  */
 export class TextToSpeechModule {
   private nativeModule: any;
+  private modelName: TextToSpeechModelName;
   private isStreaming: boolean = false;
 
-  private constructor(nativeModule: unknown) {
+  private constructor(nativeModule: unknown, modelName: TextToSpeechModelName) {
     this.nativeModule = nativeModule;
+    this.modelName = modelName;
   }
 
   /**
@@ -32,22 +35,76 @@ export class TextToSpeechModule {
     onDownloadProgress: (progress: number) => void = () => {}
   ): Promise<TextToSpeechModule> {
     try {
-      const nativeModule = await TextToSpeechModule.loadKokoro(
-        config,
-        onDownloadProgress
-      );
-      return new TextToSpeechModule(nativeModule);
+      const modelName = config.model.modelName;
+      const nativeModule =
+        modelName === 'supertonic'
+          ? await TextToSpeechModule.loadSupertonic(config, onDownloadProgress)
+          : await TextToSpeechModule.loadKokoro(config, onDownloadProgress);
+      return new TextToSpeechModule(nativeModule, modelName);
     } catch (error) {
       Logger.error('Load failed:', error);
       throw parseUnknownError(error);
     }
   }
 
+  private static async loadSupertonic(
+    config: TextToSpeechModelConfig,
+    onDownloadProgressCallback: (progress: number) => void
+  ): Promise<unknown> {
+    const { model, voiceSource, lang } = config;
+    const supertonic = model as Extract<
+      TextToSpeechModelSources,
+      { modelName: 'supertonic' }
+    >;
+
+    const paths = await ResourceFetcher.fetch(
+      onDownloadProgressCallback,
+      supertonic.unicodeIndexerSource,
+      supertonic.durationPredictorSource,
+      supertonic.textEncoderSource,
+      supertonic.vectorEstimatorSource,
+      supertonic.vocoderSource,
+      voiceSource
+    );
+
+    const [indexer, duration, textEncoder, vectorEstimator, vocoder, voice] =
+      paths;
+    if (
+      !indexer ||
+      !duration ||
+      !textEncoder ||
+      !vectorEstimator ||
+      !vocoder ||
+      !voice
+    ) {
+      throw new RnExecutorchError(
+        RnExecutorchErrorCode.DownloadInterrupted,
+        'Supertonic: missing required model paths.'
+      );
+    }
+
+    return await global.loadTextToSpeechSupertonic(
+      lang ?? 'na',
+      indexer,
+      duration,
+      textEncoder,
+      vectorEstimator,
+      vocoder,
+      voice
+    );
+  }
+
   private static async loadKokoro(
     config: TextToSpeechModelConfig,
     onDownloadProgressCallback: (progress: number) => void
   ): Promise<unknown> {
     const { model, voiceSource, phonemizerConfig } = config;
+    if (!phonemizerConfig) {
+      throw new RnExecutorchError(
+        RnExecutorchErrorCode.InvalidArgument,
+        'Kokoro: phonemizerConfig is required.'
+      );
+    }
     const kokoroModel = model as Extract<
       TextToSpeechModelSources,
       { modelName: 'kokoro' }
@@ -109,31 +166,47 @@ export class TextToSpeechModule {
   }
 
   /**
-   * Synthesizes the provided input (text or IPA phonemes) into speech.
-   * @param input - The input text or phonemes to be synthesized.
+   * Synthesizes the provided input into speech.
+   * @param input - The input text (or IPA phonemes for kokoro) to be synthesized.
    * @param speed - Playback speed multiplier (default: 1.0).
-   * @param phonemize - If true (default), treats input as text and converts it to phonemes.
-   *                    If false, input is treated as phonemes.
-   * @returns A promise resolving to the full audio waveform as a `Float32Array`.
+   * @param phonemize - kokoro only: if true (default) treats input as text and
+   *                    converts it to phonemes; if false input is IPA phonemes.
+   * @param totalSteps - supertonic only: number of flow-matching steps (default 8).
+   * @param lang - Language override (defaults to model config).
+   * @returns A generated speech waveform.
    */
   public async forward(
     input: string,
     speed: number = 1.0,
-    phonemize: boolean = true
+    phonemize: boolean = true,
+    totalSteps: number = 8,
+    lang: string = ''
   ): Promise<Float32Array> {
     this.ensureLoaded('forward');
-    return await this.nativeModule.generate(input, speed, phonemize);
+    const normalized =
+      this.modelName === 'supertonic' ? input.normalize('NFKD') : input;
+    if (this.modelName === 'supertonic') {
+      return await this.nativeModule.generate(
+        normalized,
+        speed,
+        totalSteps,
+        lang
+      );
+    }
+    return await this.nativeModule.generate(normalized, speed, phonemize);
   }
 
   /**
    * Starts a streaming synthesis session. Yields audio chunks as they are generated.
-   * @param input - Input object containing optional speed, phonemize flag and stopAutomatically flag.
+   * @param input - Input object containing optional speed, phonemize / totalSteps and stopAutomatically flag.
    * @yields An audio chunk generated during synthesis.
    * @returns An async generator yielding Float32Array audio chunks.
    */
   public async *stream({
     speed = 1.0,
     phonemize = true,
+    totalSteps = 8,
+    lang,
     stopAutomatically = true,
   }: TextToSpeechStreamingInput): AsyncGenerator<Float32Array> {
     const queue: Float32Array[] = [];
@@ -149,17 +222,33 @@ export class TextToSpeechModule {
       waiter = null;
     };
 
+    const onChunk = (audio: number[]) => {
+      queue.push(new Float32Array(audio));
+      wake();
+    };
+
+    // Native stream signatures differ per model:
+    //   kokoro:     (cb, speed, phonemize, stopAutomatically)
+    //   supertonic: (cb, speed, totalSteps, stopAutomatically, lang)
+    const nativeStream = () =>
+      this.modelName === 'supertonic'
+        ? this.nativeModule.stream(
+            onChunk,
+            speed,
+            totalSteps,
+            stopAutomatically,
+            lang ?? ''
+          )
+        : this.nativeModule.stream(
+            onChunk,
+            speed,
+            phonemize,
+            stopAutomatically
+          );
+
     (async () => {
       try {
-        await this.nativeModule.stream(
-          (audio: number[]) => {
-            queue.push(new Float32Array(audio));
-            wake();
-          },
-          speed,
-          phonemize,
-          stopAutomatically
-        );
+        await nativeStream();
         nativeStreamFinished = true;
         wake();
       } catch (e) {
@@ -191,7 +280,9 @@ export class TextToSpeechModule {
    * @param input - The text or phoneme fragment to append to the streaming buffer.
    */
   public streamInsert(input: string): void {
-    this.nativeModule.streamInsert(input);
+    const normalized =
+      this.modelName === 'supertonic' ? input.normalize('NFKD') : input;
+    this.nativeModule.streamInsert(normalized);
   }
 
   /**
diff --git a/packages/react-native-executorch/src/types/tts.ts b/packages/react-native-executorch/src/types/tts.ts
index 811d7d27c2..438ccc4678 100644
--- a/packages/react-native-executorch/src/types/tts.ts
+++ b/packages/react-native-executorch/src/types/tts.ts
@@ -6,11 +6,22 @@ import { RnExecutorchError } from '../errors/errorUtils';
  * Each model name maps to its required fields.
  * @category Types
  */
-export type TextToSpeechModelSources = {
-  modelName: 'kokoro';
-  durationPredictorSource: ResourceSource;
-  synthesizerSource: ResourceSource;
-};
+export type TextToSpeechModelSources =
+  | {
+      modelName: 'kokoro';
+      durationPredictorSource: ResourceSource;
+      synthesizerSource: ResourceSource;
+    }
+  | {
+      // Supertonic 3: four ExecuTorch submodules driven in order, plus a
+      // unicode indexer for text preprocessing.
+      modelName: 'supertonic';
+      unicodeIndexerSource: ResourceSource;
+      durationPredictorSource: ResourceSource;
+      textEncoderSource: ResourceSource;
+      vectorEstimatorSource: ResourceSource;
+      vocoderSource: ResourceSource;
+    };
 
 /**
  * Union of all built-in Text to Speech model names.
@@ -64,17 +75,58 @@ export interface TextToSpeechPhonemizerConfig {
   neuralModelSource?: ResourceSource;
 }
 
+/**
+ * Language codes supported by the Supertonic 3 model's `<lang>` token.
+ * Use `'na'` for unknown / unsupported languages.
+ * @category Types
+ */
+export type TextToSpeechSupertonicLanguage =
+  | 'ar'
+  | 'bg'
+  | 'cs'
+  | 'da'
+  | 'de'
+  | 'el'
+  | 'en'
+  | 'es'
+  | 'fi'
+  | 'fr'
+  | 'hi'
+  | 'hr'
+  | 'hu'
+  | 'id'
+  | 'it'
+  | 'ja'
+  | 'ko'
+  | 'ms'
+  | 'nl'
+  | 'no'
+  | 'pl'
+  | 'pt'
+  | 'ro'
+  | 'ru'
+  | 'sk'
+  | 'sv'
+  | 'sw'
+  | 'ta'
+  | 'th'
+  | 'tl'
+  | 'tr'
+  | 'na';
+
 /**
  * Configuration for a specific model and voice in a Text-to-Speech module.
  * @category Types
  * @property {TextToSpeechModelSources} model - The model sources and identifiers.
  * @property {ResourceSource} voiceSource - The resource containing the voice-specific tensor stored in a binary format.
- * @property {TextToSpeechPhonemizerConfig} phonemizerConfig - The phonemizer configuration to be used with this voice.
+ * @property {TextToSpeechPhonemizerConfig} [phonemizerConfig] - Phonemizer configuration. Required for `kokoro`, unused by `supertonic`.
+ * @property {TextToSpeechSupertonicLanguage} [lang] - Language token for `supertonic` (default `'na'`). Unused by `kokoro`.
  */
 export interface TextToSpeechModelConfig {
   model: TextToSpeechModelSources;
   voiceSource: ResourceSource;
-  phonemizerConfig: TextToSpeechPhonemizerConfig;
+  phonemizerConfig?: TextToSpeechPhonemizerConfig;
+  lang?: TextToSpeechSupertonicLanguage;
 }
 
 /**
@@ -88,7 +140,16 @@ export interface TextToSpeechModelConfig {
 export interface TextToSpeechInput {
   text?: string;
   speed?: number;
+  /** kokoro only: treat input as text (true) or IPA phonemes (false). */
   phonemize?: boolean;
+  /** supertonic only: number of flow-matching steps (default 8). */
+  totalSteps?: number;
+  /**
+   * supertonic only: language token for this call (e.g. `'en'`, `'na'`).
+   * Overrides the config's `lang` for this synthesis without reloading the
+   * model. Defaults to the config's `lang` (or `'na'`).
+   */
+  lang?: TextToSpeechSupertonicLanguage;
 }
 
 /**