Custom Words, Affixes and Morphology

Adding new words

Use the Add and remove words field to add a custom word to your language. 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

Remember, this assumes kalisi is the pronunciation of the word, not the surface spelling!

Removing words

Remove default English words with the minus symbol.

  -queen

It is not necessary to write the part-of-speech to remove the word (unless there are two entries of the word with different parts-of-speech and you only want to remove one of them). Alternatively, there is a Remove all default words option, if you want to start from scratch.

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:

  OPPOSITE = -s

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:

  OPPOSITE = s-

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

The left side of the arrow symbols is RegEx capable. RegEx allows you to do powerful pattern matching, like change u + any consonant (C) at the very end of a word (#) to i:

  OPPOSITE = uC# > i

Various uppercase letters can be used for classes of phonemes, for instance C to mean “any consonant” and V to mean “any vowel”. See full list of uppercase symbols here.

Sound changes can also be combined with affixes:

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

This would change ama to zamis.

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 RegEx pattern matches using the following syntax:

  AFFIX.NAME = IF [this regex pattern is in the word] THEN [apply this set of rules] ELSE [apply this 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:

  OPPOSITE = IF #s THEN se- ELSE s-

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:

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

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 [iea] 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 [iea] 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 ":

  OPPOSITE =
    IF #s THEN
      se-
    IF s# THEN
      -e
    ELSE
      s-
    "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 case that generates a newly random affix each time it is used. -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

Root words

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”:

  randomRootWord : r

  customRootWord : r = aku

Now both randomRootWord and customRootWord can be used in the derived words section to create other words (the program will not create words automatically from these roots). Be sure to give them labels that isn't also English words.