On-Device Speech Synthesis for Inclusive Mobile Applications: Architecture and Case Studies

On-Device Speech Synthesis for Inclusive Mobile Applications: Architecture and Case Studies

Abstract — The field of speech synthesis technology, especially neural Text-to-Speech (TTS), has experienced significant progress in recent years. These technologies are used as an inclusive mobile application, including blind, low vision, and reading impaired users for reliable, low-latency, and privacy-preserving speech output. In contrast, cloud-based services work under strict constraints such as computation memory, storage consumption, and real-time approachability, while continuing tightly incorporated with platform accessibility frameworks. In this context, this study introduces a systems-level analysis of on-device speech synthesis for mobile-based platforms. The main focus of this study is on architectural design patterns, optimization strategies, and accessibility implications. The main contribution of this study is an in-depth analysis of RHVoice which is a lightweight, multilingual text-to-speech engine. The study provides its integration into iOS and macOS environments, architectural adaptations, and performance optimizations for accessibility-critical use. Additionally, a comparative case study is presented to analyze the mobile deployment of the Piper neural TTS engine to contextualize emerging neural approaches for on-device inference. The findings demonstrate that modular, streaming-oriented architectures incorporated with targeted optimization techniques can deliver real-time, offline speech synthesis suitable for accessibility applications.

Index Terms: text-to-speech (TTS), neural-text, RH Voice, speech synthesis, machine learning

INTRODUCTION

Modern operating systems incorporate comprehensive accessibility features to enable individuals with disabilities to operate computer systems with flexibility. The content displayed on the screen should be read audibly to individuals who are unable to see it. For blind, low-vision, and reading-impaired users, on-device and offline text-to-speech enables reliable access to educational materials, assistive tools, and communication interfaces even in low-connectivity or privacy-sensitive environments. In addition, controls are operated via external switches or voice commands if an individual is unable to physically contact them. In other words, audio speech should be transcribed into textual captions for individuals who are unable to hear [1]. For example, Apple's iOS and iPadOS encompass over 50 accessibility features that modify both the input methods used to operate user interfaces and the output modalities used to perceive them, catering to individuals with diverse abilities [2].

Recent developments within the machine learning community have resulted in notable progress across numerous fields, particularly in the deployment of Large Language Models (LLMs) for a variety of applications. These methods operate on discrete token representations estimating the probability of each potential class (referred to as tokens) based on the sequence of previously predicted tokens [3].

Following this trend, transformer-based methods have been explored in the domain of text-to-speech (TTS) synthesis and have shown significant advancements over prior state-of-the-art models, especially in zero-shot scenarios. This achievement has been exhibited in models such as VALL-E, SpeechLM, and AudioLM [4]. However, because these models are significantly larger than traditional TTS models and utilize autoregressive inference, these advancements incur higher computational demands and increased inference times.

Implementing transformer-based methods similar to LLMs for TTS necessitates transitioning from conventional continuous speech representations, such as mel spectrograms, to a quantized form. This is generally accomplished through the utilization of a pre-trained codec [5], which transforms continuous speech waveforms into a sequence of discrete tokens. The transformer model, therefore, estimates the sequence of tokens, which are subsequently input to the codec for decoding back into a continuous waveform.

Prior to the emergence of token-based transformer TTS models, it has become feasible to develop a completely neural network-based TTS system. For example, Tacotron [6], an attention-based sequence-to-sequence model, is capable of producing a Mel spectrogram from a sequence of characters or phonemes, which is subsequently converted into speech samples by a neural vocoder such as WaveNet [7], WaveRNN [8], or Parallel WaveNet [9] dependent on the Mel-spectrogram. The resulting system decreases the complexity of a conventional TTS system and produces high-quality speech that is virtually indistinguishable from natural speech.

A fully neural network-based end-to-end TTS system provides numerous advantages beyond improved quality. They can be trained using extensive amounts of text and speech data with minimal human annotation and domain-specific expertise. They typically do not require phoneme-level alignment and involve fewer components, thereby reducing the potential for error propagation.

Despite these advancements in neural TTS modeling systems, deploying speech synthesis systems in accessibility-critical mobile applications have numerous challenges. There challenges involve trade-offs concerning quality, computational expense, speed, and robustness. For example, challenges encountered in utilizing Tacotron as a neural frontend, along with the design decisions that enabled us to address them. The research needs to explain the essential optimizations and performance enhancements for WaveRNN while maintaining high quality of mixed speech.

