Programmatic Phonetic Conversion of Modern English into Elder Futhark Runes: A Computational Linguistics Approach

Full report

On this page

The transliteration of modern English into ancient runic scripts presents a unique intersection of historical linguistics, phonology, and computational natural language processing. The Elder Futhark, universally recognized as the oldest fully formed runic alphabet, was utilized by Germanic peoples primarily during the Migration Period to record Proto-Germanic and Proto-Norse dialects1. Because modern English orthography is notoriously opaque—replete with silent letters, historical spellings, and diverse etymological origins—a direct one-to-one character substitution inevitably produces inaccurate, unpronounceable runic output3. To achieve an authentic conversion, the text must be translated phonetically rather than orthographically3.

Modern computational linguistics facilitates this translation through Grapheme-to-Phoneme transduction, converting English text into intermediate phonetic representations before mapping those distinct sounds to their closest Elder Futhark equivalents6. This relies heavily on standardized phonetic codes, such as the Advanced Research Projects Agency phonetic alphabet, to bridge the gap between English spelling and acoustic reality6. The algorithmic integration of historical runology with modern neural network-driven phonetic parsing enables a highly accurate, programmatic approach to transliteration.

The Linguistic and Historical Framework of the Elder Futhark

Understanding the target script is the foundational step in any transliteration algorithm. The Elder Futhark consists of twenty-four runes, named after the initial phonemes of the first six characters: f, u, þ, a, r, k1. The alphabet is traditionally divided into three groups of eight runes, known in modern scholarship as ættir, an Old Norse term translating to family or clan1. These three groups are conventionally named after the deities Freyr, Heimdall, and Týr, reflecting the mythological associations mapped onto the script by later medieval scholars1.

The earliest complete sequential listing of the twenty-four-character row is preserved on the Kylver Stone, a limestone slab discovered in a cemetery in Gotland, Sweden, dating to approximately 400 CE1. Other early sequential artifacts include the Vadstena and Mariedamm bracteates from the sixth century, which corroborate the division of the script into three ættir, albeit with minor variations in the ordering of specific runes, such as the inversion of the ï and p runes, and the d and o runes1. The epigraphic record, encompassing roughly two hundred and sixty surviving Elder Futhark inscriptions, demonstrates that the script was a highly formalized system designed to accurately represent the phonological inventory of late Proto-Germanic and early Northwest Germanic14.

The creators of the Elder Futhark designed the script with an intentional phonological organization. Analysis of the Kylver Stone sequence reveals structural patterns where each ætt contains exactly two vowels and six consonants, with deliberate distributions of labial and stop consonants13. Each rune functioned acrophonically; its reconstructed Proto-Germanic name began with the phoneme it represented, with the notable exceptions of Algiz and Ingwaz, which represented terminal or medial sounds that did not occur word-initially in the Germanic lexicon1.

Table 1 outlines the complete twenty-four-rune inventory of the Elder Futhark, detailing its Unicode character, conventional transliteration, reconstructed Proto-Germanic name, and standard phonetic values.

Phonological Ambiguities in the Germanic Script

While the majority of the Elder Futhark maps cleanly to specific Proto-Germanic phonemes, certain runes present historical and phonological ambiguities that complicate their programmatic use for modern English. The most heavily debated character in the script is the Eihwaz rune. Transliterated typically as an ï or æ, its exact phonetic value remains highly contested among linguists and runologists1. The rune name itself, reconstructed as \īhwa- or \īwa-, suggests a vocalic value related to front vowels, potentially /æ/, /ɪ/, or /iː/1.

Prominent linguist Elmer H. Antonsen argued that the rune represented an original sound lost during the Proto-Germanic period, possibly a low front vowel /æ/, based on indirect evidence and its distinctive usage in early inscriptions19. Conversely, Bernard Mees, in his extensive analysis of the yew rune, highlights its shifting values and acrophonic adaptations over time, noting its occasional use for harsh palatal fricatives like /ç/ or /x/19. Because modern English contains a vast array of vowel diphthongs absent from Proto-Germanic, the Eihwaz rune is frequently repurposed in programmatic transliteration to handle specific modern English vowel blends or the /æ/ sound, bridging the chronological gap between Proto-Germanic and modern phonology.

