Sound Changer: Help

Sound Changer can be used to apply ordered sound changes to words. It is intended for use by conlangers. The tool is entirely inspired by Mark Rosenfelder’s wonderful SCA² (Sound Change Applier 2). In fact, I wrote it only because I had ideas for additional features that I found useful for my own conlanging projects.

TL;DR for usage

Put your words, one per line, in the Input words field.
Put your sound change rules, one per line, in the order they should be applied, in the Sound Change Rules field.
Click the Apply! button.
See your results in the Output words field.

Sound change rules

A sound change rule consists of three parts: original (the sounds of the original word), replacement (what they turn into), and environment (in what relationship to other sounds does the change occur). The format is:

original > replacement / environment

You can use → instead of > between original and replacement. One looks nicer, one is easier to type.

The environment must always have an underscore _ which stands for the bit being replaced. Portions of environment can be placed either before or after the underscore, or both. If nothing is placed after the underscore, it means that anything will match. Thus, a_ means “after /a/, regardless of what follows”; ct_r means “between /ct/ and /r/”.

After the environment, you can include another slash (/) and another environment specification. If you do, this second environment will be interpreted as an exception.

Here are some examples:

Rule	Meaning
`i > e / ʃ_`	Changes /i/ to /e/ whenever it occurs after /ʃ/.
`c > t / a_a`	Changes /c/ to /t/ when it occurs directly between two /a/.
`c > t / a_a / ta_`	Changes /c/ to /t/ when it occurs directly between two /a/, except when what comes before the /c/ is not just /a/ but /ta/.

You can omit the environment entirely if it applies everywhere, unless you are also providing an exception. If you need to provide an exception in such a case, use the environment _, which matches everywhere.

Rule	Meaning
`c > t / _`	Changes /c/ to /t/ everywhere.
`c > t`	Shorter version of the above.
`c > t / _ / e_`	Changes /c/ to /t/ anywhere, except when it comes after /e/.

Word boundaries

Word boundaries are represented by the token #. Thus the rule u > o / _# changes /u/ to /o/ at the end of a word.

If you put whitespace in the middle of a “word” (i.e. if the “word” is really a phrase), that whitespace is also a word boundary. So if the line in your Input Words is pikachu pikachu, the rule above would change both of the /u/ since they are both right before a word boundary.

Nulls and epenthesis

A null (no sounds) is represented by either of the tokens 0 or ∅. (As with > versus →, one is easier to type, while the other looks nicer.)

Using null for the replacement part of the rule means that the original will be deleted in matching environments. So s > 0 / _# would delete /s/ at the end of words. c > 0 would delete /c/ everywhere. d > 0 / _ / a_ would delete /d/ everywhere, except after /a/.

Using null for the original part of the rule means that epenthesis (new sounds appearing out of “nowhere”) will happen in the specified environments, so 0 > n / e_t would cause /n/ to appear between any et sequence.

Metathesis (reversing)

The process of metathesis, reversing sounds, can be represented by using the special token \\ for the replacement part of the rule. So if you want /sk/ to become /ks/ at the end of a word, you would use the rule sk > \\ / _#. This can be used on as many sounds as desired; hemi > \\ would replace /hemi/ with /ihem/ everywhere it occurs.

Nonce categories

A nonce category (one which is bespoke for a single rule) can be created by enclosing multiple other tokens in curly braces { }. Thus, the rule {sm} > 0 / _# would delete either /s/ or /m/ when word-final.

Optional elements

Optional sounds can be specified in the environment (not in the original or replacement) by putting them in parentheses. For example, the rule e > i _(c)t would change /e/ to /i/ whenever the /e/ comes before /t/ or before /ct/.

Nesting of groups

Optional elements cannot be used in other optional elements, nor in a nonce category, nor a category definition; it would make no sense. A nonce category {ab} already means “if it’s /a/ or /b/”; it is already an option, as it were.
- An optional element can be used next to a category or nonce, of course: (d){ao} would mean “either /a/ or /o/, optionally with a /d/ before it”.
Nonce categories cannot be nested: if you mean “any one of /a/, /e/, /i/, or /o/”, you can just use {aeio}; there’s no need to do something like {ae{io}}.
- A nonce category can be used in an optional element: (t{sz}) would mean “Optionally, either one of /ts/ or /tz/.”
Normal categories can be used in an optional element or in a nonce category; {[V]s} might mean “any vowel or /s/”, while ([V])t could mean “/t/, optionally with a vowel before it (depending on the definition of [V]).
Normal category definitions can include other categories which were already defined (see Categories below). They cannot, however, include optional items or nonces; a category’s members must be fixed.

Backreferences and gemination

A backreference is represented by a dollar sign followed by one or more digits. It means “the Nth token of the original sounds being replaced.”