The research aims to provide detailed analysis of on-device speech synthesis for mobile applications including architectural design, optimization techniques, and other accessibility improvements. In other words, the research fused recent advances in neural TTS-based systems and analyzes their compatibility for implementation under computational memory, and any energy constraints of mobile-based platforms. Additionally, the study focuses on privacy-first and offline processing considerations that are important for accessibility-oriented speech state-of-the-art technologies. Furthermore, the study presents RHVoice as the primary practical case study, illustrating the deployment of a lightweight, accessibility-oriented on-device TTS system on iOS and macOS platforms. Whereas, a secondary case study examines the mobile deployment of the Piper neural TTS engine, which is included as a comparative example to contextualize recent neural approaches under similar on-device constraints.

The remaining portion of the research is presented as follows: Section 2 provides the related work on existing technologies. Section 3 presents a reference architecture for on-device mobile TTS systems and surveys common architectural design patterns. The model optimization techniques for mobile deployments with case studies are discussed in Section 4. Section 5 presents the accessibility implications. Finally, section 6 concludes the study with future insights.

Literature review

Recent years have seen substantial work in text-to-speech synthesis which are driven by the advancement in neural network architectures and large-scale data-driven training. This section reviews prior work across these areas.

Neural Text-to-Speech Systems

With recent developments in neural text-to-speech (TTS) technology, it has become feasible to develop a TTS system entirely based on neural networks. Shen et al. [4] presented Tacotron 2, a fully neural text-to-speech system that integrates a sequence-to-sequence recurrent network with attention mechanisms to generate mel-spectrograms, utilizing a modified WaveNet vocoder. The resulting system produces synthesized speech with prosody comparable to Tacotron and audio fidelity on par with WaveNet. In other words, non-autoregressive parallel approaches are generally preferred for their computational efficiency, both in the generation of intermediate features [11] and in neural vocoders. There are also systems that directly generate a waveform from a single network while employing an intermediate representation [4], whereas other systems utilize fully end-to-end models without intermediate features or multiple networks [12].

In another study, Wang et al. [13] introduced a Tacotron, an end-to-end generative text-to-speech model that produces speech directly from characters. Given pairs, the model can be trained entirely from start using random initialization. We introduce several essential techniques to enhance the performance of the sequence-to-sequence system for this demanding endeavor. Tacotron attains a subjective mean opinion score of 3.82 on a 5-point scale for US English, surpassing a production parametric system in naturalness. Similarly, Arik et al. [14] introduced a deep voice, a high-quality text-to-speech system developed entirely using deep neural networks. The research introduces a novel approach to boundary detection utilizing deep neural networks with connectionist temporal classification (CTC) loss. For the audio synthesis model, proposed system employs a modified version of WaveNet that utilizes fewer parameters and achieves quicker training compared to the original.

Transformer-Based and Token-Based TTS Models

Recent TTS models utilizing decoder-only Transformer architecture, such as SPEAR-TTS and VALL-E, attain remarkable levels of naturalness and exhibit the capacity for zero-shot adaptation when provided with a speech prompt. However, these decoder-only TTS models do not incorporate monotonic alignment constraints, which can occasionally result in hallucination problems such as mispronunciations, word omissions, and repetitions.

Du et al., [15] introduced VALL-T, a decoder-only generative Transducer model engineered to enhance the durability and management of TTS systems. VALL-T integrates monotonic alignment constraints within the decoder-only TTS framework, facilitating the implicit modeling of phoneme durations.

Gao et al. [16] introduced a rapid and precise parallel transformer, designated as Paraformer. This employs a continuous integrate-and-fire based predictor to estimate the token count and produce hidden variables. A glancing language model (GLM) sampler subsequently produces semantic embeddings to improve the non-autoregressive (NAR) decoder’s capacity to capture contextual interdependencies. Finally, the research develops a strategy for generating negative samples to enhance minimum word error rate training and further improve performance. These models attain high quality, but the main limitations of these transformer-based TTS models are computational demands restrict practical deployment on devices.

On-Device, Edge, and Mobile Speech Processing