The Algiz rune represents another layer of phonological complexity. Originally representing the Proto-Germanic terminal /z/ phoneme, a direct continuation of the Proto-Indo-European terminal /s/, the sound underwent a process of rhotacism in Proto-Norse, shifting toward a retroflex approximant /r₂/1. By the Viking Age and the transition to the Younger Futhark, this sound had merged entirely with the standard /r/ phoneme, rendering the original z-sound obsolete in the Nordic linguistic sphere17. However, in modern English transliteration, the Algiz rune is typically restored to its original Elder Futhark value of /z/ to distinguish it from the voiceless alveolar sibilant /s/ represented by the Sowilo rune1. This restoration is critical for phonetic mapping, as the distinction between voiced and voiceless sibilants carries heavy semantic weight in modern English.

The English Phonological Shift and the Futhorc Divergence

When converting modern English to runes, computational linguists face a fundamental chronological dissonance: mapping a highly complex, globally influenced modern language onto a script designed for an Iron Age dialect. Historically, as Germanic tribes migrated to the British Isles during the Migration Period, they carried the Elder Futhark with them24. However, the developing Old English language underwent rapid phonological shifts that quickly outgrew the twenty-four-character limitations of the original script25.

The Anglo-Saxon Futhorc emerged as a direct solution to this phonological expansion, gradually extending the runic inventory from twenty-four to thirty-three characters between the fifth and eleventh centuries24. Old English developed several vowel sounds and diphthongs absent from Proto-Germanic, necessitating new symbols to maintain phonetic accuracy25. The phenomenon known as Anglo-Frisian brightening, or a-fronting, caused the original low back vowel /ɑ/ to shift towards a fronted /æ/27. In response, the original Ansuz rune was split into three distinct variants: āc for the back vowel /ɑ/, æsc for the fronted /æ/, and ōs for the rounded /o/23.

Furthermore, the Anglo-Saxon Futhorc introduced characters for palatalized consonants, an innovation completely absent in the Elder Futhark. The cēn rune evolved to represent the affricate /tʃ/ and the palatal plosive /c/, while new runes like calc and gar were invented to address the phonetic ambiguity that arose when the velar consonants /k/ and /g/ spawned palatalized offshoots before front vowels23. Additional pseudo-runes, such as cweorð and stan, appeared in later manuscript traditions to accommodate Latin orthographic influence, such as providing a functional equivalent for the Latin letter 'Q'25.

Despite the Anglo-Saxon Futhorc being historically tailored for an ancestor of the modern English language, the vast majority of modern programmatic transliteration tools target the Elder Futhark29. This preference is driven largely by cultural recognition, digital typography constraints, and the pan-Germanic universality of the older script. However, restricting modern English to the twenty-four characters of the Elder Futhark requires complex phonological approximation and deliberate algorithmic reduction, forcing modern affricates and expansive vowel systems into a restricted acoustic framework29.

Overcoming English Orthographic Opacity

The core technical challenge in programmatic runic transliteration is the deep orthography of modern English. A deep orthography means the relationship between graphemes—the written letters—and phonemes—the spoken sounds—is highly inconsistent4. The Great Vowel Shift, a massive phonetic change spanning the fifteenth to the seventeenth centuries, radically altered the articulation of English long vowels without updating the standardized spelling, decoupling the visual representation of English from its auditory reality23. Coupled with centuries of loanwords from Romance languages, the retention of obsolete spellings, and the lack of an overarching language academy, English spelling is effectively historical rather than phonetic33.

Because the Elder Futhark was inherently a phonetic writing system, any conversion algorithm must bypass English spelling entirely. A direct character substitution algorithm—mapping the Latin letter 'C' to a specific rune regardless of whether it sounds like /k/ in "cat" or /s/ in "city"—results in gibberish that violates the fundamental mechanics of runic writing3. The programmatic rules for accurate transliteration dictate a strict adherence to sound over visual representation.

First, silent letters must be omitted unconditionally. Characters that produce no sound, such as the 'e' in "phone" or the 'k' in "knight", cannot be represented in runes because runic characters demand vocalization3. Attempting to render silent letters visually results in an elongated, unpronounceable string of runes3. Second, double consonants must be collapsed. Runic orthography generally avoids doubling consonants unless they cross a distinct morpheme boundary or denote genuine gemination, where the consonant is held for an elongated duration3. The double 'l' in the English word "hello" is acoustically a single /l/ sound and is programmatically reduced to a single occurrence of the Laguz rune3. Finally, digraphs must be resolved into single phonetic units. Combinations like 'sh', 'ch', 'th', and 'ng' represent single phonemes (/ʃ/, /tʃ/, /θ/, /ŋ/) and must be mapped to specific runic approximations rather than treating the underlying Latin letters individually5. To automate these complex linguistic decisions, computational systems rely entirely on Grapheme-to-Phoneme architectures.