This allows you to do gemination! For example, if you defined a category [stop] for stops, then the rule [stop] > $1$1 means “A stop becomes the first sound of the sounds being changed, followed by another copy of the first sound of the sounds being changed.” In other words, a stop becomes the same stop followed by itself.

This also allows you to do degemination. Given the [stop] category from the previous example, then the rule [stop] > 0 / _$1 means “A stop becomes null if it is before the first sound of the sounds being replaced”, which in this case is the sound itself. Another way to do it would be [stop]$1 > $1, which means “A stop together and the same sound right after it become that same sound.”

Orthography fields

The Input orthography and Output orthography fields are used before and after the sound change rules. These allow you to handle things like digraphs while still making your sound change rules simple. The format of these rules is

in | out

For example, if your proto-language uses ⟨sch⟩ for /ʃ/, you can handle this with an input orthography rule:

sch | ʃ

On the other end of the sound changes, if your new language used ⟨sj⟩ for /ʃ/, you would have an output orthography rule:

ʃ | sj

As with the other input fields, within each field, the rules are applied in order. Consider these input rules:

ch | x sch | ʃ

You will never get /ʃ/ out of these rules, since the first one will turn all ⟨sch⟩ into “sx” before the second one applies. So you have to think about the ordering.

Multiple input orthographies

Supposing you want to apply the same sound change rules to a set of words, but their languages have different orthographies?

If you tag an Input Orthography rule with a prefix followed by a colon like German:, that rule will only apply to words which also have a German: tag in front of them in the word list.

You can use multiple language tags. Any orthography rule with no language tag will be applied to all words in the set.

For example, try setting the Input Orthography field to:

German: sch | ʃ French: ch | ʃ

and the Input Words to:

French: cherie German: schwimmen

The output words (unless you have rules to the contrary) would be:

ʃerie ʃwimmen

The language tags can be anything you like (within reason, I suppose) followed by a colon: Latin:, OHG:, Abkhaz:, YourFace:, etc. as long as you use each one consistently across your words and input orthography.

Saving and loading your work

To save your work, click Download. This will create a JSON file storing all five input fields (words, rules, categories, input orthography, output orthography) and download it to wherever your browser downloads files to. If you know how to read and edit JSON, it should make sense, should you decide to take an editor to it (if you find that easier than working directly in the Changer window).

To load your work, click Load, navigate the dialog box to the file you want, and open it. Easy!

Character palettes

The Show IPA and Show Extended checkboxes each cause a “palette” of characters to appear below the input fields. You can click on any character to copy it to the clipboard, ready to paste into your input fields. The “IPA” palette is every character or diacritic on the one-page official IPA chart; the “extended” palette is a selection of other characters.

When mousing over the characters, a tooltip will show the Unicode name of the character, plus the IPA meaning of the character (for diacritics on the official IPA chart). When clicked, you will see a message pop up for a couple seconds letting you know that the character was copied.

To use a combining diacritic, simply paste it after the character you are modifying. So type a, then click the acute accent ◌́ and paste it after the a. They should combine to form á. To use grouping diacritics (i.e. those which span two characters), enter the first character to be spanned, then paste in the diacritic, then enter the second character being spanned. This will give you results like: t͜s.

Why the selection on the “extended” palette?

In general, the extended palette shows “unusual” characters not in the basic Latin, Cyrillic, or Greek character sets that may be hard to type but which cannot be made by combining a “typical” letter with a diacritic. The choices may be a bit idiosyncratic.

At the beginning of the palette are a few helpful characters: null, arrow, proper angle brackets for when you’re writing about orthography, and a middle dot. You might not need these in the Sound Changer itself, but they’re available for you to copy to paste into other software as well.
Latin: I’ve added the “long S”, the “sharp S”, several Egyptological characters, and a few Old English characters including wynn and yogh. (Eth and thorn are already in the IPA palette.) Additionally we have a dotless I and J, the three Claudian letters (look them up, it’s fun trivia), and the three extra Volapük letters (also fun trivia).
Cyrillic: I’ve added the letters needed for Ukrainian and a few of the most interesting older ones (yat, the variants of yus, and some palatalized variants).
Greek: I’ve included the various forms of digamma, koppa, sampi, san, and sho, plus lunate sigmas.

Warning: Unicode character composition

Many letter/diacritic combos exist in Unicode as precomposed characters. That is, “a with an acute” exists as a single Unicode glyph. At a technical level, they are not the same as the combination of the a with the combining acute.

The Sound Changer normalizes your input fields so “what you see is what you get”. If a rule involves á in any way (input word, category definitions, anything), it will not matter whether it gets into your input field via the single-character or combining-character approach. A JSON file created when you Download your work is normalized as well.

⚠️ However, should you copy-paste the contents of your input fields into other software, the differences will still be there to haunt you.

If you care for technical reasons, the Sound Changer uses the NFC normalization; that is, after normalization, all characters that can be combined will have been combined.