On-device speech recognition inherently ensures privacy and security of the user's speech data. It is consistently accessible and enhances the reliability and latency of speech recognition by eliminating the requirement for network connectivity. Additional hidden benefits associated with edge inference include energy efficiency and extended battery life for portable devices by eliminating the need to establish Bluetooth, Wi-Fi, or LTE connections for data transmission. In similar research, Gondi et al., [17] assessed the efficacy and efficiency of transformer-based speech recognition systems deployed on edge devices. The research analyzes inference performance on two widely used edge devices, the Raspberry Pi and Nvidia Jetson Nano, operating on CPU and GPU, respectively.

In another study, Zhang et al., [18] presented the methodology for developing a highly compact speech recognition system tailored for exceedingly low-resource edge devices. To meet the requirements of the streaming attribute under constraints of low computational complexity and minimal model size, the model selected a transducer lattice with a DFSMN encoder. The LSTM predictor has been substituted with a Conv1d layer to further decrease the number of parameters and computational complexity. Table 1 shows the main contributions and limitations in the existing research.

Table 1. Core findings of research

On-Device Mobile TTS Systems: Architecture and Design

This section involves how modern TTS systems designed and deployed on handheld devices under real constraints.

System Requirements and Constraints

For deploying neural text-to-speech models on mobile devices, the challenges are quite significant. Handheld devices are limited in terms of latency, memory and computing power, and can't match the capabilities of cloud-based systems. Because on-device TTS has to produce real-time speech that sounds natural, it puts lots of pressure on the model's architecture and its ability to quickly deliver results [19].

Existing work has discussed these trade-offs and the measures required to bring down latency and make the footprint smaller on mobile phones [4-5]. The responsiveness of on-device TTS, measured as the time from text input to audible output, is a crucial aspect of interactive speech applications. For screen reader users, excessive latency disrupts navigation flow, increases cognitive load, and can significantly hinder independent device use.

On-Device TTS Architecture

In general, the model breaks down speech synthesis into a series of modular processing stages. This breakdown shows both the functional needs of voice synthesis and the practical limits of mobile technology, such as limited memory, processing power, and strict real-time latency requirements for accessible apps.

Linguistic Processing Pipeline

The pipeline starts with text input, which can be from user interface elements, documents, notifications, or material that is created on the fly by accessibility services like screen readers. A text normalization component initially processes this input. It turns numerals, abbreviations, and symbols that aren't standard into their spoken counterparts. For accessibility use cases, accurate normalization is very important because mistakes make it harder for blind and low-vision users to understand what they are reading.

After normalization, the linguistic frontend turns normalized text into a phonetic or linguistic representation. This is usually done by converting graphemes to phonemes (G2P) or directly inputting phonemes. This split lets language-specific resources be updated without affecting downstream acoustic models. This makes it easier to accommodate several languages and makes the system less complicated.

Acoustic and Neural Synthesis Pipeline

The linguistic representation is then given to the acoustic model, which predicts intermediate acoustic properties like mel-spectrograms or other small representations that work for waveform synthesis. In settings on the device, this part has to find a compromise between model capacity and inference efficiency because it has to work with strict memory and latency limits.

After that, the vocoder changes acoustic features into audio samples in the time domain. Because generating waveforms usually takes the greatest processing power, TTS systems that run on devices frequently use lightweight neural vocoders or designs that are better for streaming. The acoustic model and vocoder work together to make up the main neural synthesis pipeline. They are designed to provide incremental, low-latency output.

System and Accessibility Integration Pipeline

On-device TTS systems do not create full sentences before playing them back. Instead, they use a streaming audio pipeline. Audio samples that are made are sent to an audio buffer, which sends them to a streaming component that plays them back continuously. This approach makes latency seem much lower and lets you get input right away when you're doing things like navigating a screen.

Incremental audio feedback is especially important for blind and low-vision users, as it supports optimize exploration of user interfaces and reduces the delay between focus changes and spoken feedback. The streaming output works with platform-native accessibility APIs, which makes it work with system-level services like VoiceOver on iOS and macOS. This integration layer takes care of prioritizing speech, controlling interruptions, and keeping everything in sync with changes in the user interface emphasis.

Control and Resource Management

This layer is tasked with scheduling operations, importing models, and facilitating power-conscious execution. The scheduler orchestrates the timing of inferences and the allocation of resources, whereas the model store administers access to on-device vocal and language assets. Feedback from power and thermal monitoring components facilitate dynamic adaptation of synthesis behavior, thereby ensuring system stability and optimizing battery efficiency.

