The Wolfram Emerging Leaders Program: High School (WELP:HS) is a remote, semester-long program designed for exceptional graduates from the Wolfram High School Summer Research Program to continue to develop their skills. Students work in a small group over the course of a semester to do either a research-based project or a product development–based project under the guidance of expert mentors. Projects are centered around a topic at the intersection of the group’s interests.
This essay was written by:
We present an efficient, bottom-up system for the computational generation of constructed languages, combining customizable phonology, morphology, and syntax with an interactive lexicon editor. Users supply lists for consonants and vowels as well as a syllable template via strings of C and V, customize morphosyntax (alignment, noun/verb/modifier morphology, affix ordering, and word order), and modify lexical items or auto-generate roots based on a preset, standardized 200-word Swadesh list. The generator produces word roots by sampling short substrings of the syllable template, replacing CV slots with random phonemes from the user’s provided sound inventory, and concatenating sampled syllables to form candidate roots. Though the system models isolating and agglutinative languages well, the design is limited by its inability to simulate other prominent linguistic features that exists in natural language, such as nonconcatenative morphology, fusional or polysynthetic language structures, natural linguistic exceptions and irregularities, etc. Future directions should focus on supporting English-conlang translation, script generation, diachronic simulation, and the potential for using constructed languages as a basis for NLP research on learnability and information density.
1. Introduction
1. Introduction
Constructed languages are interesting thought experiments about what a hypothetical language might look like. Oftentimes, linguists and language enthusiasts build conlangs for experimentation and research, for easier international communication, or even for artistic creation and worldbuilding. One famous example of a constructed language is Esperanto, an auxiliary language created by Ophthalmologist L. L. Zamenhof, now the world’s most widely spoken constructed language with estimates of anywhere from 100,000 to 2 million proficient speakers. Other notable examples include J. R. R. Tolkien’s Elvish languages Quenya and Sindarin, which he invented prior to writing his bestseller epic trilogy The Lord of the Rings; and Toki Pona, a minimalist constructed language created by Canadian linguist Sonja Lang with only 120 words, is now widely considered by linguists and language hobbyists as a fun experimental testbed for communication and linguistic relativity.
Previous attempts at computationally generating constructed languages have been tried and tested, but are not necessarily the most sophisticated. VulgarLang, one online constructed-language generator we observed, is constrained by its similarity to English; due to its lack of customizability and presumable reliance on English data, all of the languages it generates share too many features similar with those of English. Thus, in order to improve flexibility of language simulation and assist users with constructing their own languages, we explore the theory behind conlang-generation and investigate improvements to previous conlang-generation models. We have built a preliminary language-generation model which includes the following features: customizable phonology and syllable structure, adjustable word order, affixes, and morphosyntactic alignment, as well as artificially generated word roots and lexicon.
Previous attempts at computationally generating constructed languages have been tried and tested, but are not necessarily the most sophisticated. VulgarLang, one online constructed-language generator we observed, is constrained by its similarity to English; due to its lack of customizability and presumable reliance on English data, all of the languages it generates share too many features similar with those of English. Thus, in order to improve flexibility of language simulation and assist users with constructing their own languages, we explore the theory behind conlang-generation and investigate improvements to previous conlang-generation models. We have built a preliminary language-generation model which includes the following features: customizable phonology and syllable structure, adjustable word order, affixes, and morphosyntactic alignment, as well as artificially generated word roots and lexicon.
2. Showcase
2. Showcase
Instructions on using this language generator:
1. On the initial “Constructed Language Generator” interface, select morphosyntactic alignment (grammatical case), noun morphology (grammatical gender, number, and honorifics), verb morphology (person, tense, aspect, mood, respect, and evidentiality), and modifier morphology (limited to degree of comparison). The user can also select whether or not to include embedded negation markers to be attached to verbs and modifiers.
2. On the “Customize” interface, enter the desired syllable structure, a sequence of C’s and V’s where C represents a sole consonant and V represents a sole vowel (e.g., CVC). Then, enter in intended consonants and vowels as a list of IPA symbols separated by spaces (refer to ipachart.com for the complete International Phonetic Alphabet). The user can then customize the morphological affixes they have chosen; if necessary, the user can choose to randomize all affixes then modify them later.
3. On the “Reorder” interface, reorder selected affixes for nouns, verbs, and modifiers by dragging and dropping blocks, in order to indicate the relative positions of attached morphology with respect to the word root. The user should customize word order as well.
4. On the “Lexicon” interface, add the intended number of entries to form the constructed language’s vocabulary. If the user intends to create a minimalist constructed language, they can press the “Use Swadesh” button to use the default 200-word Swadesh list that represents basic concepts present universally in all languages. The user can also choose to randomize all words then modify them later.
5. On the final showcase interface, the user can name their language, check out the IPA and grammar scopes of their conlang, and download their language summary via PDF export.
1. On the initial “Constructed Language Generator” interface, select morphosyntactic alignment (grammatical case), noun morphology (grammatical gender, number, and honorifics), verb morphology (person, tense, aspect, mood, respect, and evidentiality), and modifier morphology (limited to degree of comparison). The user can also select whether or not to include embedded negation markers to be attached to verbs and modifiers.
2. On the “Customize” interface, enter the desired syllable structure, a sequence of C’s and V’s where C represents a sole consonant and V represents a sole vowel (e.g., CVC). Then, enter in intended consonants and vowels as a list of IPA symbols separated by spaces (refer to ipachart.com for the complete International Phonetic Alphabet). The user can then customize the morphological affixes they have chosen; if necessary, the user can choose to randomize all affixes then modify them later.
3. On the “Reorder” interface, reorder selected affixes for nouns, verbs, and modifiers by dragging and dropping blocks, in order to indicate the relative positions of attached morphology with respect to the word root. The user should customize word order as well.
4. On the “Lexicon” interface, add the intended number of entries to form the constructed language’s vocabulary. If the user intends to create a minimalist constructed language, they can press the “Use Swadesh” button to use the default 200-word Swadesh list that represents basic concepts present universally in all languages. The user can also choose to randomize all words then modify them later.
5. On the final showcase interface, the user can name their language, check out the IPA and grammar scopes of their conlang, and download their language summary via PDF export.
Below is the completed constructed language generator interface:
In[]:=
conlangInterface
Out[]=
3. Structural Design
3. Structural Design
3.1 Interface
3.1 Interface
We employ a minimalist design for the interface. We use a large font size and Helvetica font family to create the titles for interfaces that make up the language generator, a thin black frame with rounded edges to act as the container, and adequate spacing between each line within the UI.
Wrap a Column function within a Framed to create the interface foundation:
In[]:=
Framed[Column[{Style["Conlang Generator",24,Bold,FontFamily->"Helvetica"](*restoftheUI*)},Spacings->2],FrameStyle->Black,RoundingRadius->10,FrameMargins->16]
Out[]=
Our build includes a total of 5 interfaces, each of which is connected through a series of buttons on each interface which calls the next. This is especially useful as it is allows the user to form their constructed language one step at a time, instead of having to customize every linguistic feature at once.
Use Button and CellPrint@ExpressionCell to link interfaces to each other:
In[]:=
Framed[Column[{Style["Conlang Generator",24,Bold,FontFamily->"Helvetica"],Button["Next Interface",CellPrint@ExpressionCell[Framed[Column[{Style["Conlang Generator",24,Bold,FontFamily->"Helvetica"]},Spacings->2],FrameStyle->Black,RoundingRadius->10,FrameMargins->16],"Output"]]},Spacings->2],FrameStyle->Black,RoundingRadius->10,FrameMargins->16]
Out[]=
In order to streamline the process of creating an interface with multiple options, we utilize the helper function, conlangOption, which creates and formats options into rows of settings the user can tweak.
Format language settings via conlangOption:
conlangOption[type_String,category_String,opts_List]:=Module[{init,uiMaker},init=Which[type==="checkbox",{},type==="single",None,type==="textbox","",True,{}];uiMaker=Function[{dyn},Row[{Style[category<>":",Bold],Spacer[10],Which[type==="checkbox",CheckboxBar[dyn,opts,Appearance->"Horizontal"],type==="single",RadioButtonBar[dyn,opts,Appearance->"Horizontal"],type==="textbox",InputField[dyn,String,FieldSize->30,ContinuousAction->True],True,CheckboxBar[dyn,opts,Appearance->"Horizontal"]]},BaselinePosition->Axis]];{category,init,uiMaker,type}]
Use conlangOption with Dynamic and DynamicModule to create rows of adjustable options on the interface:
Module[{rows,keys,initials,uis,types},rows={conlangOption["single","Example Linguistic Setting",{"Option 1","Option 2","Option 3","Option 4","Option 5"}](*putmoreoptionsherebyaddingmoreentriesofconlangOption*)};keys=rows[[All,1]];initials=rows[[All,2]];uis=rows[[All,3]];types=rows[[All,4]];DynamicModule[{state=AssociationThread[keys,initials]},Framed[Column[{Style["Conlang Generator",24,Bold,FontFamily->"Helvetica"],Column[Table[With[{k=keys[[i]],ui=uis[[i]]},ui[Dynamic[state[k],(state[k]=#)&]]],{i,Length[uis]}]],Button["Next Interface",CellPrint@ExpressionCell[Framed[Column[{Style["Conlang Generator",24,Bold,FontFamily->"Helvetica"]},Spacings->2],FrameStyle->Black,RoundingRadius->10,FrameMargins->16],"Output"]]},Spacings->2],FrameStyle->Black,RoundingRadius->10,FrameMargins->16]]]
Interfaces with which the user interacts also need to process and output information, forming a link of data transfer. We execute this by designing the interface functions to pass along a “master association” with information about the language and the user’s selected settings, with each interface taking information from that association to function and adding on its own data to the “master association.” This design is effective because it allows for a smooth connection between each step of the language customization process, and for each interface to extract and manipulate only the data it requires. Observe how the association expands as it undergoes the processes of conlangInterface, customizationInterface, reorderInterface, and lexiconInterface.
conlangInterface outputs:
customizationInterface takes this in, converts the user’s selected settings to an association with all values in IPA, and outputs:
Then, reorderInterface takes part of this in, reorders the morphology to the user’s desired order, and outputs:
Next, lexiconInterface takes part of this in, generates the user’s customized vocabulary list, and outputs:
Finally, showcaseInterface takes in the complete set of data about the user’s customized language and displays it:
3.2 Customization
3.2 Customization
The components of a constructed language, or any language for that matter, includes three key components: phonetics/phonology, morphology, and syntax. Thus, we divide the language-generation process into two parts: one, creating the language’s sound system (phonetics and phonology); two, creating the grammar (morphology and syntax). The foundation of all languages is its sound inventory and syllable structure; the sound inventory encapsulates all the language’s consonants, vowels, and other sounds, and the syllable structure denotes the language’s basic phonotactic pattern. We first customize the language’s sound inventory and syllable structure, allowing the user to enter intended IPA sounds through the interface.
Enter the intended consonants, vowels, and syllable structure through an interface:
We also programmed a dedicated display that allows users to view their language’s customized phonetic inventory in a clear and intuitive way. Consonants and vowels are presented in well-organized tables modeled after the official International Phonetic Alphabet’s consonant chart and vowel trapezoid, respectively. This layout makes it easy for users to readily access and confirm their constructed language’s sound system.
Consider that the user chooses the set of these IPA consonants and vowels to make up their constructed language’s phonetic inventory:
Display this phonetic inventory data using consonantsDisplay and vowelsDisplay:
3.3 Morphosyntax
3.3 Morphosyntax
A language’s affixes, or bound morphemes, to indicate additional grammatical meaning, are attached to the root of the word as a prefix, suffix, circumfix (around the stem), or infix (between the stem). One crucial step of customizing morphology is the user’s ability to adjust the order of the attached morphemes relative to the root. This can be done using draggable, reordering “magnet” blocks.
Manually reorder items in a list through a reorderBlocks interface:
The reorderInterface function works on the same principle. In total, reorderInterface include four adjustable features. On the morphological level, the user is able to reorder affixes for each of nouns, verbs, and modifiers. Additionally, on the syntax level, the user can also customize the word order by reordering Subject, Verb, and Object.
Use reorderInterface to customize the order by which nouns, verbs, modifiers, and sentences are formed:
Taking the result of which, the user can move on to the next step, generation of their language’s lexicon.
3.4 Word Generation
3.4 Word Generation
We attempt to simulate the natural variation of lexicon through first generating the root of the word, onto which we concatenate additional morphology. In order to customize the lexicon for the user’s constructed language, the user has two options: one, add root words themselves, or two, use the provided Swadesh list. For context, the Swadesh list is a set of core vocabulary and concepts, which represents universal concepts found in virtually all languages, as is displayed below:
Refer to the standardized 200-word Swadesh list:
Each root concept should correspond with a string of syllables that conforms to the user’s selected sound inventory and syllable structure. The function wordCreator accepts a language specification that must contain these three fields: a syllable-template string (a pattern composed of the characters C and V) for the syllable structure, a list of consonant symbols, and a list of vowel symbols. The syllable template is then validated against the regular expression ^[CV]+$. Consonant and vowel inventories are turned to strings and cause failure if left empty.
Use wordCreator to randomly generate unassigned 50 word roots:
The caveat for the wordCreator function is that we assume the natural distribution of the amount of syllables of any randomly selected word root in a given language follows a roughly normal distribution. As such, we have programmed the function so that syllable counts reflect the 68-95-99.7 heuristic.
The standard distribution of syllables for wordCreator is as follows:
Within 0.5 standard deviations of the mean, 34% of all randomly generated roots have at least 1 syllable.
Within 1 standard deviation of the mean, 68% of all randomly generated roots have at least 2 syllables.
Within 2 standard deviations of the mean, 95% of all randomly generated roots have at least 3 syllables.
Within 3 standard deviations of the mean, 99.7% of all randomly generated roots have at least 4 syllables.
Within 4 standard deviations of the mean, 99.9% of all randomly generated roots have at least 5 syllables.
The remaining 0.1% of generated roots have 6 syllables, which is the capped syllable count.
Within 0.5 standard deviations of the mean, 34% of all randomly generated roots have at least 1 syllable.
Within 1 standard deviation of the mean, 68% of all randomly generated roots have at least 2 syllables.
Within 2 standard deviations of the mean, 95% of all randomly generated roots have at least 3 syllables.
Within 3 standard deviations of the mean, 99.7% of all randomly generated roots have at least 4 syllables.
Within 4 standard deviations of the mean, 99.9% of all randomly generated roots have at least 5 syllables.
The remaining 0.1% of generated roots have 6 syllables, which is the capped syllable count.
Observe how the normally distributed set of roots leads to more 1-syllable roots and less multiple-syllable roots, mimicking the syllable count distribution in a natural language:
The program repeats this sampling until it has the requested number of unique roots. To avoid runtime errors that may delay or freeze the program, it stops after a fixed number of tries (50 times the desired count) and returns whatever unique words it found.
We then hook the wordCreator function up to an interactive UI, which we titled lexiconInterface:
We then hook the wordCreator function up to an interactive UI, which we titled lexiconInterface:
This front-end lexiconInterface provides a DynamicModule UI that the user can directly interact with. First, it allows manual entry of English-conlang word pairs that forms the basis of the conlang’s word list. Moreover, it can also append empty rows in bulk and deletes rows so that the user can customize the number of words they would like to include; and by calling wordCreator (Randomize!), lexiconInterface fills empty cells. If necessary, the “Use Swadesh” option populates English prompts from the preset, embedded Swadesh list. This option makes it convenient for the user to modify their conlang word data easily and efficiently.
4. Conclusion
4. Conclusion
4.1 Limitations
4.1 Limitations
While the constructed-langauge generator demonstrates flexibility at the phoneme and morpheme levels, it also has several limitations.
The system is primarily suited for modeling isolating and agglutinative languages, where grammatical meaning is expressed through the linear concatenation of discrete morphemes. It is significantly less effective at generating fusional or polysynthetic languages, in which single morphemes encode multiple grammatical categories or where entire sentences may be incorporated into a single word. Although the generator allows fine-grained control over phonological inventories and individual morphemes, it currently lacks deeper modeling at the word-level and sentence-level, which constrains its expressive power for these language types.
Furthermore, the generator does not support nonconcatenative morphology. As a result, it cannot simulate root-and-pattern systems such as those found in Semitic languages like Arabic or Hebrew, where grammatical distinctions are expressed through internal vowel alternations, grammatical templates, or other non-linear transformations. All morphological processes in the current system are strictly concatenative, limited to prefixes and suffixes.
Speaking of grammar, natural languages frequently contain irregularities and exceptions to otherwise productive grammatical rules. The current generator enforces fully regular morphology and syntax, with no mechanism for introducing random or systematic exceptions. This limits its ability to approximate the historical and diachronic complexity that characterizes real human languages. Word order is limited to permutations of Subject, Verb, Object. Additionally, the system does not provide tools for modeling information-structure phenomena, such as topicality or topic-comment structures; it cannot completely simulate languages like Chinese and Japanese which have these structures. The system also has no features for part-of-speech-changing morphemes, such as derivational affixes that convert nouns to verbs or adjectives to adverbs. Finally, the generator lacks support for a number of common grammatical categories, including active-passive distinction, causativity, transitivity, imperative forms, volitional or intentional forms, noun-verb agreement, and other voice- or mood-related constructions. These omissions restrict the grammatical richness of generated languages.
Overall, while this project is highly customizable and leaves all the options to the user, it is ultimately still unable to simulate the natural variation of languages with 100% efficiency. Future research and modeling should address these limitations.
The system is primarily suited for modeling isolating and agglutinative languages, where grammatical meaning is expressed through the linear concatenation of discrete morphemes. It is significantly less effective at generating fusional or polysynthetic languages, in which single morphemes encode multiple grammatical categories or where entire sentences may be incorporated into a single word. Although the generator allows fine-grained control over phonological inventories and individual morphemes, it currently lacks deeper modeling at the word-level and sentence-level, which constrains its expressive power for these language types.
Furthermore, the generator does not support nonconcatenative morphology. As a result, it cannot simulate root-and-pattern systems such as those found in Semitic languages like Arabic or Hebrew, where grammatical distinctions are expressed through internal vowel alternations, grammatical templates, or other non-linear transformations. All morphological processes in the current system are strictly concatenative, limited to prefixes and suffixes.
Speaking of grammar, natural languages frequently contain irregularities and exceptions to otherwise productive grammatical rules. The current generator enforces fully regular morphology and syntax, with no mechanism for introducing random or systematic exceptions. This limits its ability to approximate the historical and diachronic complexity that characterizes real human languages. Word order is limited to permutations of Subject, Verb, Object. Additionally, the system does not provide tools for modeling information-structure phenomena, such as topicality or topic-comment structures; it cannot completely simulate languages like Chinese and Japanese which have these structures. The system also has no features for part-of-speech-changing morphemes, such as derivational affixes that convert nouns to verbs or adjectives to adverbs. Finally, the generator lacks support for a number of common grammatical categories, including active-passive distinction, causativity, transitivity, imperative forms, volitional or intentional forms, noun-verb agreement, and other voice- or mood-related constructions. These omissions restrict the grammatical richness of generated languages.
Overall, while this project is highly customizable and leaves all the options to the user, it is ultimately still unable to simulate the natural variation of languages with 100% efficiency. Future research and modeling should address these limitations.
4.2 Future Directions
4.2 Future Directions
We have several promising directions for extending this project in future work. One major extension would be the development of an interactive translation system that allows users to translate between English and their constructed language. Such a system could leverage the generator’s internal representations of phonology, morphology, and syntax to produce rule-based translations and provide insight into how grammatical structure affects meaning. We also brainstormed the creation of a script generator, using image-based machine learning algorithms to generate writing systems for constructed languages. By training models on existing scripts, the system could produce visually coherent alphabets, abjads, abugidas, or logographic systems that match a constructed language’s phonological structure.
More broadly, this project opens up questions about the relationship between constructed languages and natural language processing (NLP). One intriguing direction that has potential for research is investigating whether carefully designed conlangs can improve data efficiency in NLP systems or serve as testbeds for linguistic generalization in large language models. Future work could explore quantitative measures of a constructed language’s viability in NLP, such as information density, bits per morpheme, or compression efficiency to analyze how grammatical structure influences data flow and learnability. These extensions would ultimately improve the system beyond language generation toward a broader framework for exploring the structure, efficiency, and evolution of human and/or constructed language.
More broadly, this project opens up questions about the relationship between constructed languages and natural language processing (NLP). One intriguing direction that has potential for research is investigating whether carefully designed conlangs can improve data efficiency in NLP systems or serve as testbeds for linguistic generalization in large language models. Future work could explore quantitative measures of a constructed language’s viability in NLP, such as information density, bits per morpheme, or compression efficiency to analyze how grammatical structure influences data flow and learnability. These extensions would ultimately improve the system beyond language generation toward a broader framework for exploring the structure, efficiency, and evolution of human and/or constructed language.
5. Acknowledgements
5. Acknowledgements
We acknowledge Nora Popescu for her exceptional mentorship, insightful feedback, and guidance throughout the development of this project. We also acknowledge Rory Foulger and Eryn Gillam for their thoughtful advice and steady support at each stage of the work, and Stephen Wolfram for his encouragement and for fostering an environment of exploration through the Wolfram Emerging Leaders Program (WELP). Any remaining errors are our own.
6. References
6. References
◼
Reiter, E., & Dale, R. (2000). Building natural language generation systems. Cambridge University Press.
◼
Vulgarlang. (n.d.). Vulgarlang — A fantasy language generator. https://www.vulgarlang.com/
◼
Xu, H. (2025, July 10). μLang — computationally generating a morphologically average conlang lexicon [Staff Picks]. Wolfram Community. https://community.wolfram.com/groups/-/m/t/3501302.
Appendix
Appendix
CITE THIS NOTEBOOK
CITE THIS NOTEBOOK
Computational generation of constructed languages
by Chengmin Xu (Daniel), and Qianheng Xu (Hendry)
Wolfram Community, STAFF PICKS, February 11, 2026
https://community.wolfram.com/groups/-/m/t/3638644
by Chengmin Xu (Daniel), and Qianheng Xu (Hendry)
Wolfram Community, STAFF PICKS, February 11, 2026
https://community.wolfram.com/groups/-/m/t/3638644