Glosses

You can put a gloss on the line with each input word. Just include some whitespace and then a middle dot (•), then whatever you include on the rest of the line is a gloss. You need not include a gloss on every line to use the feature, just whichever lines you like. For example:

knabo • boy patro • father fratino • sister domo • house

When you click Apply, the output will include each word’s gloss.

Output formats and options

We’ve included the same output formats that the original SCA² supported. They are:

output: The default. Just the output word, followed by its gloss if any.
input → output: The input word with an arrow pointing to the output word, followed by its gloss.
output [input]: The output word (and its gloss) followed by the input word in square brackets.

Just pick the one you want from the Output format radio buttons.

Intermediate stages

Suppose you’re trying to create a new language Speakian from a proto-language, Proto-Speakian. So far, so good. But then suppose you come up with the idea that partway through your list of rules, the language has a distinct stage called Old Speakian.

If you define a sound change rule that begins with the special token -- (two hyphens, no space between them), it will define an intermediate stage in the language’s evolution. Then, if you check the Show intermediate stages checkbox, you will see those stages among your results when you click Apply.

If you do use intermediate stages, the output formats will look thus, assuming the input word is blob and the output word is blup.

output: displays all the intermediate stages (but not the original input word) before the output, separated by semicolons. For example, bloob; bloop; blup.
input → output: The whole chain of stages, input to output, separated by arrows: blob → bloob → bloop → blup.
output [input]: The square brackets will contain all the preceding stages back to the original input, separated by arrows: blup [bloop ← bloob ← blob].

Note that any text after the -- on a sound rule line which creates a stage is ignored, so you can safely put a comment after it like -- Old Speakian.

ℹ️ If you use input or output orthographies, they are applied before (input) and after (output) everything in the sound change rules, and they are not applied to an intermediate stage. So if you used orthography rules on each end of the process, and created one intermediate stage, the forms of the word you would see would be: (1) the original word before input orthography is processed; (2) the intermediate stage, which looks like the original word after input orthography and all the rules which apply before the stage; (3) the final form, which is the word after input orthography, all change rules, and the output orthography.

So: If you really really want to see the original word with only input orthography but no sound changes, add an intermediate stage at the very beginning of the rule list; if you really want to see the output word just before the output orthography is applied, add an intermediate stage at the very end of the rule list.

Sorting the output

If the Sort Output checkbox is checked, the output words will be sorted. Otherwise, they will be output in the order you entered the input words.

Note that the sorting is done in order of the final output word. If you show intermediate stages in either the output or input → output formats, this may not quite look right at first glance.

Comment lines

Any line in the orthography fields, or the words, rules, or categories lists, beginning with a # (after any leading whitespace, if any) is treated as a comment and is ignored in processing. It will however be included if you download a JSON file of your content, so it is preserved from session to session. For example, the input orthography might look like the following, but it will function exactly as described in the “Multiple input orthographies” section:

# Orthography rules for words imported from German German: sch | ʃ # Orthography rules for words imported from French French: ch | ʃ

Unlike glosses, comment lines in the input word list will not appear in the output word list, since you might be sorting the output words. But if you put them there and click Download, they will be in the downloaded file so they’ll be there for you when you work on the language again.

Syntax incompatibilities from SCA²

Although inspired by Mark’s SCA², the usage and syntax for the Sound Changer are different. Some of that has been noted in the documentation above, but just to highlight some key points:

The original and replacement parts of a rule must be separated by an arrow (→ or >), not by a slash (/) as SCA² uses.
Category names must be in square brackets, except when the category is being defined.
Nonce categories in SCA² use curly braces, rather than square brackets (e.g. {sm} instead of [sm]).

Why didn’t I just make it fully compatible?

Categories in SCA² did not need brackets, but they had to be one character long (unless you mucked with rewrite rules), and could result in conflicts with sounds: does “S” represent a category or did we use it for the ʃ sound because “S” is easier to type? Instead, category names can be multiple characters, even including whitespace and having the same characters used for sounds, at the cost of requiring us to put them in brackets: [V], [s], [front vowel], etc.
Categories in SCA² also had to be the first thing in the “original” part of a rule. Here they can be any part of a match, so one could transform a vowel and a stop following it in one rule, for example: [vowel][stop] > etc.
Using arrows for the change, square brackets for recurring categories, and curly braces for nonces, adheres more closely to the notation found in the Wikipedia article Phonological rule (referenced 17 Feb 2026). Square brackets there show featural things like [+ aspirated]; our categories are the nearest thing we have.

Acknowledgements

First and foremost, Mark Rosenfelder, who did this first, whose work inspired this, and whose resources for conlangers and conworlders are sine qua non for anyone in the hobby.
And, all my friends who provided encouragement and suggestions.

Finally, Sound Changer is dedicated to my friend C, who is deeply missed. Langlik vivã der Tanist.