For assistive technologies that may be used continuously throughout the day, such as screen readers, power-aware execution directly affects device availability and sustained accessibility.

Platform-Specific Design Considerations

iOS and macOS Integration

The TTS systems on Apple's devices need to integrate closely with system frameworks including Core Audio, AVAudioEngine, and VoiceOver. Audio playback has to follow system-level restrictions, like changes in audio focus, speech interruption for convenience, and rules for running in the background.

Memory management is very important on iOS since putting background jobs on hold and memory strain might mess up long-running synthesis tasks. Because of this, mobile TTS solutions put a lot of emphasis on loading lightweight models, streaming inference, and managing buffers directly. According to sandbox regulations, all language resources, models, and speech data must be safely saved in the application bundle or downloaded for offline use with the user's clear authorization [12].

Model Optimization Techniques for Mobile Deployment

While recent neural text-to-speech architecture demonstrates substantial progress in speech quality and flexibility, this research discusses neural optimization techniques primarily as background and points of comparison. The primary focus is on optimization strategies applicable to lightweight and hybrid on-device systems, particularly non-end-to-end solutions such as RHVoice that are viable under strict mobile resource constraints.

Neural Architecture Optimization

The key to making mobile TTS work well is choosing the right architecture that strikes a balance between expressive power and computational expense. Table I shows the differences between common model setups for servers and mobile deployment.

Table 2. Model configuration comparison for server vs. mobile deployment

Lightweight Vocoder Design

The vocoder is the main computational bottleneck because it works on a sample-by-sample basis. The split-state WaveRNN architecture lessens the amount of work that needs to be done by sharing hidden state calculations between samples [12]. This method divides the GRU hidden state in half, using the first half to forecast the current sample and the second half to predict the future sample. This cuts the number of matrix multiplication operations in half. This modification substantially improves execution efficiency on mobile CPUs while preserving perceptual speech quality.

Multi-Band MelGAN [20] and HiFi-GAN [21] are two examples of alternative vocoders that allow for non-autoregressive parallel generation. This speeds up the process but slightly lowers the quality. Using transposed convolutions, these designs can make many samples at the same time, getting real-time factors of 5-10x on mobile GPUs.

Attention Mechanism Simplification

Autoregressive acoustic models gain advantages from streamlined attention mechanisms. Stepwise monotonic attention [12] limits alignment to only moving forward, which cuts down on processing from O(n²) to O(n) and makes it more stable for text patterns that repeat. Linear attention variations [22] for transformer-based models come close to full self-attention with linear complexity, making it possible to use them on devices with limited memory bandwidth.

Quantization and Compression

Post-Training Quantization

Post-training quantization changes FP32 model weights to INT8 representation. This makes the model 75% smaller and speeds up inference by 2 to 4 times by using vectorized integer arithmetic. When using TTS models, it's important to keep the dynamic range of mel-spectrogram predictions. Per-channel quantization scales use different quantization settings for each output channel. This keeps the quality of vocoder conditioning signals from getting worse. Experimental results indicate that INT8 quantization introduces minimal perceptible quality degradation while substantially reducing memory bandwidth requirements. For WaveRNN vocoders, combining 8-bit μ-law output quantization with INT8 weight quantization enables significant acceleration on ARM NEON architectures [12].

Structural Pruning and Knowledge Distillation

Based on relevance scores from validation loss, structural pruning takes out whole parts of a neural network, such attention heads and LSTM units. When using mobile TTS, removing 30–40% of the LSTM units in the acoustic model usually speeds things up by 1.5 times with less than 0.1 MOS loss. Knowledge distillation moves knowledge from a big teacher model to a small student model by comparing the KL divergence loss of their output mel-spectrogram distributions. This method works especially well for teaching lightweight vocoders to sound like bigger WaveNet models.

Hardware-Specific Acceleration

Neural Engine Optimization

Modern Apple iPhones have special Neural Engine cores that are designed to make matrix multiplication and convolution processes faster. Using Core ML to deploy TTS models automatically compiles them to neural engine bytecode, although manual optimization gives better results. Important methods are:

Operation fusion: Combining consecutive linear layers and activations cuts down on memory transfers.

