Whilst worldbuilding, I decided to make a conlang. It's named Leksah.

Leksah is heavily influenced by the programming language Haskell. As such, Leksah has only 3 parts of speech:

  • Literals, which usually correspond to nouns. These are always written titlecased. (Yep, like German!)

  • Functions, which usually correspond to verbs.

  • The particle "-el", which applies a function.

As such, Leksah has word order VSO.

Yet there is a special kind of literals: Numerals. There are infinite number of integers, and I cannot make every single new word for every integer.

Furthermore, it seems no natural languages can spell every integers. The maximum units are "vigintillion" for English, "무량대수"(無量大數) for (Sino-)Korean and so on.

That said, let me introduce some aspects of my world. The main residents of my world are angels (dubbed moderators in my world), and some of those whose "duties" are related to math (cryptologists in particular?) has obligations involving huge numbers. That's why my conlang must enable such numbers to be said.

So here's a sketch of how numerals would be dealt. Integers shall be written and said in decimal. Here's how digits are said:

  • 0 = "Nad" (from NADAZERO)

  • 1 = "Un" (from UNAONE)

  • 2 = "Bis" (from BISSOTWO)

  • 3 = "Ter" (from TERRATHREE)

  • 4 = "Kar" (from KARTEFOUR)

  • 5 = "Pan" (from PANTAFIVE)

  • 6 = "Sox" (from SOXISIX)

  • 7 = "Set" (from SETTESEVEN)

  • 8 = "Ok" (from OKTOEIGHT)

  • 9 = "Nov" (from NOVENINE)

Though these are literals, as an exception, they can be applied by "-el". In this context, it concatenates digits to make bigger numbers:

  • 42 = "KarelBis"

  • 108 = "UnelNadelOk"

  • 65535 = "SoxelPanelPanelTerelPan"

Note that the spellings are camelcased.

Yet I think there are some disadvantages compared to natural languages:

  • This scheme wastes time when saying a power of 10. "10000" is spelled "UnelNadelNadelNadelNad".

  • This scheme is very prone for a listener to accidentally omit or duplicate a digit, especially when the same digit is repeated.

How should I modify this scheme to avoid such situations? Is there any conlang can say arbitrarily large integers?

  • "Is there any conlang can say arbitrarily large integers?" - not a conlang, but an constructed extension to the English convention allows this - en.wikipedia.org/wiki/… Commented Jun 28, 2021 at 14:45
  • and to frame challenge your question, perhaps the moderators are mathematically perfect beings: they will never make mistakes when speaking a number; and unlike humans find no special significance in the powers of ten; that is to say they would find 4 294 967 296 (i.e 2^32) to be at least as interesting and important as 1 000 000 000, and so have no need for special words for powers of ten. Commented Jun 28, 2021 at 14:50
  • Not an answer, as this covers bases, but possibly helpful: googology.wikia.org/wiki/Misalian_base-naming_system Commented Nov 2, 2021 at 13:23

7 Answers 7


You could do what humans normally do when dealing with arbitrally long numbers - treat them as strings.
We don't normally use values higher than milion in daily life - would you dictate a 10 digit phone number* as

"Six bilions**, two hundred eighty three milions, one hundred eighty five thousands, three hundred seven"
Or as
"Six two eight three one eight five three zero seven"?

They could be grouped in sets of three digits (the holy trinity), and if you really wanted, you could prepend each set with triad ordering number (or names of saints if going for religious vibes)

"Six in 4th triad, two hundred eighty three in 3rd triad, one hundred eighty five in 2nd triad, three hundred seven in 1st triad".
"Six in name of Michael, two hundred eighty three in name of Joseph, one hundred eighty five in name of Lucas, three hundred seven in name of Adam".

