Rules
A rule rewrites one or more phonemes into others (or deletes or inserts them) whenever a shared surrounding environment matches. A language can have any number of rules, applied in order, and each rule sees the output of the one before it — so rules are a pipeline, not a set of independent checks.
What a rule expresses
Can do
- A single rule can bundle multiple correspondence pairs that share one environment — p, t, k → b, d, g / _ N is one rule, not three.
- A pair can delete a phoneme (→ ∅) or insert one into a gap that matches the environment (∅ →, epenthesis), not just substitute one phoneme for another.
- The environment on either side can require specific phonemes, group membership, a word boundary (#), and can mark any of those optional.
- Rules are ordered and reorderable, and each rule's effect feeds into the next — classic sound-change interactions (one change enabling or blocking a later one) work correctly because of this.
- Within a single rule, every match is found against the word as it looked before that rule ran, then applied all at once — so a rule never re-triggers itself on its own output in one pass.
Limitations
- A rule can't reorder sounds (metathesis) — it can only replace, delete, or insert in place.
- The environment only sees phoneme identity, group membership, and word edges — it has no concept of stress, tone, or syllable position, even though syllable shapes exist elsewhere in the app.
- A rule fires once per pass through the pipeline. It doesn't repeat itself to a fixed point — a change that should cascade across several segments needs the rule listed more than once, by hand.
- There's no way to express a negative environment ("not before X") beyond building a group that excludes X, and no way to combine two unrelated conditions ("A or B") beyond the same trick.
- If a phoneme matches more than one correspondence pair in the same rule (say, once by name and once via a group), the first pair in the list silently wins — nothing warns you the overlap exists.
When rules run
Can do
- Every rule in the language applies, in order, to every word produced by the Word Generator, before that word is shown to you.
- The live notation preview while editing a rule (t → d / V _ #) shows you exactly what you've built as you build it.
Limitations
- Rules only ever run at generation time. There’s no underlying/surface distinction and no re-application: editing, adding, or reordering a rule does not retroactively touch words already sitting in your Dictionary. And a word you type in by hand never passes through rules at all — rules only ever see generator output.
- There's no sandbox to type a word and watch a rule transform it — the only preview is the abstract notation string, not an applied example.
- Rules have no name, no grouping into stages ("Old Language → Middle Language"), and no branching for dialects — just one flat, ordered list per language.