Reorganizing convolutions: Changing 1D convolutions into depthwise-separable ones cuts the number of parameters by 8 times.

Loop unrolling: Unrolling the WaveRNN sample generation loop 120 times (per frame) cuts down on driver round-trips and speeds up the process by 2 to 3 times compared to CPU execution [12].

Heterogeneous Compute Allocation

Efficient mobile TTS uses different types of computing resources by sending operations to the right processors. The acoustic model works well on high-efficiency CPU cores or GPU shader cores since it works at frame-level granularity (10 ms steps). The sample-level vocoder needs to be processed in order, and it works best on high-performance CPU cores or neural engines. Dynamic scheduling that takes into account the thermal state of the device stops throttling during long synthesis sessions.

. Case Study: RHVoice on iOS/macOS

RHVoice is an open-source speech synthesis engine that works with more than 15 languages and is built for situations with little resources. This case study looks at how it works with Apple platforms, focusing on adapting the architecture, overcoming optimization problems, and making it easier to use.

RHVoice Architecture Overview

RHVoice uses a standard parametric synthesis process that includes a language frontend, an acoustic model, and a vocoder. RHVoice doesn't use end-to-end neural systems. Instead, it uses statistical parametric synthesis with decision-tree clustered hidden Markov models (HMMs) for acoustic prediction and a simple pulse-code modulation-based vocoder. This concept puts a modest footprint (less than 50 MB per language) and makesure real-time performance ahead of maximal naturalness.

iOS/macOS Integration Architecture

The integration architecture has three layers:

Native Engine Layer: The RHVoice C++ core written for ARM64 with optimization settings (-O3 -ffast-math) runs synthesis in a background thread that AVAudioEngine controls.

Bridging Layer: Objective-C++ wrappers transform Swift/Objective-C data types into RHVoice's internal representations. They also handle choosing voice profiles and setting parameters.

Layer for integrating systems: A custom AudioUnit subclass gets text from AVSpeechSynthesizer. Delegate protocols and AVAudioPCMBuffer objects send PCM audio across streams.

Implementation Challenges and Solutions

Memory Management

The C++ allocator in RHVoice doesn't work with iOS's automatic reference counting (ARC). Custom allocator hooks send memory allocation to std::malloc and make sure that memory is cleaned up in dealloc methods. This stops memory leaks during long synthesis sessions. Using mmap() to memory-map voice data files instead of loading them all into RAM cuts the amount of memory that stays in RAM by 60%.

Real-Time Synthesis Constraints

On mobile CPUs, the basic RHVoice implementation has a latency of 300–500 ms. Some ways to optimize are:

Pre-buffering: Starting the synthesis engine with 200 ms of silence while the linguistic processing is finished, which lets the audio start playing right away

Parellel Processing: Running text normalization and G2P conversion on a high-efficiency core at the same time as the main synthesis thread starts up.

Optimizing audio graphs: Setting up AVAudioEngine with AEProcessingGraph to reduce round-trip latency in the audio subsystem.

These changes reduce the perceived synthesis latency to a range suitable for real-time, accessibility-oriented interaction

Sandboxing and Code Signing

Apple's sandbox constraints stop linguistic rules from being loaded dynamically from outside directories. The solution puts all voice data in the application bundle, using NSBundle resource paths and code-signed resources. The app must ask the user for permission to download voices and keep the files in the app's container directory.

. Case Study:  Piper Neural TTS on Mobile

Piper is a new neural TTS system that uses a simplified VITS (Variational Inference with Adversarial Learning for End-to-End Text-to-Speech) framework that is best for running on the edge. Piper's conditional variational autoencoder with adversarial training creates waveforms directly from phoneme sequences, which makes the pipeline less complex and takes up less memory than standard two-stage acoustic model-vocoder pipelines. This part gives a technical look at Piper's mobile implementation, with a focus on improving latency and real-time inference performance.

Piper Architecture and Mobile Adaptation

The standard Piper model (30–50 MB FP32) is regularly optimized for use on mobile devices:

ONNX Runtime Quantization: After training, dynamic quantization substantially reduces model size while maintaining perceptual speech quality suitable for accessibility use cases.

Operator Fusion: Consecutive convolution, normalization, and activation layers are combined, which cuts down on kernel launch overhead by 40% on mobile