Computational Phonetics: G2P Transduction and ARPABET

Grapheme-to-Phoneme transduction is a foundational component of modern computational linguistics, heavily utilized in Text-to-Speech synthesis and Automatic Speech Recognition systems to determine the acoustic pronunciation of a given text6. In the context of runic transliteration, a G2P engine acts as the necessary intermediary, translating opaque English orthography into a machine-readable phonetic array, which can then be algorithmically mapped to the Elder Futhark.

The ARPABET Phonetic Code

While the International Phonetic Alphabet is the universal academic standard for phonetic transcription, programmatic systems typically utilize ARPABET for English language processing1. Developed in the 1970s by the Advanced Research Projects Agency as part of the Speech Understanding Research project, ARPABET maps the phonemes and allophones of General American English exclusively to ASCII characters8. This ASCII constraint ensures seamless processing, array manipulation, and database querying in programming environments without the encoding complexities and multi-byte character issues associated with specialized IPA Unicode strings7.

The ARPABET system encompasses thirty-nine core phonemes, comprising fifteen vowels and twenty-four consonants7. In computational outputs, vowels in the ARPABET system are systematically appended with an integer to denote lexical stress7. A zero indicates no stress, a one indicates primary stress, and a two indicates secondary stress, providing a highly granular representation of the spoken word7.

Table 2 illustrates a selection of the mapping between standard Latin orthography, the IPA standard, and the ARPABET computational codes utilized in G2P systems.

Algorithmic G2P Frameworks: From WFST to Neural Networks

Programmatic G2P conversion relies on two primary methodologies: static dictionary lookups for established vocabulary, and predictive algorithmic modeling for Out-Of-Vocabulary words, such as proper nouns, neologisms, and dialectal slang.

The baseline for dictionary lookups in English is the Carnegie Mellon University Pronouncing Dictionary. This vast, open-source machine-readable lexicon provides highly accurate ARPABET transcriptions for over one hundred and thirty-four thousand words6. Because linguistic data is finite, however, robust transliteration pipelines must incorporate predictive fallback mechanisms for words absent from the CMU dictionary.

One prominent approach utilizes Weighted Finite-State Transducers. Toolkits like Phonetisaurus leverage joint multigram modeling and Expectation-Maximization sequence alignment algorithms35. In this architecture, the system ingests an aligned grapheme-to-phoneme dictionary and estimates a standard n-gram language model, which is then compiled into a directed graph known as a Weighted Finite-State Transducer35. When predicting the pronunciation of an unknown word, the model compiles the input characters into a state machine and computes the intersection with the trained WFST model, extracting the shortest path through the graph to output the most statistically likely phoneme sequence35.

Conversely, modern Python libraries—most notably the g2p\_en module—have largely abandoned finite-state models in favor of deep learning architectures utilizing Sequence-to-Sequence frameworks or Transformer models6. These neural models encode the input character sequence into a high-dimensional hidden state and decode it into an ARPABET sequence, relying on contextual embeddings to handle complex phonetic rules without requiring explicit alignment data43.

The processing flow of the g2p\_en pipeline exemplifies the ideal preprocessing stage for runic transliteration. Initially, non-standard text undergoes strict normalization. Arabic numerals are spelled out programmatically, converting "10" to "ten", and common abbreviations are expanded, ensuring that no non-alphabetic data reaches the phonetic parser6. Following normalization, the text is tokenized into discrete words and analyzed by an averaged perceptron tagger to assign Part-Of-Speech tags6. POS tagging is a critical step for resolving heteronyms—words spelled identically but pronounced differently based on their grammatical function, such as the verb "to read" versus the past tense "read"6. Once the grammatical context is established, the algorithm queries the CMU dictionary, falling back to the neural network for any unresolved tokens, ultimately producing a flat array of ASCII phonetic codes6.

The Transliterator Matrix: Mapping ARPABET to the Elder Futhark