* Please don't call it. Using a beginning of very important constant as example.
** Definition of bilion gets finicky based where you are, here means 1000 Milions.

  • The number is τ (or 2π) for those curious Commented Jun 28, 2021 at 14:29
  • 1
    @AlexLamson 01189998819991197253 would have been an even nerdier option :) Commented Jun 28, 2021 at 17:26
  • One could also group by other digit counts, as the Indian numbering system does - a new name occurs every two digits after the thousands - that is, 10^3, "thousand"; 10^5, "lakh"; 10^7, "crore"; 10^9, "arab"; 10^11, "kharab", etc. Commented Jul 10, 2021 at 18:14

In the spirit of functional programming, you can add run length encoding.

Practically speaking, we see that there is no more effective of a method for naming numbers than giving them a sequence of digits. This is exactly what we do in mathematics. 513843843246213513513813502162324713513541263 is simply best described as that series of digits.

So the issue is specifically that the people speaking your conlang come across cases with long strings of the same digit quite often (as we do).

The solution is to permit explicit run length encoding

The number 1000000 might be expressed as 1 (run 6 0) a 1 followed by a run of 6 0s. This would also solve the issue of repeat numbers in a number. You might describe 16333333337 as 1 6 (run 8 3) 7

If I can venture a guess as to how your Haskel based language works, I am guessing 1 6 (run 8 3) 7 would be read as "UnelSoxelConsRunelOkelTerSet," using "Run" as the phonem for this run operation, and inventing a new particle, "Cons" which starts a new cons list (you didn't mention this, but it strikes me as an essential particle for a Haskel based language. Haskell gets its power from directed acyclic graphs, not just sequences)

Note that the named quantities like million and billion are useful. They give us hints as to the rough size of the number before we hear every single digit. But for explicitness, run length encoding works fine. You might want to prefix large numbers with a number of digits as a hint.

For arbitrary large numbers, which may not run length encode well, a checksum may be in order. A well chosen check-summing scheme may also allow for correction of errors in communication, not just detection.


Both issues can be solved simultaneously.

Consider for a moment how you say 1 239 475 612 034 in English. It’s not (usually) said as:

one two three nine four seven five six one two zero three four

Instead, it’s read out as:

one trillion two hundred thirty nine billion four hundred seventy five million six hundred twelve thousand and thirty four

The ‘normal’ way to read it is much longer, but those extra words serve an important purpose, they provide information about where in the number you are, which in helps reduce errors (in information theory terms, they serve as a very limited form of in-band error correcting code).

The same feature of the language also makes powers of ten very compact.

For your language, you can go a step further, and make the names of the powers of ten composable. English does this to a limited degree for the tens and hundreds places (so, for example, you have ‘ten thousand’ and ‘one hundred million’), but there’s no reason that it needs to be limited to just a three-digit arrangement. The caveat is that I would expect digit grouping to match up with however wide this ends up betting before looping (so, for example, if you go with one million being the largest power of ten you have a special name for, I would expect the digit grouping in written form to separate digits into groups of 10).

  • That's an integer. Now, how do you say 1.239 475 612 034? No one says "1 decimal two hundred thirty-nine thousandths four hundred seventy-five millionths six hundred and twelve billionths and thirty four trillionths". It's "one decimal (string of digits)". When you give your credit card number over the phone to order something, do you say "one quadrillion, two hundred thirty-four trillion, five hundred sixty-seven billion, eight hundred ninety million, one hundred twenty-three thousand, four hundred fifty-six" or do you just say say "1234567890123456"? Commented Dec 22, 2021 at 20:27
  • 2
    @KeithMorrison The OP only asks for integers, and my suggestion does not preclude alternative methods for decimals or reading off digits. Commented Dec 22, 2021 at 21:57

For precise integers, I see no viable systematic alternative that covers them all up to arbitrary size. But often, you don't need precise integers with all digits specified, spelled out, and spoken. For unprecise integers you can design some spoken form of exponent notation (like 1.0E9 in some programming language notation).


If -el "applies", I'm not sure about using it between digits. By that logic, KarelBis would be 4 applied to 2, so 2^4. Going that route, and assuming base 10 is the more common counting system in your world, you would need a word for 10, eg. Dix (from French). So 1001 would be DixelDixelDixUn: 10 * 10 * 10 + 1. Or these moderators could use prime numbers (important in cryptography) to communicate among themselves. If -el is the concatenator for powers, and let's say -id is the concatenator for multiplication (and no concatenator for addition), then 4837560 would be TerelBisidTeridPanidSetidDixTeridKaridDixelDixKaridDixTer. That is, 2^3 x 3^1 x 5^1 x 7^1 x 13^1 x 443^1 with 443 = 4 * 10 * 10+4 * 10+3, though I don't see a way to put that in parenthesis. Harder than spelling out the digits!


You can have some fun with this.

If the moderators resemble humans and are not good at repeating identical strings an exact number of times, then you can use something like Hebrew numerals or Greek numerals but with short syllables. The idea being that you effectively have multiple series of digits that cover different place value positions. Combining this idea with a simple collection of syllables that run in some order will give you a number system that's pronounceable but lets you skip zeroes when the gaps can be determined from context.

One problem with a system like this is that it takes up a lot of space. Either many numbers will be homophones with non-numbers or the numbers will be occupying some very important real estate and the rest of the language will have to adapt.


After some thinking, I think I can confirm how it should. Let me self-plagiarize from this post on Code Golf SE, with respect to the updated phonology and orthography.

Though this conlang's numeral system is still essentially decimal, it expresses run-length encoding on zeros. (Thanks @Austin for suggestion)

The basic words for the nonzero digits are:

  • 1 = uma
  • 2 = piso
  • 3 = terra
  • 4 = qarte
  • 5 = pamta
  • 6 = soçi
  • 7 = sete
  • 8 = oto
  • 9 = mowe

Note that the vowels in these words are all positive. (Yep, now my conlang has vowel harmony.)

For every positive integer, with its decimal expansion, let d be the least significant nonzero digit.

  • First, d shall be spelled out like above.

  • Second, if d has any trailing zeros, the length of the zeros shall be spelled out recursively, with the lastly spelled word having its vowels replaced by their negative counterpart (represented by circumflexes).

  • Third, if d was not the most significant digit, "wa" shall attach to the lastly spelled word as a suffix. And then d and its trailing zeros (if any) shall be stripped off, and the remaining digits shall be spelled out recursively.

  • All the words spelling out an integer shall be hyphenated.


  • 1 = uma
  • 2 = piso
  • 7 = sete
  • 10 = uma-ûmâ
  • 11 = umawa-uma
  • 12 = pisowa-uma
  • 19 = mowewa-uma
  • 20 = piso-ûmâ
  • 42 = pisowa-qarte
  • 69 = mowewa-soçi
  • 100 = uma-pîsô
  • 109 = mowewa-uma-ûmâ
  • 440 = qarte-ûmâwa-qarte
  • 666 = soçiwa-soçiwa-soçi
  • 1945 = pamtawa-qartewa-mowewa-uma
  • 2000 = piso-têrrâ
  • 2022 = pisowa-pisowa-piso-ûmâ
  • 2080 = oto-ûmâwa-piso-ûmâ
  • 44099 = mowewa-mowewa-qarte-ûmâwa-qarte
  • 44100 = uma-pîsôwa-qartewa-qarte
  • 10^60 (one novemdecillion) = uma-soçi-ûmâ
  • 10^63 (one vigintillion) = uma-terrawa-sôçî
  • 10^63 + 2 × 10^33 (one vigintillion two decillion) = piso-terrawa-têrrâwa-uma-mowewa-pîsô
  • 10^100 (googol) = uma-uma-pîsô
  • 10^(10^100) (googolplex) = uma-uma-uma-pîsô

The asymptotic complexity of this numeral system has logarithmic upper bound. As for the lower bound, I haven't calculated it precisely, but it is at most super-logarithmic.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.