Custom Words, Affixes and Morphology

Adding new words

Before generating a language, you can add custom words to the Add and remove words. Use the format English word : part-of-speech. All words must have a part-of-speech (n = noun, v = verb, etc) to be valid:

  queen : n
  conlang, constructed language : n

To specify what the conlang word will actually be, add = conlang word (in IPA):

  queen : n = kalisi

This makes kalisi is the pronunciation of the word, not the surface spelling!

If you've already generated a language (either by loading a saved language, or by clicking Edit This Language), you can now change the vocabulary in the Add and remove words field. Remember to re-generate the language after making changes!

Removing words

After clicking Edit This Language, you can remove a dictionary entry by simply deleting the line from the Add and remove words field. If you haven't clicked Edit This Language, you can prevent a word from ever being generated by subtracting the word in Add and remove words:


When using the subtract method, it is not necessary to write the part-of-speech (unless there are two entries of the word with different parts-of-speech and you only want to remove one of them).

Derived words

Derived words are words that are built out of other words. For example, “government” is a noun which is built by combining the verb “govern” with the affix “-ment”. We are able to simulate these kinds of words in the Derived words field.

Adding affixes to words

Add affixes to words to create derived words as new word : part-of-speech = existing word-AFFIX.TAG

  government : n = govern-ACT.OF

Vulgar has various default affixes already populated in the Add or modify affixes input box. You can create brand new affixes in this box. For instance, Vulgar does not automatically create an affix for the opposite of something, as in English’s “un-” prefix. So you may choose to create this affix in Add or modify affixes:

  OPPOSITE = Random

You can name the affix tag whatever you want, but it must be in capitals to distinguish it from a regular word. The name can optionally have numbers or a full stop.

= Random means Vulgar will randomly create the affix for you. You can now use -OPPOSITE on words in the Derived words box:

  unhappy : adj = happy-OPPOSITE
  uncommon : adj = common-OPPOSITE

Be creative with affixes! Maybe your language uses affixes for things instead of full words, like:

  royal palace : n = house-ROYAL
  royal servant: n = servant-ROYAL

Affixes can be stacked on each other:

  unhappiness : n = happy-QUALITY.OF.BEING-OPPOSITE

In this scenario, QUALITY.OF.BEING first changes “happy” to “happiness”, then the OPPOSITE affix is added.

If the root word you’re trying to pull from the dictionary has two possible parts-of-speech (such as “laugh” as a verb and “laugh” as a noun), you can specify the part of speech like this:

  laughing : v = laugh:v-PROGRESSIVE

Defining affixes

Instead of using = Random, you can define what your custom affixes actually are in the following format:


This creates a suffix. A root word such as ama would change to amas

To create a prefix, the - symbol goes on the other side:


This changes ama to sama. Even though this is a prefix, the affix tag can be positioned after the word, eg happy-OPPOSITE, although OPPOSITE-happy is also valid.

Multiple processes can by applied by comma separating the commands (don’t forget a space after the comma!). The following rule attaches a prefix, then a suffix, to create a circumfix:

  OPPOSITE = s-, -s

This changes ama to samas. Again, the OPPOSITE tag can be positioned before or after the root word, however I suggest putting everything after, for consistency.

Affixes that are separate words

You can encode a whole word into an affix by separating the hyphen by a space:

  OPPOSITE = not -

This changes ama to not ama.

Sound changes

Sound changes can be encoded into an affix tag using the > symbol

  OPPOSITE = a > i

In this example, ama would change to imi. However, you may want to only change the final a in the word. To do this use >>

  OPPOSITE = a >> i

This changes ama would change to ami. Similarly, the first a in the word can be matched with <<

  OPPOSITE = a << i

This changes ama would change to ima

All sound change notation can be used, eg:

  OPPOSITE = u > i / _C#

Sound changes can also be combined with affixes:

  OPPOSITE = a >> i, -s, z-

This would change ama to zamis.