With the English text successfully reduced to a sequence of discrete phonetic tokens, the core logic of the converter relies on a robust translation matrix. This multidimensional matrix maps the thirty-nine distinct ARPABET phonemes down to the twenty-four Elder Futhark characters. Because modern English contains an extensive array of phonemes that did not exist in the Proto-Germanic linguistic sphere, the matrix requires systematic approximations, favoring etymological proximity and articulatory similarity.

Consonant Mapping Logic

The twenty-four consonant sounds of General American English map to the Elder Futhark with varying degrees of directness. Voiceless and voiced plosives generally have distinct one-to-one mappings, while affricates and certain fricatives require deliberate algorithmic reduction.

Table 3 details the programmatic mapping logic for consonants, correlating the computational ARPABET code with the targeted Elder Futhark rune and its Unicode hex value.

 

Handling syllabic consonants presents a specific edge case in the algorithmic mapping. The ARPABET system designates specific tokens for consonants that function as the nucleus of a syllable, such as EL for the /l̩/ sound in "bottle", or EN for the /n̩/ sound in "button"8. Because runic orthography did not differentiate syllabic consonants structurally, the transliteration algorithm must map these sequentially to their standard consonant counterparts, reducing EL to the Laguz rune and EN to the Naudiz rune, relying on the reader to infer the vocalic weight8.

Vowel Mapping Logic

Vowels present the highest programmatic difficulty in any transliteration matrix. Modern English contains over fourteen distinct vowel sounds, alongside numerous diphthongs, contrasting sharply with the roughly five or six base vowels represented in the Proto-Germanic Elder Futhark9. The Great Vowel Shift fundamentally altered the articulation of English vowels, meaning modern pronunciation rarely aligns with the phonetic spaces mapped by ancient runemasters23.

To programmatically resolve this discrepancy, the transliteration algorithm neutralizes the stress markers output by the G2P model—stripping the integers from the ARPABET strings via regular expressions—and maps the raw vowel token to the closest articulatory equivalent in the runic inventory.

Table 4 details the programmatic mapping logic for vowels and complex diphthongs.

 

Software Architecture and Implementation Logic

Translating this complex linguistic matrix into executable code requires a highly structured, sequential processing pipeline. Python is the dominant language for this architecture due to its extensive natural language processing libraries and the robust availability of pre-trained G2P modules6. The software architecture functions over a series of deterministic data transformations.

The application initializes by importing the required neural network models and establishing the translation dictionary, which acts as the core mapping heuristic. The English text is ingested and immediately subjected to strict normalization algorithms6. If a user inputs a phrase containing punctuation, symbols, or numeric data, the system sanitizes it, spelling out numbers and expanding contractions to ensure that only pronounceable alphabetic data reaches the phonetic parsing engine6.

The G2P engine then executes the CMU dictionary lookup, invoking the neural prediction fallback model for any out-of-vocabulary words. The system outputs a serialized list of phonetic tokens and punctuation blocks, heavily populated with lexical stress integers appended directly to the vowel strings6. The transliteration algorithm iterates through this generated phonetic array. Because the translation dictionary expects base phonetic tokens, the code utilizes regular expressions to strip the numeric characters, neutralizing tokens like AY1 or AH0 down to their base forms AY and AH7. This sanitized token then serves as the key to query the dictionary. If a match is found, the corresponding Unicode rune string—pulled from the standardized Runic block spanning U+16A0 to U+16FF—is appended to the output buffer47.

Handling punctuation presents a unique challenge, as historical runic epigraphy did not utilize modern syntactical markers. Word boundaries in ancient inscriptions were frequently ignored entirely, resulting in scriptio continua, or they were delineated by a single interpunct, a double interpunct, or a cross18. To programmatically mimic this aesthetic while maintaining legibility, the algorithm evaluates tokens that fail the dictionary lookup, specifically spaces and punctuation marks. Whitespace is algorithmically mapped to the Unicode Runic Word Separator (U+16EB), rendering a single middle dot between words18. Standard Latin punctuation, such as periods and commas, is either discarded to maintain epigraphic purity or mapped to the multiple-dot sentence separator (U+16EC)18.