Mobile Friendly Phonemization: The default eSpeak-ng phonemizer (an external process) is replaced with a lightweight 2 MB CNN-based G2P model that doesn't have any latency between processes.

Streaming Inference: Instead of full-utterance synthesis, audio production takes place in 512-sample chunks (32 ms @ 16 kHz).

Platform-Specific Implementation Challenges

The main problem is getting Piper's streaming output to work with AVAudioEngine's render callback without causing any audio problems. The answer uses a ring buffer that doesn't need to be locked between the ONNX Runtime thread and the audio callback.

Below code shows the Core Audio render callback:

// Core Audio render callback
OSStatus renderCallback(void *inRefCon,
                       AudioUnitRenderActionFlags *ioActionFlags,
                       const AudioTimeStamp *inTimeStamp,
                       UInt32 inBusNumber,
                       UInt32 inNumberFrames,
                       AudioBufferList *ioData) {
    PiperTTSContext *ctx = (PiperTTSContext *)inRefCon;
    // Non-blocking read from ring buffer
    size_t samplesRead = ring_buffer_read(ctx->audioRing, 
                                          ioData->mBuffers[0].mData, 
                                          inNumberFrames);
    if (samplesRead < inNumberFrames) {
        // Underrun protection: pad with zeros
        memset((float*)ioData->mBuffers[0].mData + samplesRead, 0, 
               (inNumberFrames - samplesRead) * sizeof(float));
    }
    return noErr;
}

VoiceOver Integration

Piper uses the UIAccessibilityReadingContent protocol with pre-synthesis of forthcoming pieces to suit VoiceOver's rigorous time requirements: Below the code shows the predictively pre-synthesizes speech for the next few accessibility elements.

func accessibilityElementDidBecomeFocused(_ element: UIAccessibilityElement) {
    // Pre-synthesize next 3 elements while current plays
    let upcomingText = self.preloadUpcomingText(count: 3)
    DispatchQueue.global(qos: .userInteractive).async {
        self.piperEngine.preloadPhonemes(upcomingText)
    }
}

Conclusion

This study analyzed on-device speech synthesis as a core enabling technology for inclusive mobile applications. In other words, the research introduces a unified analysis of system architecture, model optimization strategies, and accessibility implications under real-world mobile constraints. For example, by decomposing on-device TTS into linguistic processing, neural acoustic generation, and system-level integration, the study illustrated how modular, streaming-oriented architectures can achieve low-latency, privacy-preserving speech synthesis while operating within strict memory, energy, and thermal limits. Furthermore, the evaluation of optimization techniques demonstrated that careful architectural simplification, quantization, pruning, and hardware-aware execution make real-time neural TTS feasible on contemporary mobile devices. The research also presented on RHVoice and modern neural systems such as Piper, showing how both can be effectively deployed to support accessibility-critical use cases. Finally, the findings underscore that on-device TTS is not only a technical necessity for performance and privacy but also a foundational component of equitable digital access for blind, low-vision, and reading-impaired users. By enabling private, low-latency, and offline speech output, on-device TTS plays a foundational role in equitable access to digital information for blind, low-vision, and reading-impaired users.

References

[1] Ren, Y., Hu, C., Tan, X., Qin, T., Zhao, S., Zhao, Z., & Liu, T. Y. (2020). Fastspeech 2: Fast and high-quality end-to-end text to speech. arXiv preprint arXiv:2006.04558.

[2] Robinson JL, Braimah Avery V, Chun R, Pusateri G, Jay WM. Usage of Accessibility Options for the iPhone and iPad in a Visually Impaired Population. Semin Ophthalmol. 2017;32(2):163-171.

[3] Yue, K., Chen, B. C., Geiping, J., Li, H., Goldstein, T., & Lim, S. N. (2024). Object recognition as next token prediction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (pp. 16645-16656).

[4] Shen, J., Pang, R., Weiss, R. J., Schuster, M., Jaitly, N., Yang, Z., ... & Wu, Y. (2018, April). Natural tts synthesis by conditioning wavenet on mel spectrogram predictions. In 2018 IEEE international conference on acoustics, speech and signal processing (ICASSP) (pp. 4779-4783). IEEE.

[5] Yi Ren, Yangjun Ruan, Xu Tan, Tao Qin, Sheng Zhao, Zhou Zhao, and Tie-Yan Liu, “Fastspeech: Fast, robust and controllable text to speech,” in Advances in Neural Information Processing Systems, 2019.