Infixes are affixes that go in the middle of a word. Eg, in Spanish the infix -it- turns a word into a diminutive version of the word: gato (“cat”) changes to gatito (“little cat”). The convention is to write infixes with hyphens either side of the infix (-it-) but the problem with this is it does not encode where in the word the infix should go. In Vulgar, we need to use sound changes with backreferences to achieve the effect:

  DIM = (C)(V)# > 1it2

1 refers to whatever was captured in the first brackets (the consonant before the final vowel) and 2 refers to the second brackets (the final vowel).

Changing to multiple choices

A choice between random affixes can be created using the bar symbol |. The following rule adds either an -s, -t or -p as the affix:

  OPPOSITE = -s|-t|-p

Similarly, the resulting sound change can be randomised with the | symbol:

  OPPOSITE = a >> i|o|e

Conditional IF and ELSE statements

There may be scenarios where you want to create conditional rules. You can do this based on whether a sound change pattern is found in a word:

  AFFIX.NAME = IF [this pattern is found] THEN [apply this set of rules] ELSE [apply a different set of rules]

For instance, let’s say your prefix is s-, but if the root word already starts in an s you want to the prefix to se- to avoid a double s. The # symbol represents a word boundary. So we can say:


This changes sama to sesama, while ama changes to sama. Note that IF, THEN and ELSE must be capitalised.

The ELSE condition is optional and can be omitted. Multiple IF statements are permitted:

  OPPOSITE = IF #s THEN se- IF s# THEN -e ELSE s-

Rules can be split over multiple lines (and indented) to make them easier to read:

    IF #s THEN
    IF s# THEN

In Vulgar, secondary IF statements are technically what other programming languages call "ELSE IF" statements. Meaning, they don't get tested if a previous IF condition is satisfied. To create a truly independent IF statement, you need to break up the rules up with a semi-colon (;)

  OPPOSITE = IF #s THEN se- ; IF s# THEN -e ELSE s-

In this example, a word such as sas changes to sesase, because both IF statements are tested and both are satisfied. Without the semi-colon, it does not test the second IF.

IF statements can apply affixes that match the vowel harmony of root word. Let’s say you have a vowel harmony system of front vowels (i, e, a) and back vowels (u, o). IF {i,e,a} will test for the presence of any of those vowels in the word, from there you can apply an affix that matches the vowel harmony:

  OPPOSITE = IF {i,e,a} THEN -se ELSE -so

NOT (!) and AND (&) operators

Use & to test for multiple conditions:

  OPPOSITE = IF #V & V# THEN se-

This tests that the word both begins with and ends with a vowel.

Use ! to test that it does not match a condition:

  OPPOSITE = IF ! #se THEN se-

This tests that the word does not start with se.

Explaining it all in English

Vulgar has a difficult time translating complex rules into plain English. If the program is struggling, you can write your own plain English explanation under the rule, starting with a single double quote character ":

    IF #s THEN
    IF s# THEN
    "If the word begins with s, add se-.
    Else if it ends with s, add -e.
    In all other cases add s-.
  NEXT.RULE = ...

Single use affixes

The affix tag -AFFIX is a special tag that generates a newly random affix each time it is used on a word in the Derived Words input box. -AFFIX may produce either a prefix or suffix, so -SUFFIX and -PREFIX can be used if you want to get more specific.

Compound words

Let’s say your word for “war” is kara and your word for “God” is kin, and you want a compound of those words karakin to mean “God of War”. Use the following syntax:

  God of War : n = war-god - to create a single compound word karakin
  God of War : n = war god - to create a compound word but separated by a space kara kin

Bound roots

Sometimes you may want to create a root word that doesn’t exist as a stand-alone dictionary entry, but that is only found with affixes attached to it. An example in English would be words like “absence” and “absent”, where it is somewhat unclear which word is derived from which, and may instead be interpreted as a bound root “absen-” attaching to affixes “-ce” and “-t”.

These are known as “bound roots”, since they must be bound to something else. To create a bound roots, add them with the special part-of-speech r for “root”:

  randomBoundRoot : r

  customBoundRoot : r = aku

Now both randomBoundRoot and customBoundRoot can be used in the derived words section to create other words. Be sure to give them labels that aren't also English words.