While this G2P-driven pipeline produces vastly superior transliterations compared to orthographic substitution ciphers, it remains an approximation bounded by the limitations of the target script. The primary limitation lies in the irreconcilable mismatch between modern phonology and the Proto-Germanic phonetic inventory. Rendering the /tʃ/ sound in the English word "church" as a sequence of velar plosives and alveolar trills reflects a necessary algorithmic compromise rather than historical linguistic reality29. Advanced computational implementations could theoretically improve this by introducing a conditional intermediary layer that maps modern English phonemes back through the Great Vowel Shift and Grimm’s Law before converting them to runes, generating an output closer to the etymological roots of the Germanic vocabulary27. However, this crosses the boundary from programmatic transliteration into literal language translation, generating reconstructed Proto-Germanic vocabulary rather than representing the modern English input.

By prioritizing phonetic architecture over orthographic appearance, computational linguistics provides a robust mechanism for engaging with historical writing systems, allowing modern languages to interface systematically with the constraints of the ancient world.

Works cited

1. Elder Futhark \- Wikipedia, https://en.wikipedia.org/wiki/Elder\_Futhark

2. Elder Futhark ᚠᚢᚦᚨᚱᚲ \- Runic Viking Alphabet \- Online Translator, https://www.dcode.fr/elder-futhark

3. Rune Phonetics – How to read and write in Runes \- The Wicked Griffin, https://thewickedgriffin.com/rune-phonetics/

4. Rune Translator | Free English to Runic Alphabet Converter, https://quirkytranslators.com/historical-english/rune-translator/

5. Rune Converter: English to Elder & Younger Futhark Runes, https://www.norsegarde.com/pages/rune-converter

6. g2p-arpabet \- PyPI, https://pypi.org/project/g2p-arpabet/

7. Source code for paddlespeech.t2s.frontend.arpabet \- Read the Docs, https://paddlespeech.readthedocs.io/en/latest/\_modules/paddlespeech/t2s/frontend/arpabet.html

8. ARPABET \- Wikipedia, https://en.wikipedia.org/wiki/ARPABET

9. Runic Alphabet: Elder Futhark Symbols and Meanings \- Remitly, https://www.remitly.com/blog/education/runic-alphabet/

10. Elder Futhark Runes: Complete Guide to All 24 Symbols, https://www.mythic-harmonies.com/runes-magic/elder-futhark-runes-complete-guide-meanings/

11. List of rune-row inscriptions \- Wikipedia, https://en.wikipedia.org/wiki/List\_of\_rune-row\_inscriptions

12. Futhark Inscriptions: Older vs. Younger | PDF | Runes \- Scribd, https://www.scribd.com/document/410807572/English-Old-Norse

13. Elder Futhark: Inner Structure \- The Viking Rune, https://www.vikingrune.com/2008/12/elder-futhark-code/

14. Runetyper, https://sigrarr.github.io/runetyper/

15. GitHub \- stscoundrel/riimut: Transform latin letters to runes & vice, https://github.com/stscoundrel/riimut

16. Proto-Norse Language \- Encyclopedia.pub, https://encyclopedia.pub/entry/31746

17. Runes and Runestones (Wikipedia Compilation) | PDF \- Scribd, https://www.scribd.com/document/99210865/Runes-and-Runestones-Wikipedia-Compilation

18. Elder Futhark Keyboard Online: Ancient Germanic Runes \- Lexilogos, https://www.lexilogos.com/keyboard/futhark\_old.htm

19. The sounds of Proto-Norse and the Elder Fuþark \- Orðstírr, https://ordstirr.wordpress.com/runes/the-sounds-of-proto-norse-and-the-elder-futhark/

20. How to Use ᛇ in Old English : r/runes \- Reddit, https://www.reddit.com/r/runes/comments/1m04z7j/how\_to\_use\_%E1%9B%87\_in\_old\_english/

21. "The Yew Rune, Yogh and Yew" (Bernard Mees, 2011\) \- Reddit, https://www.reddit.com/r/runes/comments/111ep1s/the\_yew\_rune\_yogh\_and\_yew\_bernard\_mees\_2011/

22. phonetic approximations for Younger Futhark translation : r/RuneHelp, https://www.reddit.com/r/RuneHelp/comments/1b936tk/phonetic\_approximations\_for\_younger\_futhark/

23. The Runes and their sounds | ᚱᚣᚹᚾ᛫ᛋᛣᚣᚹᛚ, https://rune.school/runes-and-sounds/