[6] Wang, Y., Skerry-Ryan, R. J., Stanton, D., Wu, Y., Weiss, R. J., Jaitly, N., ... & Saurous, R. A. (2017). Tacotron: Towards end-to-end speech synthesis. arXiv preprint arXiv:1703.10135.

[7] Van Den Oord, A., Dieleman, S., Zen, H., Simonyan, K., Vinyals, O., Graves, A., ... & Kavukcuoglu, K. (2016). Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 12, 1.

[8] Kalchbrenner, N., Elsen, E., Simonyan, K., Noury, S., Casagrande, N., Lockhart, E., ... & Kavukcuoglu, K. (2018, July). Efficient neural audio synthesis. In International Conference on Machine Learning (pp. 2410-2419). PMLR.

[9] Oord, A., Li, Y., Babuschkin, I., Simonyan, K., Vinyals, O., Kavukcuoglu, K., ... & Hassabis, D. (2018, July). Parallel wavenet: Fast high-fidelity speech synthesis. In International conference on machine learning (pp. 3918-3926). PMLR.

[10] Wei Ping, Kainan Peng, and Jitong Chen, “ClariNet: Parallel wave generation in end-to-end text-to-speech,” in International Conference on Learning Representations (ICLR), 2019.

[11] Yi Ren, C. Hu, Xu Tan, Tao Qin, Sheng Zhao, Zhou Zhao, and T. Liu, “Fastspeech 2: Fast and high-quality end-to-end text to speech ” ArXiv, vol. abs/2006.04558, 2020.

[12] Ron J. Weiss, RJ Skerry-Ryan, Eric Battenberg, Soroosh Mariooryad, and Diederik P. Kingma, “Wave-Tacotron: Spectrogram-free end-to-end text-to-speech synthesis ” arXiv e-prints, Nov. 2020.

[13] Wang, Y., Skerry-Ryan, R. J., Stanton, D., Wu, Y., Weiss, R. J., Jaitly, N., ... & Saurous, R. A. (2017). Tacotron: Towards end-to-end speech synthesis. arXiv preprint arXiv:1703.10135.

[14] Arık, S. Ö., Chrzanowski, M., Coates, A., Diamos, G., Gibiansky, A., Kang, Y., ... & Shoeybi, M. (2017, July). Deep voice: Real-time neural text-to-speech. In International conference on machine learning (pp. 195-204). PMLR.

[15] Du, C., Guo, Y., Wang, H., Yang, Y., Niu, Z., Wang, S., ... & Yu, K. (2025, April). Vall-t: Decoder-only generative transducer for robust and decoding-controllable text-to-speech. In ICASSP 2025-2025 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP) (pp. 1-5). IEEE.

[16] Gao, Z., Zhang, S., McLoughlin, I., & Yan, Z. (2022). Paraformer: Fast and accurate parallel transformer for non-autoregressive end-to-end speech recognition. arXiv preprint arXiv:2206.08317.

[17] Gondi, S., & Pratap, V. (2021). Performance evaluation of offline speech recognition on edge devices. Electronics, 10(21), 2697.

[18] Zhang, Y., Sun, S., & Ma, L. (2021, June). Tiny transducer: A highly-efficient speech recognition model on edge devices. In ICASSP 2021-2021 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP) (pp. 6024-6028). IEEE.

[19] Brammer, J. I. (2016). Audio screen: Unsighted game mechanics for mobile devices (Doctoral dissertation).

[20] Yang, G., Yang, S., Liu, K., Fang, P., Chen, W., & Xie, L. (2021, January). Multi-band melgan: Faster waveform generation for high-quality text-to-speech. In 2021 IEEE Spoken Language Technology Workshop (SLT) (pp. 492-498). IEEE.

[21] Kong, J., Kim, J., & Bae, J. (2020). Hifi-gan: Generative adversarial networks for efficient and high fidelity speech synthesis. Advances in neural information processing systems, 33, 17022-17033. [22] K. Choromanski, V. Likhosherstov, D. Dohan, V. Song, A. Gane, T. Sarlos, P. Hawkins, J. Davis, A. Mohiuddin, L. Kaiser, and D. Belanger, “Rethinking Attention with Performers,” International Conference on Learning Representations (ICLR), 2021.