24. Runic Alphabets: Elder Futhark, Younger Futhark & Futhorc, https://panoramaglasslodge.com/the-runic-alphabets-explained-elder-futhark-younger-futhark-anglo-saxon-futhorc/

25. The Anglo-Saxon Runes: Language, Lore, and Legacy of the Futhorc, https://paganheim.com/blogs/culture-religion/the-anglo-saxon-runes-language-lore-and-legacy-of-the-futhorc

26. Anglo-Saxon runes \- Wikipedia, https://en.wikipedia.org/wiki/Anglo-Saxon\_runes

27. Phonological history of Old English \- Wikipedia, https://en.wikipedia.org/wiki/Phonological\_history\_of\_Old\_English

28. Anglo-Saxon runes (Futhorc) \- Omniglot, https://www.omniglot.com/writing/futhorc.htm

29. Elder Futhark Rune Guide | Names and Letters | Fornvegr, https://fornvegr.no/pages/runes

30. Nordic Runes Converter | English to Elder Futhark Translator, https://nordicrunesconverter.com/

31. Modern English in futhorc | kunihiro's sphere, https://kunihi.ro/2024/12/26/english-in-runes.html

32. Elder futhark alphabet : r/RuneHelp \- Reddit, https://www.reddit.com/r/RuneHelp/comments/1eur4fp/elder\_futhark\_alphabet/

33. Why does Old English sound so different from Middle and Modern, https://www.reddit.com/r/linguistics/comments/3rg3p1/why\_does\_old\_english\_sound\_so\_different\_from/

34. Elder Futhark translation \- LingoJam, https://lingojam.com/ElderFutharktranslation

35. Exploring grapheme-to-phoneme conversion with joint n-gram, https://www.cambridge.org/core/journals/natural-language-engineering/article/phonetisaurus-exploring-graphemetophoneme-conversion-with-joint-ngram-models-in-the-wfst-framework/F1160C3866842F0B707924EB30B8E753

36. WFST-Based Grapheme-to-Phoneme Conversion \- ACL Anthology, https://aclanthology.org/W12-6208.pdf

37. ARPAbet \- learnius, https://learnius.com/slp/3+Speech+Production%2C+Perception+and+Phonetics/4+Phonetics/2+Phonetic+Alphabet/ARPAbet

38. IPA to Arpabet python \- Stack Overflow, https://stackoverflow.com/questions/33583485/ipa-to-arpabet-python

39. A Tunable Forced Alignment System Based on Deep Learning \- PMC, https://pmc.ncbi.nlm.nih.gov/articles/PMC12337111/

40. NikiPshg/Grapheme-to-Phoneme-G2P-with-Stress \- GitHub, https://github.com/NikiPshg/Grapheme-to-Phoneme-G2P-with-Stress

41. Phonetisaurus: A WFST-driven Phoneticizer – Framework Review, https://cmusphinx.github.io/2012/05/phonetisaurus-a-wfst-driven-phoneticizer-e2-80-93-framework-review/

42. Grapheme-to-Phoneme Transformer Model for Transfer Learning, https://arxiv.org/abs/2104.04091

43. G2P\_EN: A Machine Learning Model for Converting English Text to, https://medium.com/axinc-ai/g2p-en-a-machine-learning-model-for-converting-english-text-to-phonemes-03072cc2251f

44. g2p/g2p\_en/g2p.py at master · Kyubyong/g2p \- GitHub, https://github.com/Kyubyong/g2p/blob/master/g2p\_en/g2p.py

45. Phonological history of English \- Wikipedia, https://en.wikipedia.org/wiki/Phonological\_history\_of\_English

46. GitHub \- NRC-ILT/g2p: Grapheme-to-Phoneme transductions that, https://github.com/roedoejet/g2p

47. futhorc-runes · GitHub Topics, https://github.com/topics/futhorc-runes

48. Free Futhark Translator Online, https://openl.ai/translator/futhark-translator

49. Is there a way to print Runes as individual characters?, https://stackoverflow.com/questions/66401017/is-there-a-way-to-print-runes-as-individual-characters

50. Transform latin letters to Elder Futhark runes & vice versa \- GitHub, https://github.com/stscoundrel/elder-futhark

51. paddlespeech.t2s.frontend.arpabet module \- Read the Docs, https://paddlespeech.readthedocs.io/en/latest/api/paddlespeech.t2s.frontend.arpabet.html