Default

This notation basically just cleans up the number without really changing it much. What it actually does depends on the size of the number:

• Numbers below 1e12 are written out as plain numbers (with commas). Numbers below 1,000 are written with four significant figures, larger numbers are just rounded to the nearest integer.
• Numbers above 1e12 are written in scientific notation.
• For larger numbers, there may be e's placed in front of the number - for example, 10¹⁰¹⁰⁰ is written as e1e100, and 10^^5 is written as ee1e10,000,000,000. The visible exponent will never go above 1e12, as that's the point when another e is added to the front.
• If there would be more than five e's in front of the number like this, it switches to being written in hyperscientific notation instead.


• A similar progression is followed for tiny numbers: unabbreviated decimals like 0.01, then scientific notation like 1e-12, then scientific notation with multiple e's like ee-1e20, then hyperscientific like 1F-9 (in this case, the hyperexponent is written with a negative sign to indicate we're working with a reciprocal, which isn't how hyperscientific notation actually works but it's what this notation does).

Explanations on scientific and hyperscientific are found in their respective boxes.
As the name implies, this is the default notation that other notations can pull from, so generally other numbers left over within other notations (such as the mantissa and exponent in scientific notation) are themselves written in Default notation.

Scientific

Scientific notation is the most well-known way of abbreviating large numbers. Scientific notation expressions come in the form XeY for some numbers X and Y, where X must be between 1 (inclusive) and 10 (exclusive). XeY means X * 10^Y, so 1e10 means 10,000,000,000 and 5e50 means 5 * 10⁵⁰. The number before the e is called the mantissa, and the number after the e is called the exponent. Numbers below 1 have negative exponents, so 0.03 is 3e-2.
Larger numbers have e's placed in front of the number, with each e in front adding a 10 to the bottom of a power tower, so e4.5e18 means 10^{4.5 * 1018}, and eee5e12 means 10^{10105 * 1012}. If there would be more than five e's in front of the number like this, those e's are truncated into an (e^N) expression, so (e^10)1e100 means eeeeeeeeee1e100 (that's 10 e's in front). For the highest numbers supported by Eternal Notations, that amount of e's can get large enough to be written in scientific notation itself.

Engineering

Engineering notation is similar to scientific notation, but the exponent is always a multiple of 3, which means the mantissa ranges between 1 and 1,000 instead of between 1 and 10. This is done because powers of 1,000 often feel more distinct from each other than powers of 10 do. For example, 10¹⁴ is written as 1e14 in scientific notation, but it's written as 100e12 in engineering notation.
Once the number gets large enough to have e's in front, it's still only the last exponent that must be a multiple of 3: for example, a googolplex, which is written as e1e100 in scientific notation, is written as e10e99 in engineering notation. The multiple of three restriction does not apply to the amount of e's, so the N in an (e^N) expression can still be any integer.

Logarithm

This notation writes numbers based on their base-10 logarithm - in other words, it's basically scientific notation without the mantissa. For example, 10³⁰ is written as e30. 2 is written as e0.301, because 10^0.301 is around 2, i.e. the base-10 logarithm of 2 is around 0.301. For larger numbers, multiple logarithms may be taken, indicated by there being multiple e's in front: for example, 10¹⁰¹⁰⁰ is written as ee100. If there would be more than five e's in front of the number like this, those e's are truncated into an (e^N) expression, so (e^10)14 means eeeeeeeeee14. For the highest numbers supported by Eternal Notations, that amount of e's can get large enough to be written in scientific notation.

Hyperscientific

Hyperscientific notation is a variation on scientific notation that handles tetration instead of exponentiation. Hyperscientific notation expressions come in the form XFY for some numbers X and Y, where X must be between 1 (inclusive) and 10 (exclusive). XFY means 10^10^10...^X with Y 10's, so 10^10^3 becomes 3F2, 10^10^10^4.5 becomes 4.5F3, and 5 becomes 5F0. For the highest numbers supported by Eternal Notations, the hyperexponent (the number after the F, indicating the height of the power tower) can get large enough to also be written in hyperscientific notation, at which point the mantissa is no longer written: for example, 10^^(10^10) is written as F1F2, which means F(1F2), which means a power tower that is (1F2) tens tall, and 1F2 is 10^10.

Power Tower notation is a variation on Hyperscientific where the hyperexponent is 1 less than it would be for hyperscientific, which means the mantissa ranges between 10 and 10^10 instead of ranging between 1 and 10.

Super Logarithm

Normal logarithms are an inverse of exponentiation: log_b(x) returns a number y such that b^y = x. Super logarithms are the same thing, but for tetration instead of exponentiation: slog_b(x) returns a number y such that b↑↑y = x. Super Logarithm notation writes numbers in terms of their base-10 super-logarithm: for example, 10^10^10^10 is written as F4.

Pentation

Pentation is the fifth hyperoperator, defined as repeated tetration and written as x↑↑↑y, which is defined as x↑↑x↑↑x↑↑x...↑↑x with y x's in that "tetration tower". Penta-Scientific is like Hyperscientific and Penta-Logarithm is like Super Logarithm, but using pentation instead of tetration. Pentation grows yet faster still than tetration, too fast for even break_eternity.js to handle, so you won't see a penta-exponent above 2.4 or so in these two notations - even for a library designed to handle tetration, pentation is just too strong.

Natural Logarithm

For complicated reasons (mostly calculus), the most "natural" base for a logarithm is not 10, but rather a number known as e, a.k.a. "Euler's number", which is around 2.71828. The base-e logarithm is called the natural logarithm, often written ln(x) instead of log_e(x). The three notations here are equivalents of Logarithm, Super Logarithm, and Penta-Logarithm that use e as their base instead of 10.

Double Logarithm

A variant of logarithm notation where the amount of iterations is always a multiple of 2. It's 2 by default, but then it becomes 4, then 6, and so on for larger numbers.

Binary

Binary, a.k.a Base 2, is a way of writing numbers that only uses the digits 0 and 1. Our normal way of writing numbers is Base 10, meaning the place values are 1, 10^1, 10^2, 10^3, and so on. In binary, the place values are 1, 2^1, 2^2, 2^3, and so on, so "10110" means 1 * 2^4 + 1 * 2^2 + 1 * 2^1 = 16 + 4 + 2 = 22.

Binary is the second-most used number base in the world, as it's the base used by computers: whether it means "off and on" or "positive and negative", binary is easy to express in computer circuits, so it's what computers use to do arithmetic.

This notation follows the same progression as Default notation, but in binary instead of decimal. In the scientific and hyperscientific portions, 2 is used as the base of the exponentiation instead of 10, so 1e110 means 1 * 2^6.

Binary (ı, l) comes from the YouTube video the best way to count, a video focused on binary, and among its many suggestions is to use simpler digits for binary specifically: a short line for 0, a long line for 1. The two characters used here are close-enough approximations of those lines.

Ternary

Ternary, a.k.a Base 3, is a way of writing numbers that only uses the digits 0, 1, and 2. Our normal way of writing numbers is Base 10, meaning the place values are 1, 10^1, 10^2, 10^3, and so on. In ternary, the place values are 1, 3^1, 3^2, 3^3, and so on, so "2201" means 2 * 3^3 + 2 * 3^2 + 1 = 54 + 18 + 1 = 73.

While ternary is the second-simplest number base, and it's seen a few attempts to use it, ultimately it's not used much in the modern world.

This notation follows the same progression as Default notation, but in ternary instead of decimal. In the scientific and hyperscientific portions, 3 is used as the base of the exponentiation instead of 10, so 1e201 means 1 * 3^19.

Quaternary

Quaternary, a.k.a Base 4, is a way of writing numbers that only uses the digits 0, 1, 2, and 3. Our normal way of writing numbers is Base 10, meaning the place values are 1, 10^1, 10^2, 10^3, and so on. In quaternary, the place values are 1, 4^1, 4^2, 4^3, and so on, so "3012" means 3 * 4^3 + 1 * 4 + 2 = 192 + 4 + 2 = 196.

Each quaternary digit represents two binary digits, so in theory quaternary could be used as a way to compress binary to make it slightly more readable, but in practice octal and hexadecimal are better bases to do that with.

This notation follows the same progression as Default notation, but in quaternary instead of decimal. In the scientific and hyperscientific portions, 4 is used as the base of the exponentiation instead of 10, so 1e32 means 1 * 4^14.

Seximal

Seximal, a.k.a Base 6, is a way of writing numbers that only uses the digits from 0 to 5. Our normal way of writing numbers is Base 10, meaning the place values are 1, 10^1, 10^2, 10^3, and so on. In seximal, the place values are 1, 6^1, 6^2, 6^3, and so on, so "5241" means 5 * 6^3 + 2 * 6^2 + 4 * 6 + 1 = 1,080 + 72 + 24 + 1 = 1,177.

Seximal was originally called "senary". The name "seximal" came from the video a better way to count by jan Misali, which highlights properties of seximal that make it a powerful and useful base for its size. Like most number bases other than decimal, binary, and powers of binary, though, seximal doesn't see much real-world use.

This notation follows the same progression as Default notation, but in seximal instead of decimal. In the scientific and hyperscientific portions, 6 is used as the base of the exponentiation instead of 10, so 1e43 means 1 * 6^27.

Octal

Octal, a.k.a Base 8, is a way of writing numbers that only uses the digits from 0 to 7. Our normal way of writing numbers is Base 10, meaning the place values are 1, 10^1, 10^2, 10^3, and so on. In octal, the place values are 1, 8^1, 8^2, 8^3, and so on, so "736" means 7 * 8^2 + 3 * 8^1 + 6 = = 448 + 24 + 6 = 478.

Each octal digit represents three binary digits, so octal has sometimes been used as a way to compress binary and make it more readable, though hexadecimal remains a more popular way to do so.

This notation follows the same progression as Default notation, but in octal instead of decimal. In the scientific and hyperscientific portions, 8 is used as the base of the exponentiation instead of 10, so 1e70 means 8 * 6^56.

Duodecimal/Dozenal

Duodecimal, also called "Dozenal", is Base 12, a way of writing numbers that uses twelve digits instead of ten. Our normal way of writing numbers is Base 10, meaning the place values are 1, 10^1, 10^2, 10^3, and so on. In base 12, the place values are 1, 12^1, 12^2, 12^3, and so on, so "418" means 4 * 12^2 + 1 * 12^1 + 8 = 576 + 12 + 8 = 596. Base 12 needs two extra digits beyond the ten digits we're familiar with - what those two digits are depends on the version of base 12 being used.

Unlike other non-decimal number bases, base 12 has a serious following, with supporters that believe it's superior to base 10 and that society should switch to writing numbers in base 12, such as the Dozenal Societies of America and Great Britain. It's because of this following that we have two names and three notations for this base: "duodecimal" is the name for base 12 that matches up with the names for other bases, but the supporters of base 12 don't want it to have a name that derives from base 10, so they go with "dozenal". The same applies to the digits used for ten and eleven: the digits A and B are used for duodecimal since it's customary to use letters for digits beyond 9 in higher bases, but for dozenal there are different proposals: ↊ and ↋ are digits specifically made for use with dozenal, but since computers don't always support those characters, some use X and E instead.

These notations follow the same progression as Default notation, but in duodecimal/dozenal instead of decimal. In the scientific and hyperscientific portions, 12 is used as the base of the exponentiation instead of 10, so 1e99 means 1 * 12^117. Since uppercase letters may be used as digits, hyperscientific uses # instead of an uppercase F.

Hexadecimal

Hexadecimal, a.k.a Base 16, is a way of writing numbers that uses sixteen digits instead of ten. Our normal way of writing numbers is Base 10, meaning the place values are 1, 10^1, 10^2, 10^3, and so on. The extra digits used for ten, eleven, twelve, thirteen, fourteen, and fifteen are A, B, C, D, E, and F respectively. In hexadecimal, the place values are 1, 16^1, 16^2, 16^3, and so on, so "A4C" means 10 * 16^2 + 4 * 16^1 + 12 = = 2,560 + 64 + 12 = 2,636.

Each hexadecimal digit represents four binary digits, so hexadecimal is often used by low-level programming languages to truncate binary into a more readable form for humans.

This notation follows the same progression as Default notation, but in hexadecimal instead of decimal. In the scientific and hyperscientific portions, 16 is used as the base of the exponentiation instead of 10, so 1eA5 means 1 * 16^165. Since uppercase letters may be used as digits, hyperscientific uses # instead of an uppercase F.

Balanced Ternary

Balanced ternary is a way of writing numbers that's similar to regular ternary. The place values are still 1, 3, 3^2, 3^3, and so on, but whereas the digits in regular ternary are for 0, 1, and 2, the digits in balanced ternary are for 0, 1, and -1. In this notation, the digits are 0 (for 0), + (for 1), and - (for -1). For example, 2 is +- (3 - 1), 10 is +0+ (9 + 1), and 22 is +-++ (27 - 9 + 3 + 1). Unlike normal number bases, balanced ternary doesn't need a negative sign to place in front of negative numbers: to convert a number to its negative in balanced ternary, just turn all the +s into -s and vice-versa. For example, -2 is -+ (-3 + 1), -10 is -0- (-9 - 1), and -22 is -+-- (-27 + 9 - 3 - 1).

This notation follows the same progression as Default notation, but in balanced ternary instead of decimal. In the scientific and hyperscientific portions, 3 is used as the base of the exponentiation instead of 10, so +.+-e++-- means (1 + 2/9) * 3^32. Because of the digits used, the range of the mantissa in balanced ternary is not from 1 to 3, but rather from around 0.5 (+.----...) to 1.5 (+.++++...).

Bijective Decimal

"Bijective" decimal is a number base similar to regular decimal. The place values are still 1, 10, 10^2, 10^3 and so on, but unlike decimal, bijective decimal does not have a digit for zero. Since there's no zero digit, ten can't be written as "10", so ten gets its own digit, that being A. Eleven can still be written as "11", so it is. 20 is written as "1A", 100 is "9A", 101 is "A1", 1,000 is "99A", and so on. The lack of a zero digit means non-whole numbers can't be written in this system, so this notation rounds to the nearest whole number. This notation follows the same progression as Default notation, but in bijective decimal instead of regular decimal. Since uppercase letters may be used as digits, hyperscientific uses # instead of an uppercase F.

Standard

In real life, one of the most common ways to abbreviate large numbers (other than scientific notation), especially when it comes to money, is to use abbreviations of the names "thousand", "million", "billion", and so on, so 500 million would be written as "500 M". This is what "Standard" notation does (the name "Standard" was chosen by Antimatter Dimensions, because at the time it often was the standard way incremental games abbreviated numbers). Standard notation works well for smaller numbers like millions and trillions, but the further you go, the more ridiculous and less readable it gets. Eternal Notations has three different varieties of Standard, which differ in the abbreviations they use to represent each -illion name but share the same general progression: the notation just called "Standard" uses prefixes chosen by MathCookie (the creator of Eternal Notations), AD Standard uses the prefixes that Antimatter Dimensions uses, and Aarex Standard uses prefixes chosen by Aarex Tiaokhiao, a prominent figure in the incremental games community. I'll start by explaining MathCookie's Standard, then I'll go back and explain how the other two differ from it.

The first few -illions have their own names and thus their own prefixes: k for thousand (10³), M for million (10⁶), B for billion (10⁹), T for trillion (10¹²), Qa for quadrillion (10¹⁵), Qi for quintillion (10¹⁸), Sx for sextillion (10²¹), Sp for septillion (10²⁴), Oc for octillion (10²⁷), No for nonillion (10³⁰), and Dc for decillion (10³³). After those first few, the -illions follow a place-value system where the -illions for 1 through 9, multiples of 10 from 10 through 90, and multiples of 100 from 100 through 900 each get their own names, and the rest combine these names. The prefixes for the unit position are U, D, T, Qa, Qi, Sx, Sp, O, and N, the prefixes for the tens position are Dc, Vg, Tg, Qg, Qq, Sg, St, Og, and Ng, and the prefixes for the hundreds position are Cn, Dn, Tc, Qe, Qu, Sc, Si, Oe, and Ne. For example, the 345th -illion, with a value of 10^1,038, is abbreviated as QiQgTc.
After the hundreds, though, the only -illions that get new names are powers of 1,000-numbered -illions, which have the smaller prefixes placed in front of them to multiply them, with hyphens separating each power of 1,000. The thousandth -illion, a millillion (10^3,003) is abbreviated as Ml, so the 49,824th -illion (10^149,475) is written as NQgMl-QaVgOe. At this point, the names start following the -illion scheme devised by Jonathan Bowers, which has become the standard for the names of huge -illion numbers. The next few -illions with their own prefixes are the thousandth, millionth, billionth, trillionth, and so on -illions, whose names follow the small SI prefixes (milli, micro, nano, pico, and so on); the prefixes for these in Standard notation are Ml, Mc, Na, Pc, Fm, At, Zp, and Yc. ronto and quecto weren't part of the SI prefixes yet when Bowers made his system, so the following "power of a thousand" -illions, a.k.a "Tier 2 illions", use made-up extended SI prefixes: Xn, Vc, Mec, Duc, Tec, Ttc, Pnc, Hxc, Hpc, Otc, and Enc. For example, the 123,456,789,012th -illion would be written as TVgCnNa-SxQqQeMc-NOgSiMl-DDc. The "tier 2" illion names themselves enter a place value system after the first 19 of them, primarily using greek number prefixes as their name inspirations: the unit position prefixes are Me, Du, To, Tt, Pn, Hx, Hp, Ot, and En, but entries 10 through 19 also use those prefixes from Vc to Enc instead of being [ones digit]Vc, then 20 and above go back to the usual "ones + tens". The tens position prefixes are Vc, Ic, Ta, Te, Pe, He, Ht, Oa, and Ea, and the hundreds position prefixes are Hc, Dh, Th, Tth, Ph, Hxh, Hph, Oh, and Eh.
Like before, the next tier 2 illions to get their own names are the thousandth, millionth, billionth, and so on - these are the "tier 3" illions, which start with the large SI prefixes instead of the small ones: Ki (for reference, Ki is around 10^{3 * 103003}), Mg, Gg, Tr, Pt, Ex, Zt, Yt. Then the SI prefixes give way to Greek-like names again, but this time those Greek names are somewhat warped: Xe, Da, Hd, Dok, Tad, Ted, Pd, Ed, Zd, Yd, and Nd. Underscores are used to separate tier 3 illions within a single tier 2 illion, so the 45,321,905th tier 2 illion would be written as PnTeMg_MeIcThKi_PnEh. After the first 19 tier 3 illions, the tier 3 illions enter their own place value system: the first few ones place prefixes are Hd, Di, and Ti, then the ones from 4 to 19 match up with the Tr, Pt, Ex... sequence given before. The tens position prefixes are Da, Ik, Tak, Tek, Pk, Ek, Zk, Yk, and Nk, and the hundreds position prefixes are Ho, Bo, Tro, Tot, Po, Eo, Zo, Yo, and Nt.
Finally, the fourth tier. The first fourth tier -illion, which is the thousandth third tier -illion, is Ka. Tildes (~) separate fourth tier -illions within a single third tier -illion. Unlike with the lower tiers, when a tier 3 -illion is used as a prefix on a tier 4 -illion, the first few prefixes are different: as prefixes, the tier 3 -illions from 2 to 9 become Dl, Ta, Tl, Pl, El, Zl, Yl, and Nl, then the rest of the prefixes (10 to 999) are the same as the corresponding plain tier 3 -illion (Da, Hd, Dok... up to XeNkNt). The fourth tier -illions start with warped SI prefixes but then start using the names of increasingly large astronomical objects: Ka, Mj, Gj, As, Lu, Fr, Jv, Sl, Bt, Gx, Go, Sp, Vs, and Mu.
This is where the system ends: Mu stands for a "multillion", the largest -illion name in Bowers's system, with a value of around 10^10^10^(3 * 10^42). This means that the names run out at 10^10^10^(3 * 10^45), so for numbers larger than that, they're placed inside the brackets of an Il() expression, which means the "n"'th illion (where n is whatever's inside the parentheses): Il(Mu), for example, would be the 10^10^10^(3 * 10^42)'th -illion, which is around 10^10^10^10^(3 * 10^42). If multiple layers of Il() need to be applied, they're written as Il^2(), Il^3(), and so on, and once the amount of Il() layers, each one adding a 10 to the bottom of the power tower goes above 1,000, the number becomes written purely in terms of the amount of Il layers, with that amount of letters itself written in Standard notation, so Il^1 M is around 10↑↑1,000,000.

AD Standard is the version of Standard used by Antimatter Dimensions, which to my knowledge is the first version of Standard that ever went past 2¹⁰²⁴. The first few prefixes are K, M, B, T, Qa, Qt, Sx, Sp, Oc, No, and Dc. The ones position prefixes are U, D, T, Qa, Qt, Sx, Sp, O, and N, the tens position prefixes are Dc, Vg, Tg, Qd, Qi, Se, St, Og, and Nn, and the hundreds position prefixes are Ce, Dn, Tc, Qe, Qu, Sc, Si, Oe, and Ne. The tier 2 illions are in all-caps here: MI, MC, NA, PC, FM, AT, and ZP... and that's where it ends, as Antimatter Dimensions only goes up to around e9e15, which is in the FM range (AT and ZP are present in the code of the game, though). Therefore, the Il() thing gets going after that.

Whereas Antimatter Dimensions Standard stops early, Aarex's Standard goes all the way up to the limit of Bowers's -illions, just as MathCookie's Standard does. I'm not going to go into detail on all the prefixes; check out Aarex's list of them, which is the source of Aarex's Standard, if you want the full list. The most notable difference comes in the form of the separators: hyphens are still used to separate tier 2 -illions, but tier 3 -illions are separated via a' instead of _, and tier 4 -illions aren't separated at all; for tier 4 specifically, tier 3 prefixes or suffixes on them chop off the beginning or ending letter of the tier 4 -illion. Also, rather than using Il() larger than the last prefix, is uses MXS-, where MXS-(n) just means 10^n, so MXS-M would mean 10^(1 M)... though for numbers large enough that MXS- is needed, MXS- and Il() are essentially the same.

Long Scale

In English-speaking countries, -illion names use the "short scale", in which each -illion is 1,000x the previous: a billion is a thousand millions (10⁹), a trillion is a thousand billions (10¹²), a quadrillion is a thousand trillions (10¹⁵), and so on. However, many European languages use the "long scale", in which each -illion is 1,000,000x the previous: a billion is a million millions (10¹²), a trillion is a million billions (10¹⁸), a quadrillion is a million trillions (10²⁴), and so on. In the short scale, the n^th -illion has a value of 10^{3n + 3}, while in the long scale the n^th -illion has a value of 10⁶ⁿ. The Long Scale notations are like Standard (one for each of the three variations of Standard), but using the long scale instead of the short scale. Because the -illions go up by a factor of a million each time instead of a thousand, Long Scale does not abbreviate thousands with k/K, choosing instead to just leave the thousands as is. (Some long-scale languages have the term "milliard" for a thousand millions, "billiard" for a thousand billions, and so on, but these notations do not bother with that.)

Mixed Scientific

Standard notation is useful for the first few -illions, but quickly becomes unwieldy starting somewhere between decillions and centillions (where exactly it becomes unwieldy is subjective, but it's somewhere in there). Scientific notation is more "boring" than Standard and isn't as intuitive as Standard for smaller numbers like millions and billions, but it makes much more sense than Standard for larger numbers. Mixed Scientific is a compromise between the two: it uses Standard for smaller numbers, then switches to Scientific for larger ones. When the exponent in the scientific notation gets large enough, it will itself be written in Standard up to the same limit, and only then does an e get placed in front. Similarly, once the N in (e^N) gets large enough, it starts being written in Standard and then switches to scientific.
Eternal Notations has mixed scientific varieties for all six versions of Standard/Long Scale, and what the standard-to-scientific limit is depends on the variety:

• MathCookie's Standard uses Standard up through Vg, as vigintillion is the last -illion recognized as an official word in dictionaries (centillion is too, but-illions 21 through 99 are not).
• AD Standard uses Standard up through No, as that's what Antimatter Dimensions's Mixed Scientific notation does.
• Aarex's Standard uses Standard up through De (though this was an arbitrary decision made for Eternal Notations, as Aarex has not to my knowledge ever addressed mixed scientific for his Standard).

Letters

Letters notation, which was popularized by Antimatter Dimensions but was used in some variety in several incremental games beforehand, is similar to Standard notation in that it splits a number into a power of 1,000 and a coefficient on that power, but whereas Standard uses abbreviated versions of the names "thousand", "million", "billion", and so on, Letters uses lowercase letters in order: a for 10³, b for 10⁶, c for 10⁹, d for 10¹², and so on. For example, 20,500 is 20.5a, and 593,000,000 is 593b.
The system keeps going after z: the next power of 1,000 after z uses aa, then next is ab, then ac, then ad, and so on. ba comes after az, then bb, then bc, and so on. After zz is aaa, after zzz is aaaa, and so on. This means that the powers of 1,000 are written in a "bijective base 26" with letters as the digits.
Having a bunch of lowercase letters is as far as the notation goes elsewhere, but Eternal Notations goes much further. Once there are too many letters, the notation switches to a number with a single uppercase A, where the uppercase A indicates that the number represents how many lowercase letters would be in the expression if it was fully expanded without the A: for example, 50A means 1aaaaaaa... with 50 a's. For fractional numbers with an uppercase A, you can think of the fraction as the logarithmic distance from one amount of letters to the next: for example, 14.5A means "halfway between 14A and 15A", which is around 1fcoyj... with 14 letters in there. Once the number with the A gets over 1,000, the lowercase letters return: for example, 20Ab means 1aaaaa... with 20b = 20,000,000 a's. An uppercase B indicates that the number represents the amount of lowercase letters in an expression with an uppercase A: for example, 500B means 1Aaaaaaa... with 500 a's. Likewise, an uppercase C means the number is the amount of lowercase letters in a B expression, a D means the number is the amount of lowercase letters in a C expression, and so on; each uppercase letter is two power-tower layers higher than the previous one. Like the lowercase letters, the uppercase letter after Z is AA, then AB is next, then AC, and so on, with BA after AZ, AAA after ZZ, and so on. Finally, once there's too many uppercase letters to show, you get an expression with an @, where the number indicates the amount of uppercase letters that would be in the expression: for example, 32@ means 1AAAA... with 32 A's.

Alphabet

Alphabet notation, the notation used in the games created by TopCog, is similar to Letters notation, but it's not quite the same. Letters are written before the number instead of afterwards, so 100,000,000 is b100. Instead of going to multiple letters after z, the uppercase letters come next, so after z is A, then B, and so on. Whereas Letters notation uses bijective base 26, Alphabet uses regular base 53; this means it has a zero digit, which is ~, so after Z is a~, then aa. aA is after az, b~ is after aZ, ba is after b~, A~ is after zZ, a~~ is after ZZ, a~a is a~~, aa~ is after a~Z, aaa is after aa~, a~~~ is after ZZZ, and so on.
Since the uppercase letters are used as regular digits instead of a second "tier" of letters, the tiers are handled differently: each tier uses the same letters, but the tiers are separated with a |. For example, a|500 means aaaa...1 with 500 a's, a|a40 means aaaa...1 with a40 = 40,000 a's, b|120 means a|aaaaa...1 with 120 a's after the |, A|75 means z|aaaaaa...1 with 75 a's, and so on. This also applies for the third tier, so a||40 means aaaaaa...|1 with 40 a's.
The part of the notation with the lowercase and uppercase letters is used in TopCog's games, but those games never get to numbers nearly as high as Eternal Notations does, so the higher tiers of letters with the |'s separating them were made up by MathCookie, though he tried to do something that he felt fit with the notation.

Greek Letters

Greek Letters and Greek Alphabet are variations of Letters and Alphabet that use the Greek alphabet instead of the Latin alphabet. For Greek Letters, the lowercase and uppercase Greek letters replace the lowercase and uppercase Latin letters, and @ is replaced by Ϝ, which is one of the old abandoned Greek letters. Greek Alphabet uses both the lowercase and uppercase Greek letters, with ϙ (another abandoned letter) used as the zero digit. AD Greek Letters is the "Greek Letters" notation in the Antimatter Dimensions notations, which is actually an Alphabet variation rather than a Letters variation, as it uses both lowercase and uppercase letters in the same digit set like Alphabet does. However, AD Greek Letters uses bijective base 48 instead of regular base 49, i.e. it does not have the zero digit, so αα comes right after Ω instead of αϙ coming between the two like it does in Greek Alphabet.

Emoji

Originally called "Cancer" notation by Antimatter Dimensions, Emoji notation is a variant of Letters notation where each letter is replaced with an emoji.
The emojis were chosen to correspond to their letters: 😠 is a ("angry"), 🎂 is b ("birthday"), 🎄 is c ("Christmas"), 💀 is d ("death"), 🍆 is e ("eggplant"), 👪 is f ("family"), 🌈 is g ("gay"), 💯 is h ("hundred"), 🍦 is i ("ice cream"), 🎃 is j ("jack-o-lantern"), 💋 is k ("kiss"), 😂 is l ("laughing"), 🌙 is m ("moon"), ⛔ is n ("no"), 🐙 is o ("octopus"), 💩 is p ("poop"), ❓ is q ("question mark"), ☢ is r ("radioactive"), 🙈 is s ("see no evil"), 👍 is t ("thumbs up"), ☂ is u ("umbrella"), ✌ is v (I guess this could be "victory", but I think it was just chosen because the hand sign looks like a V), ⚠ is w ("warning"), ❌ is x (this one's pretty self-explanatory), 😋 is y ("yummy"), and ⚡ is z ("zap").
Whereas the emoji for the lowercase letters were chosen by the creators of Antimatter Dimensions, MathCookie chose the emoji for the uppercase letters (and @): 🚨 is A ("alarm"), 🅱️ is B (also self-explanatory), 🍒 is C ("cherries"), 😈 is D ("demon" or "devil"), 💥 is E ("explosion"), 👠 is F ("fashion", or perhaps "fancy"), 🔫 is G ("gun"), 🏥 is H ("hospital"), 👀 is I ("eyes" starts with E, but it sure sounds like the letter I), 🤹 is J ("juggler"), 😵 is K ("killed"), ❤️ is L ("love"), 🔢 is M ("math"), 🌑 is N ("night"), 🍩 is O (because the donut looks like the letter O), 💍 is P ("proposal"), 🗨️ is Q (because it looks like a Q), ® is R (again, self-explanatory), 💰 is S (the dollar sign looks like an S), 🏆 is T ("trophy"), 🦄 is U ("unicorn"), 🌋 is V ("volcano"), 🤷 is W (because the man's arms kinda make a W shape), ✂️ is X (because the scissors are in the shape of an X), 🟡 is Y ("yellow"), and 💤 is Z (self-explanatory once again). Finally, the replacement for @ is 𓁨, the symbol for a million in the Ancient Egyptian number system; the man's arms are stretched in astonishment at the size of the number, which certainly applies to the huge numbers needed to get this symbol in this notation.
Emoji Alphabet is an Alphabet variation that uses those same emoji for the lowercase and uppercase letters; the zero digit is 🚫.

XYZ

A fairly simple notation that follows a similar but simpler version of the tiers of Letters notation. Smaller numbers are written with a number between 1 and 10 and some amount of Xs; each X multiplies the number by 10, so 3XXX means 3 * 10 * 10 * 10 = 3,000. A Y indicates that the number that goes with it is the amount of X's that would be in the full expression without the Y, so 8Y means 1XXXXXXXX (with 8 X's), and 2.5XXY means 1XXXXX... with 2.5XX = 250 X's. In other words, nY, for some "number and X's expression" n, means 10^n, so 2.5XXY means 10^(2.5XX) = 10^250. A Z indicates that the number that goes with it is the amount of Y's that would be in the full expression without the Z, so 9Z means 1YYYYYYYYY (with 9 Y's), 3XZ means 1YYYY... with 3X = 30 Y's, and 4XYZ means 1YYYY... with 4XY = 10⁴⁰ Y's. In other words, nZ means 10↑↑n.

Element Letters

A variety of Letters notation where each power of 118 gets a "letter" instead of each power of 1,000, and each of these "letters" is a symbol for an element on the periodic table: 118^1 is H, 118^2 is He, 118^3 is Li, 118^4 is Be, and so on. Like Letters notation, after Og (the 118th element) is HH, then HHe, then HLi, and so on, except if there's multiple of the same element in a row they're concatenated with a subscript, so HH becomes H₂ and HHH becomes H₃ but HHe and HHeH are unaltered. Uppercase letters have a bar over them, such as H̅, as that's the symbol for antimatter hydrogen. @ is replaced with ☢, and for reciprocals there's a - on the end.

Roman Numerals

You've probably heard of Roman numerals and know how they work already, but in case you don't, here's a refresher: 1 is written as I. The next few numbers are written by just using multiple I's as if they're tally marks: 2 is II, and 3 is III. I isn't the only unique symbol: V is 5, X is 10, L is 50, C is 100, D is 500, and M is 1,000. To write larger numbers, write multiple of these symbols and add them up: for example, XXVIII means 10 + 10 + 5 + 1 + 1 + 1 = 28. If a smaller symbol is written before a larger one, that's subtraction instead of addition, but this is only valid when it's a single power of ten (I, X, C, M, etc.) in front and it's coming before the symbol that's 5x or 10x it. This means IV is 4, IX is 9, XL is 40, XC is 90, CD is 400, and CM is 900. These subtraction pairs can be treated as single symbols, so 394 is written as CCCXCIV (100 + 100 + 100 + 90 + 4). There is limited support for non-whole numbers, but only for twelfths: · is 1/12, : is 2/12 (1/6), ∴ is 3/12 (1/4), ∷ is 4/12 (1/3), ⁙ is 5/12, S is 6/12 (1/2), and then 7/12 through 11/12 use S and dots, so 7/12 is S·, 8/12 (2/3) is S:, and so on. To go beyond 4,000, you can write a symbol with a line above it to multiply that symbol by 1,000, so V̅ is 5,000 (which means MV̅ is 4,000), X̅ is 10,000, L̅ is 50,000, C̅ is 100,000, D̅ is 500,000, and M̅ is a million.

How numbers beyond M̅ are handled depends on the notation being used. The notation called "Roman Numerals" here writes a number in parentheses after the M̅ to indicate multiplying M̅ by that number, so M̅(XI) means XI * M̅ = 11,000,000, and M̅(CXV)D means CXV * M̅ + D = 115,000,500. Eventually, this number can get large enough to itself be an M̅ with parentheses on it, and so on. After a few layers of this, a number in brackets is added, which means the M̅ is raised to the power of the number in the brackets before the multiplication, so M̅[VI](CDX) means M̅^VI * CDX = 410 * 1,000,000⁶ = 4.1e38. Finally, once there would be several layers of brackets, a number in braces is introduced, which means the expression is placed on top of a power tower of M̅'s with the number in braces being the height of the tower, so M̅{IV}[X](C) means M̅^M̅^M̅^M̅^(M̅^X * C).

AD Roman is the Roman numerals notation seen in Antimatter Dimensions, and this one goes for a scientific notation approach for larger numbers: numbers above 4 million are written in an x↑y expression, where x and y are both in Roman numerals. x↑y means x * 4,000,000^y, so XIX↑V means 19 * 4,000,000⁵; this is basically scientific notation with a base of 4,000,000 instead of 10 and using ↑ instead of e. For larger numbers, the exponent itself will need to be written in a ↑ expression, and so on; after enough of these arrows, the notation switches to hyperscientific, still using a base of 4,000,000, with ↑↑ in place of F. Single-arrow expressions are evaluated before double-arrows, so IX↑I↑↑V means (IX↑I)↑↑V = 36,000,000↑↑5 = 4,000,000^4,000,000^4,000,000^4,000,000^4,000,000^36,000,000.

Septecoman

Septecoman is a Roman numerals-like notation that's based on 7s and 17s instead of 5s and 10s. The symbols are as follows: I is 1, S is 7, D is 17, N is 119 (7 * 17), T is 289 (17^2), O is 2,023 (7 * 17^2), F is 4,913 (17^3), H is 34,391 (7 * 17^3), and E is 83,521 (17^4). The subtraction rule still applies, but with a couple differences: it only applies when it's one or two of a power of 17 (I, D, T, O, E, etc.) in front of the symbol that's 7x it, so IIS for 5 and IS for 6 are both valid here but IID and ID are not. When a smaller symbol is written before an E, it's multiplication instead of addition or subtraction, so SE is 7 * 17^4, DE is 17^5, NE is 7 * 17^5, and so on. These multiplication pairs, like the subtraction pairs, can be treated as single symbols, so DESESE means 17^5 + 14 * 17^4. Fractional numbers use backwards letters: Ƨ is 7/17, ꓷ is 1/17, И is 7/289, and ꓕ is 1/289.

The multiplication rule only goes up to OE. FE could be used for 17^7, as the subtraction rule doesn't apply here, but it kinda looks like it applies here (it would under the usual Roman numerals subtraction rules, but not under Septecoman subtraction rules), so 17^7 is where the next part of the notation starts, which behaves more like AD Roman than Roman Numerals. A number in brackets indicates multiplication by 17^x, where that x is 17 times the number in the brackets, so [I]SI means SI * 17^17, and [II]NDS means NDS * 17^34. Since this starts at 17^7, we also need [Ƨ] to multiply by 17^7, [ƧƧ] to multiply by 17^14, [IƧ] to multiply by 17^24, and so on. For larger numbers, you'll get multiple layers of brackets, and eventually a number in braces will show up, with the number in braces indicating the amount of layers of brackets outside the ones actually shown - but, like the brackets themselves, the amount of layers of brackets is 17 times the number in the braces, so {I}DN means [[[...[DN]...]I]I]I with 17 bracket layers, {II} adds 34 bracket layers, and so on. This means we need {ꓷ} to add one bracket layer (adding one bracket layer essentially increases the height of the power tower by 1), {ꓷꓷ} to add two bracket layers, {ꓷꓷƧ} to add five bracket layers, {Ƨ} to add seven bracket layers, and so on.

This notation was created by MathCookie because 17 is his favorite number, so he wanted to make a notation based on 17, and Roman numerals seemed like a good template to alter enough to make it feel like something new.

SI

The International System of Units (the "SI"), the system of measurements used across pretty much the entire world (the United States of America is the primary exception), has a list of prefixes that can be placed before its units to change their size. The most well-known of these is kilo- (k) for 1,000: a kilometer is 1,000 meters, a kilogram is 1,000 grams, and so on. The rest of the prefixes are as follows: mega- (M) for 10⁶, giga- (G) for 10⁹, tera- (T) for 10¹², peta- (P) for 10¹⁵, exa- (E) for 10¹⁸, zetta- (Z) for 10²¹, yotta- (Y) for 10²⁴, ronna- (R) for 10²⁷, and quetta- (Q) for 10³⁰. (Don't recognize those last two? They were added to the system in 2022. If you were expecting something like "xenna" or "bronto" for 10²⁷... well, those were never real SI prefixes). There are also prefixes for numbers below 1, and these are arguably more well-known than the larger prefixes (mostly because of distance; millimeters, micrometers, etc. see plenty of use, but people tend to use units like AU or light-years rather than megameters, gigameters, etc.): milli- (m) for 10^-3, micro (µ) for 10^-6, nano (n) for 10^-9, pico (p) for 10^-12, femto (f) for 10^-15, atto (a) for 10^-18, zepto (z) for 10^-21, yocto (y) for 10^-24, ronto (r) for 10^-27, and quecto (q) for 10^-30. (There are also prefixes for 10² (hecto- (h)), 10¹ (deca- (da)), 10^-1 (deci- (d)), and 10^-2 (centi-, (c)), but these four won't be used by these notations). These notations use these prefixes: SI notation uses the letters, SI (Written) writes out the whole prefix name. For example, in SI, 1,987,000 is 1.987 M, 10¹⁷ is 100 P, and 0.056 is 56 m.

For numbers above 1,000 Q, multiple prefixes are used: kQ for 10³³, MQ for 10³⁶, GQ for 10³⁹... QQ for 10⁶⁰, kQQ for 10⁶³, and so on. (Combining prefixes in this way is not allowed under official SI rules, but we're doing it anyway because it's pretty much required to go any further than 10³⁰ here). Likewise, mq for 10^-33, µq for 10^-36, nq for 10^-39, and so on. Once there are enough Q's in a row, they're truncated with a number in brackets after them; that number indicates how many Q's there are, so MQ[10] means MQQQQQQQQQQ (with 10 Q's). Once the amount of Q's gets above 1,000, it's written with SI prefixes itself. For large enough numbers, there may be multiple layers of brackets, and then a number in braces gets introduced, where the number in braces indicates the amount of layers of brackets outside of what's shown: for example, Q{4}[5] means Q[Q[Q[Q[5]]]].

Binary SI

The SI prefixes work great for most units of measurement, but things get confusing once bytes get involved - which is a problem, since bytes are perhaps the unit that the SI prefixes are used the most on these days. Because computers work in powers of 2, it would make sense for the prefixes on bytes to be powers of 2 instead of powers of 10... and 2¹⁰ = 1,024 is quite close to 10, so many people co-opt the SI prefixes and use them for powers of 1,024 on bytes instead of powers of 1,000. This leads to a small discrepancy that gets larger for higher prefixes: for example, 1 TB under the 2⁴⁰ definition is around 1.1 TB under the 10¹² definition, which can lead to people being scammed when their hard drive (sold under the 10¹² definition) displays less storage than they paid for (because their system displays memory under the 2⁴⁰ definition). This confusion goes against the purpose of the SI (to create a single common standard for measurements), so to solve this, the IEC (which creates international standards for most technologies involving electricity) created an alternate set of prefixes that use the powers of 1,024 by definition: kibi- (Ki) for 2¹⁰, mebi- (Mi) for 2²⁰, gibi- (Gi) for 2³⁰, tebi- (Ti) for 2⁴⁰, pebi- (Pi) for 2⁵⁰, exbi- (Ei) for 2⁶⁰, zebi- (Zi) for 2⁷⁰, and yobi- (Yi) for 2⁸⁰ (equivalents for ronna and quetta have not yet been finalized, and there's no need for counterparts for the smaller prefixes because fractions of a byte don't go lower than eighths). Unfortunately, these prefixes have not been universally accepted, so while a kibibyte always means 1,024 bytes, a kilobyte might still mean 1,000 or 1,024 depending on the system being used.

These two notations are the same as the regular SI notations, but using these binary prefixes instead of the regular SI prefixes.

Mixed SI

Mixed SI is similar to Mixed Scientific, but for SI instead of Standard: it starts with SI prefixes, but then after Q it switches to Scientific instead of using compound prefixes. When the exponent in the scientific notation gets large enough, it will itself be written in SI up to the same limit, and only then does an e get placed in front. Similarly, once the N in (e^N) gets large enough, it starts being written in SI and then switches to scientific.

Combined-D

This notation, suggested by Scratch user RobloxLover2015, is in theory a variant of Mixed Scientific, but in practice it's actually much closer to being a variant of SI. For numbers up to decillions, it uses similar prefixes as those in Standard: M, B, T, Qa, Qi, Sx, Sp, O, N, and D. For example, 500,000,000 is 500M, and 10¹⁴ is 100T. (Thousands don't get a prefix, they're just written out as numbers). Above decillions, the amount of decillions is written in this notation itself, so 1e36 is 1,000D, 1e39 is 1M*D, 1e42 is 1B*D... 1e60 is 1D*D, 1e63 is 1,000D*D, 1e66 is 1M*D*D, and so on. Once there would be more than three D's, the amount of D's is written in brackets, so 10Qa*D[9] means 10Qa*D*D*D*D*D*D*D*D*D (with 9 D's). For larger numbers, the number in brackets gets to be large enough to be written in Combined-D notation itself. Once there are several layers of brackets, a number in braces gets introduced, where the number in braces indicates the amount of layers of brackets outside of what's shown: for example, D{5}[100M] means D[D[D[D[D[100M]]]]].

Hyper-SI

SI notation (and, for that matter, Standard and Letters) can be thought of varieties of Scientific/Engineering notation where each exponent value gets a name instead of a number... and if SI notation is a Scientific variety, then Hyper-SI notation is a Hyperscientific variety, where each tetra-power of 10 gets a name, and for a given prefix X and number n, n X means 10^10^10^10...^n with however many 10's in the power tower the prefix X corresponds to, i.e. nFz for X's appropriate number z. Here are the prefixes:

• F1 is plexi- (Pl), as the suffix -plex means 10^x, such as how a googolplex is 10^googol.
• F2 is digexi- (Dg), as in "the amount of digits in the exponent.
• F3 is brinexi- (Bi), because the limit of break_infinity.js (e9e15) is around 1.204 brinexi.
• F4 is swekexi- (Sk), because Skewes's numbers are around 1.531 swekexi and 2.984 swekexi respectively.
• F5 is madenexi- (Md), because according to Reinhardt-C's list of incremental game limits , the incremental game Exponential Madness goes up to around 1 madenexi.
• F6 is alifexi- (Af), because according to Reinhardt-C's list of incremental game limits, the incremental game True Infinity Alpha goes up to around 1 alifexi.
• F7 is hypocexi- (Hc), because it's the first tetra-power of ten for which HyperCalc resorts to using PT notation to write it.
• F8 is cloctexi- (Co) because it's a "class 8" number under Robert Munafo's number classes.
• F9 is tenebexi- (Tb) because, on Part 3 of cookiefonster's Pointless List of Large Numbers, "Bentley's Number" is around 10↑↑9.
• F10 is deckerexi- (Dk) because Decker is a googological name for 10↑↑10.

There are also a couple negative-F prefixes (i.e. layers of logarithms instead of layers of exponents):

• F-1 is logo- (lg) since it's taking the base-10 logarithm of the number.
• F-2 is nepogo- (np) because it's used for negative numbers but the number that's written with the np is positive.

No prefixes below F-2 are needed, as 1 np is log(log(1)) = -Infinity. Above F10, multiple prefixes are used: PlDk for F11, DgDk for F12, BiDk for F13... DkDk for F20, PlDkDk for F21... Dk(5) for DkDkDkDkDk = F50... and so on.

Sandcastle Builder

Sandcastle Builder is a ridiculous incremental game based off xkcd comic #1190, "Time". This game is so wacky that the number notation it uses is probably the least ridiculous part of it, and even the notation gets a little silly. It's a variation of SI: it starts with the SI prefixes from kilo to yotta (ronna and quetta didn't exist yet when this game was made), but after those, it goes into made-up prefixes: Umpty (U) for 10²⁷, Squilli (S) for 10³⁰, Helo (H) for 10³³, Ferro (F) for 10³⁶, Lotta (L) for 10³⁹, and Wololo for 10⁴². After W is KW, then MW, then GW, and so on, with the twist that there's one more prefix later on: Quita (Q) is an abbreviation for WWWWW (that's five W's), i.e. 10²¹⁰. Beyond the change in prefixes, though, these notations behave the same as regular SI.

Cookie Fonster's Extended SI

cookiefonster is a former googologist who once created a system of extended SI prefixes that went up to a million large prefixes and a million small prefixes, giving it a range of six million orders of magnitude: from 10^3,000,000 to 10^-3,000,000. His explanation on that webpage goes into more detail on the system, so I'll try to keep this explanation brief. Here's how the system works:

• The first few prefixes are the canonical SI ones, up to yotta- and yocto- (ronna and quetta weren't added to the SI prefixes when this system was made). A few of their names are slightly changed so all the large prefixes end in a and all the small prefixes end in o (kilo- becomes kila-, for example), but since this notation only uses their abbreviated forms, that doesn't matter here.
• The next two prefixes use popular fake SI prefixes: bronto- for 10²⁷ and geop- for 10³⁰. To keep the "large prefixes end in a, small prefixes end in o" rule, these become bronta- (B) and geopa- (O), and their reciprocals are brimto- (b) and gepto- (g).
• The next few unique prefixes are only for "multiples of 10" in the prefix list, i.e. powers of 10³⁰. These also pull from previously-made fake prefixes, though with less regularity than bronto- and geop-'s inclusion: amosa- (A) for 10⁶⁰, hapra- (R) for 10⁹⁰, kyra- (Y) for 10¹²⁰, pija- (J) for 10¹⁵⁰, sagana- (S) for 10¹⁸⁰, pectra- (C) for 10²¹⁰, nisaba- (N) for 10²⁴⁰, and zotza- (X) for 10²⁷⁰. The reciprocal equivalents of these are amisto- (i) for 10^-60, harkto- (h) for 10^-90, kyrno- (k) for 10^-120, pejo- (j) for 10^-150, sagto- (s) for 10^-180, percto- (c) for 10^-210, niseko- (e) for 10^-240, and zuzto- (x) for 10^-270. A combination of a tens prefix and ones prefix is used between these: for example, the 37th prefix (for 10¹¹¹) is haprazetta- (RZ).
• The "multiple of 100" prefixes use greek letters. The large prefixes are alpha- (α) for 10³⁰⁰, beta- (β) for 10⁶⁰⁰, gamma- (Γ) for 10⁹⁰⁰, delta- (Δ) for 10^1,200, theta- (Θ) for 10^1,500, iota- (Ι) for 10^1,800, kappa- (κ) for 10^2,100, lambda- (Λ) for 10^2,400, and sigma- (Σ) for 10^2,700. Their reciprocals are epsilo- (ε) for 10^-300, nuo- (ν) for 10^-600, xio- (ξ) for 10^-900, omicro- (ο) for 10^-1,200, pio- (π) for 10^-1,500, tafo- (τ) for 10^-1,800, upsilo- (υ) for 10^-2,100, phio- (φ) for 10^-2,400, and chio- (χ) for 10^-2,700.
• The thousandth prefixes are omega- (Ω) for 10^3,000 and psio- (ψ) for 10^-3,000. Rather than new prefixes for each "multiple of 1,000", multipliers are placed in front of these two: for example, since M is the second prefix, the 2,000th prefix is MΩ.
• cookiefonster ended his system at the millionth prefix, omegomega- (ΩΩ), for 10^3,000,000, but there's no reason it can't keep going: just keep placing multipliers on Ω's! These huge prefixes consist of sets of prefixes separated by Ω's, where each Ω multiplies everything before it by 1,000 in terms of the prefix number. For example, the 123,456,789th prefix (for 10^370,370,367) is αAGΩΔJEΩκNB. Once this string would get too long, some of it is truncated by writing Ω^n to mean n Ω's in a row: for example, OTΩ^5 means OTΩΩΩΩΩ, the (13 * 1,000⁵)th prefix. Once the exponent on the Ω exceeds 1,000, it's also written in this notation, which eventually leads to a power tower of Ω's where a single Ω^ is equivalent to 1,000^1,000^, i.e. each Ω^ adds 2 to the height of the actual number's power tower. Once there's too many Ω^'s, they're truncated into a ((Ω^)^n) expression, and for huge tetrational numbers that super-exponent is also written in this notation.

Fraction

These notations approximate non-whole numbers as rational numbers (fractions) using continued fractions - the exact details of how continued fractions work aren't really relevant here, what matters is that they're independent of the number base being used, and that they're in some sense the "best" fraction approximations for given levels of simplicity. Since programming languages tend not to include exact rational numbers, Eternal Notations provides three different levels of precision for fractions: Loose will stop once the error is less than 0.001n (where n is the number being approximated: for example, for a number around 1.5, Fraction (Loose) will return an approximation that's within 0.0015 of the target number), Medium's error will be less than 10^-6 * n, and Precise's error will be less than 10^-10 * n. The three Fraction notations will return "improper" fractions for numbers above 1, while the three Mixed Number notations separate the whole part from the fractional part. These notations, unlike most notations in Eternal Notation, aren't interesting for large numbers, since eventually the whole numbers themselves will be within precision limits; it's with numbers less than the millions where these notations are interesting.

Letter Digits

Letter Digits notation is similar to Letters notation, but without a mantissa: the lowercase letters represent the number itself instead of representing a power of 1,000. a is 1, b is 2, z is 26, aa is 27, and so on. An uppercase A still means that the number after the A represents the amount of lowercase letters that would be in the expression without the uppercase A, but now that number is itself represented via lowercase letters: for example, Am means aaaaaaaaaaaaa (that's 13 a's). Further uppercase letters also mean the same thing they did before, but since there's no mantissa, going to the next uppercase letter only adds 1 to the height of the power tower instead of 2. Likewise, in an expression with an @, the lowercase letters after the @ express the amount of uppercase letters that would be in the full expression.
Alphabet Digits is, as you'd probably expect, Alphabet notation without the mantissa. Aside from using regular base 53 instead of bijective base 26, a notable difference between Letter Digits and Alphabet Digits is in how they handle fractional lowercase letters: Letter Digits uses a fractional approximation (with the same level of precision as Fraction (Medium)), Alphabet Digits uses decimal places.

Myriad

Most people don't often use -illion names beyond a trillion: if they need to refer to something in the quadrillions, they'll say "thousand trillions" or "million billions". This begs the question: why do we need the word "quadrillion" if "thousand trillion" would suffice? In other words: do we really a new name for every power of 1,000, or could we be more efficient with spreading out the names?

Such an increase in efficiency is the goal of Donald Knuth's -yllion system. In this system, tens and hundreds get names, but "thousand" isn't used: 1000 is "ten hundred", and the next name is at 10⁴, which is called a myriad ("myriad" for 10,000 is a fairly standard term, at least in some languages). The first -yllion, a myllion, is a myriad myriad, i.e. 10⁸. 10¹² is just "a myriad myllion", as the second -yllion, a byllion, isn't until a myllion myllion, 10¹⁶. Similarly, 10²⁴ is "a myllion byllion", and the next -yllion, a tryllion, is at a byllion byllion, 10³². Each -yllion, therefore, is the square of the previous one, and in general the n'th -yllion has a value of 10^{2n + 2}.

These notations use the same prefixes as Standard (a variety for each of the three Standard prefixes is given here), but now they refer to -yllions instead of -illions, so M is 10⁸, B is 10¹⁶, T is 10³², Qa/Qd is 10⁶⁴, Qi/Qt is 10¹²⁸, and so on. When multiple -yllions are included, they're separated via hyphens with the largest -yllions first, so 10²⁴ is 1 B-M. M is the smallest prefix used here; myriad does not get its own prefix, so numbers below 10⁸ are written as normal, with the caveat that commas are placed between every 4 digits instead of every 3 digits in this system. The prefixes are the same as Standard up until the 100th -yllion; the 100th -yllion still uses Cn/Ce, but powers of 100 act like the powers of 1,000 do in Standard (separated via underscores here), so the 356th -yllion in (MathCookie's) Myriad is TCn_SxQq. The 1,0000th -yllion is a "myryllion", which uses the prefix My (in all three systems; Antimatter Dimensions never specified what the prefix for such an -illion would be, while Aarex does and it's My for him too, so I just used My for all three), then the 100,0000th -yllion is CeMy (again, we're trying to reuse symbols where we can here).

For really big numbers, Knuth proposed "latin-x-yllion" to mean "the x'th yllion", so "latinmyllionyllion" means the 10⁸th -yllion, and it's given the prefix LtM here. Once we reach a latinbyllionyllion, the 10¹⁶th -yllion, though, we just put the whole number in an Lt[] expression: for example, Lt[1.5 B-M] means the "1.5 myllion byllion"th -yllion, i.e. the (1.5 * 10²⁴)th -yllion, which is around 10^{21.5 * 1024}. Like with Standard, for even larger numbers you'll get Lt^2[], then Lt^3[], and so on, and eventually the Lt amount will itself be written in Myriad notation. Whereas each Il() added 1 to the height of a power tower in Standard, here each Lt[] adds 2 to the height of a power tower (the power tower would alternate between 10s and 2s, not that it really matters for anything other than the top few entries of the tower).

Double Binary Names

the best way to count is a long YouTube video made by supporters of binary as the best number base, which goes into great detail on all the properties of binary that make it easier and more versatile than other bases. Near the end of the video, they give a system of naming these numbers (and a way of writing these names with symbols, though of course typically you'd just write the numbers in binary itself without the complexity of these names). Double Binary Names notation writes numbers using the symbols version of this naming system. The first three symbols of this system are 1, 2, and 4, and the system follows a few rules:

• When a smaller symbol is written after a larger symbol, it's addition.
• When a smaller symbol is written before a larger symbol, it's multiplication.
• Expressions with smaller symbols are evaluated before expressions with bigger symbols.

For example, "4 2" means 4 + 2 = 6, "2 4" means 2 * 4 = 8, and in "2 1 4 1" you evaluate the 2s and 1s before you touch the 4, so this becomes (2 + 1) * 4 + 1 = 13.
We don't allow two of the same symbol to be right next to each other, and we only introduce a new symbol whenever we need to. This ends up meaning that we need a new symbol once we reach the square of the previous symbol, which means the symbols correspond to the double-powers of 2, i.e. the numbers of the form 2²ⁿ for positive integer n. The names for the double-powers of 2 chosen in the video tend to use computer science terms, since powers of 2 show up often there. The names and symbols are as follows:

• 1, 2¹ = 2, and 2² = 4 already have their own single digits, so they keep those as their symbols.
• 2⁴ = 16 is "hex" (H), because a single hexadecimal (base 16) digit is four binary digits.
• 2⁸ = 256 is "byte" (B), because a byte is 8 bits.
• 2¹⁶ = 65,536 is "short" (S), 2³² = 4,294,967,296 is "int" (I), and 2⁶⁴ ≈ 1.844e19 is "long" (L); these are different sizes of integer variables in low-level programming languages like C, with a short being 16-bit, an int being 32-bit, and a long being 64-bit. 65,536 is the first nonnegative integer too large for a short to hold, and likewise for the other two.
• 2¹²⁸ ≈ 3.403e38 is called "overlong" in the video, but I think a better name is "float" (F), as this number is the limit of a "float", i.e. a single-precision floating-point number (floating point is the way that computers represent non-whole numbers).
• 2²⁵⁶ ≈ 1.158e77 is "byteplex" (P), because it's 2^(byte). "Plex" is a suffix that normally means 10^x, like how a googolplex is 10^googol, but since this is a binary-focused system, -plex is used to mean 2^x instead of 10^x here.
That's as far as the video goes in naming numbers, but Eternal Notations goes further with eight more symbols (these eight were chosen by MathCookie):
• 2⁵¹² ≈ 1.341e154 is "tetracube" (T), as this number is 4^4^4, i.e. 4↑↑3.
• 2¹⁰²⁴ ≈ 1.798e308 is "double" (D), as this number is the limit of a "double", i.e. a double-precision floating-point number; doubles are used for floating point numbers in most high-level programming languages, including JavaScript, which is why 2¹⁰²⁴ is a well-known limit in the incremental games community.
• 2²⁰⁴⁸ ≈ 3.232e616 is given the letter R, as the cryptographic system RSA (one of the oldest encryption/decryption algorithms still in use) is typically used with 2048-bit "keys" these days. (Perhaps the name for this number would be "r-key"?)
• 2⁴⁰⁹⁶ ≈ 1.044e1,233 is "sector" (C), as memory-storing hard drives usually use 512-byte (= 4096-bit) disc sectors as their minimum unit of data to allocate to programs. (Yeah, C isn't the best symbol here, but D and S were both taken and C was the next best option)
• 2⁸¹⁹² ≈ 1.091e2,466 is "kibi" (K), as 8,192 bits = 1,024 bytes = 1 kibibyte.
• 2^16,384 ≈ 1.19e4,932 is "quadruple" (Q), as this number is the limit of a quadruple-precision floating point number; programming languages rarely use these.
• 2^32,768 ≈ 1.415e9,864 is given the letter A, as "Advanced Format" disk sectors are 4,096 bytes (32,768 bits) instead of 512 bytes. (Perhaps the name for this number would be "adform" or "advaf"?)
• 2^65,536 ≈ 2.004e19,728 is "shortplex" (X), or perhaps "hexduplex"; this number is 2↑↑5, which I figured was a good stopping point for new symbols.

Once 2^131,072 is reached, the number is written in parentheses with a p after it; the p stands for "-plex", which here means 2^x, so (2 S 1)p means 2^(2 S 1) = 2^131,073. For larger numbers, multiple p's will be present, and then the p will get an exponent to indicate how many p's there are; that exponent will itself be written in this notation, so I | p^(H 2 1) means 2^2^2^2...^2^4,294,967,296 with (H 2 1) = 19 2's in the power tower.

Double Binary Prefixes is simpler than Double Binary Names: the symbols H and above are used like SI prefixes, and the leftover mantissa is just written as a usual (decimal) number. For example, 2.5 B means (2.5 * 256) = 1,280. The prefixes end up following a binary-like system themselves: H for 16, B for 16^2, HB for 16^3, S for 16^4, then HS, BS, HBS, I, HI, BI, HBI, SI, HSI, BSI, HBSI, L... and so on. If there would be multiple X's, they're written as X^n (where n is itself written in Double Binary Prefixes); the ^n serves as the replacement for SI's brackets, and later on there's "# (n)", which replaces braces. Double Binary Prefixes, at least up until X, is basically a version of Myriad with numbers of the form 2²ⁿ given names/prefixes instead of numbers of the form 10²ⁿ.

Alphaquint

Alphaquint is a Roman Numerals-like way of writing numbers, except there are arbitrarily many numerals rather than a finite set of them. The numerals are letters of the alphabet, with each letter representing a power of 5: A is 1, B is 5, C is 25, D is 125, E is 625, and so on. There's no subtraction rules here, so 4 is just AAAA. This continues up to Z = 5²⁵ (around 2.98e17). The letters after Z continue in the same fashion as Letters and Letter Digits: after Z is Aa, then Ab, then Ac, and so on. After Az is Ba, after Bz is Ca, and so on. After Zz is Aaa, after Zzz is Aaaa, and so on. To make it clear when multiple letters are part of the same numeral, the first letter of a numeral is capital and the rest of the letters in that same numeral are lowercase. This continues up to Zzzzzzz (that's seven Z's), at which point the numerals are deemed to have gotten too long, so a number (also written in this notation) in brackets is added to the left of the expression, which indicates that the rest of the expression is placed atop a power tower of 5's with that height: for example, [BA] FEEDBBB would mean 5^5^5^5^5^5^(FEEDBBB), with six 5's because BA means 6.

Hypersplit

Hypersplit notation splits a number into four numbers, all of which are between 0 and 10: a mantissa, an exponent, a tetra-exponent (i.e. a power tower height), and a penta-exponent (a.k.a. a "tetration tower" height). Numbers between 1 and 10 are just written as the mantissa. This is similar to how numbers are represented internally in OmegaNum.js, but there there's no regular exponent (it goes mantissa, tetration, pentation, hexation, etc. there). With just a mantissa m and an exponent e, the number is written as m * 10^e, so 150 is 1.5 * 10^2. When there's a tetra-exponent t, it's written as (10^)^t, indicating that t is the amount of (10^)'s in the power tower: for example, (10^)^7 8 * 10^5 means 10^10^10^10^10^10^10^(8 * 10^5). When there's a penta-exponent p, it's written as (10^^)^p, indicating that p is the amount of (10^^)'s in the "tetration tower": for example, (10^^)^3 (10^)^2 1 would mean 10^^10^^10^^(10^10^1), though in practice the penta-exponent will never go above 1 because break_eternity doesn't support numbers large enough for it to go above one. In addition to the 10-based variant, there's also a 3-based variant where the base of the exponent, tetra-exponent, and penta-exponent is 3 instead of 10 (the numbers are still written in decimal, though, not ternary). A 2-based variant is also provided, though because 2^2 = 2^^2 = 2^^^2 = 4, the limits for e and t are increased to 4 instead of 2 for this variant.

Hyper-E

Hyper-E Notation is a googological notation that, even in its weakest form, encompasses the hyperoperator sequence as a whole (and its various extensions go much, much farther than that). In this weakest form, an expression in Hyper-E notation has the form Ea#b#c#d... for some numbers a, b, c, d... and so on. With just one number, Ea means 10^a. With more than one number, the function is recursive: Ea#b means E(Ea#(b - 1)), Ea#b#c means Ea#(Ea#b#(c - 1)), Ea#b#c#d means Ea#b#(Ea#b#c#(d - 1)), and so on: for each step, you get rid of the last argument and replace the second-to-last argument with the entire original expression but with the last argument decreased by 1. If the last argument is 1, remove the last argument but don't do anything else. Each entry in a Hyper-E Expression approximately corresponds to the next hyperoperator: the first entry is an exponent, the second corresponds to tetration, the third to pentation, and so on. Ea#b turns out to be the same as aFb in Hyperscientific, and beyond two-entry expressions, only Ea#1#2, which means Ea#(Ea) = aF(10^a), is seen before Eternal Notations reaches its limit.

Infinity

Introduced by Antimatter Dimensions, Infinity notation is essentially a variation of Logarithm with a base of 2¹⁰²⁴, which is around 1.79e308, instead of 10. For example, the number written as 0.1∞ is (2¹⁰²⁴)^0.1 = 2^102.4 ≈ 6.69e30. For huge numbers, the number before the ∞ will itself be written in infinity notation, resulting in multiple ∞s in a row, such as 0.25∞∞ meaning (2¹⁰²⁴)^(21024)0.25. Once there are enough ∞s in a row, they're truncated into an ∞ⁿ expression.
If you're wondering why 2¹⁰²⁴ was chosen as the base, it's because 2¹⁰²⁴ is the limit of numbers in many programming languages (including JavaScript, which most incremental games are written in); numbers beyond 2¹⁰²⁴ are considered to be infinite, thus the use of 2¹⁰²⁴ as "infinity" in this notation.

Eternity

Infinity notation has the property that, if you stick to numbers reachable without a large number library, it maxes out at 1∞. Eternity notation takes this idea of representing a number in terms of its proportion of the way towards the limit and applies it to break_eternity. break_eternity.js's maximum is 10↑↑(2¹⁰²⁴), so to write a number in Eternity notation, take its base-10 super-logarithm, then take the base-(2¹⁰²⁴) logarithm of that. This result is written with the character ֎ in front of it, which is apparently an Armenian sign for eternity. This character actually comes in two forms: the clockwise ֎ is used for normal numbers (those above 1) and the counterclockwise ֍ is used for reciprocals, so ֍0.01 is the reciprocal of ֎0.01. (0 and 1 don't work under either of these, so they're just written as plain numbers.) This notation is incredibly slow - it takes until around 10↑↑1,210 to reach ֎0.01, for example.

Brackets

Introduced in an April Fools' Day update to Antimatter Dimensions, Brackets is a notation designed to be confusing and hard to understand. The notation uses a base-6 logarithm, with the number also written in base 6, but the digits 0 and 5 are replaced with parentheses, brackets, and braces in an arbitrary order: ) is 0, [ is 1, { is 2, ] is 3, ( is 4, and } is 5. For example, 6 is e[.)), and 36 is e{.)). That's all there is to it... in Antimatter Dimensions, at least. This notation's extension to tetrational numbers is also designed to be confusing: if the base-6 logarithm needs to be taken multiple times, an expression is placed before the e to indicate the amount of extra times it's taken (which is one less than the actual number of times, since it doesn't include the original logarithm). This expression is also written as a base 6 logarithm with the same six digits, but here both the digits themselves and the order of the digits are reversed, so six extra logarithms would be indicated by placing ((.] before the e.

Simplified Written

This notation comes from NG+++, an Antimatter Dimensions mod by Aarex Tiaokhiao. In this notation, each of the digits 0-9 are written with the first two letters of their name: 0 is Ze, 1 is On, 2 is Tw, 3 is Th, 4 is Fo, 5 is Fi, 6 is Si, 7 is Se, 8 is Ei, and 9 is Ni. Numbers between 1 and 1,000 are rounded to the nearest integer and written with these digits: for example, 350 is written as ThFiZe. For numbers above 1,000, there will be a number in parentheses (also written in this notation) that multiplies by 10ⁿ: for example, (Si) FoOnEi means 10⁶ * 418. This is like scientific notation, but the mantissa ranges between 100 and 1,000 instead of between 1 and 10. Once the number in parentheses would go above 1,000, a number in brackets is introduced instead. The number in brackets means that the expression is placed on top of a power tower of 10s with n 10s in it: for example, [Fo] EiSeSi means 10^10^10^10^876. Finally, for the largest numbers Eternal Notations supports, there will be a number in braces, which puts the expression on top of a "tetration" tower of 10s: for example, {Th} TwOn would mean 10^^10^^10^^21 (though the number in braces never gets above 1 in practice).

Dots

Unicode, the standard that decides what wacky text characters are supported by computers, supports 256 Braille dot patterns. These patterns consist of a 2x4 grid of dots, some of which are visible and some of which are not. The patterns follow a binary numbering system: the numbers go from 0 to 255, with the first three dots in the left column as the 1s, 2s, and 4s places, the first three dots in the right column as the 8s, 16s, and 32s places, the bottom-left dot as the 64s place, and the bottom-right dot as the 128s place (visible is 1, invisible is 0).
Dots notation uses these dot patterns to notate numbers. First of all, it offsets the numbers by 1, so ⠁ (which is pattern 1 in Unicode) is the digit for 0, ⠂ (pattern 2 in Unicode) is the digit for 1, ⠃ (pattern 3 in Unicode) is the digit for 2, and so on - this is done because pattern 0 in Unicode is empty, and having a blank position would get confusing, so pattern 0 is not used. ⣿, the final pattern, is also not used as a regular digit, so Dots notation works with patterns 1 to 254 as digits from 0 to 253, making it a base-254 system. The last digit of the number is not the 1s place, but rather the first place after the decimal point (the decimal point itself is not shown, but it's implied to be there), i.e. the 1/254ths place, so numbers below 254 use two digits (the first digit is the 1s place, the second is the 1/254ths place), numbers between 254 and 254^2 use three digits (254s place, 1s place, 1/254ths place), and so on. For numbers below 1, the first digit will be a 0 to signify that what comes afterwards is all after the decimal point.
Only up to four digits are shown, so once the number is above 254^3, scientific notation begins. This is where ⣿ comes in: ⣿ separates the exponent and the mantissa, with the exponent coming before the ⣿ and the mantissa coming after the ⣿. The mantissa is represented the same way it was before (three whole number digits and then one post-decimal point digit), and the exponent is just written as a whole number without the post-decimal point digit. For larger numbers, a ⣿⠂ will be placed at the end to signify that the expression is an exponent on a 254, like how e's are placed at the beginning of Scientific notation to indicate that the expression is an exponent on a 10 there. Once there are enough of these, the notation switches to hyperscientific, with ⣿⣿ separating the hyperexponent and the mantissa (hyperexponent before the ⣿⣿, mantissa after).

Hearts

For numbers between 100 and 1e12, Hearts notation uses colored heart emoji to implement resistor color codes, a system in which each digit gets a color: 0 is black (🖤), 1 is brown (🤎), 2 is red (❤️), 3 is orange (🧡), 4 is yellow (💛), 5 is green (💚), 6 is blue (💙), 7 is purple (💜), 8 is grey (🩶), and 9 is white (🤍). This notation uses the version of resistor color codes with three significant figures, so the first three hearts are digits of the mantissa and the fourth is a scientific notation exponent: for example, 🧡💛🖤❤️ means 340 * 10² = 34,000. There's no implied decimal point in the mantissa: the mantissa ranges between 100 and 1,000, not between 1 and 10. This means we need negative exponents for numbers smaller than 100, in which case a cyan heart (🩵) is placed before the exponent to indicate the exponent is negative. 🩷 is used as the exponent for 10 (this magenta heart will never show up as a digit, only as an exponent), then 🤎🩷 is the exponent for 11, ❤️🩷 is the exponent for 12, 🧡🩷 is the exponent for 13, and so on, like how SI notation's prefixes after Q are kQ, MQ, GQ, and so on. Instead of writing multiple 🩷s in a row for exponents of 20 and above, the amount of 🩷s there would be is written after the 🩷, also in this notation: for example, since 🤎🖤🖤🖤 is 100, 🩷🤎🖤🖤🖤 is the exponent for (10 * 100) = 1,000, and then 🤎🩷🤎🖤🖤🖤 is the exponent for 1,001, ❤️🩷🤎🖤🖤🖤 is the exponent for 1,002, and so on. Once the exponent is above 10,000, only the multiplier after the 🩷 is shown, since at that point the mantissa is pretty much meaningless. For really big numbers, there will be multiple 🩷s before the number (each one representing one 10,000,000,000^ in a power tower), and then it will switch to hyperscientific: if 💗 is in the expression, then the number after the 💗 is how many 🩷s there would be before the rest of the expression if it was expanded out without the 💗.

Dominoes

Dominoes notation, as the name implies, writes numbers using dominoes. This notation was designed around the colored dominoes, with the text-based one as an afterthought, so I'll explain Colored Dominoes (Double 6) first, then go back and talk about the differences with the others.

The first few nonnegative integers get their own domino: the 0-0 domino is 0, the 1-0 domino is 1, the 1-1 domino is 2, the 2-0 domino is 3, the 2-1 domino is 4, the 2-2 domino is 5, the 3-0 domino is 6, and so on. Whenever we increase the number by 1, we increase the amount of dots on the bottom square of the domino by 1, unless the two squares are already equal, in which case we increase the amount of dots on the top square by 1 and reset the bottom square to 0. This continues until we hit the largest domino in the system; for Double 6, this is the 6-6 domino, which has a value of 27. After that, we add another domino in front, using these 28 dominoes from 0-0 to 6-6 as digits in a base-28 number system. For non-whole numbers, there will be a couple white dominoes with black dots (as opposed to cream with colored dots); these are decimal places. Once there are too many dominoes, a black 1-0 domino appears: in an expression with a black 1-0 domino, the rest of the expression denotes how many dominoes there would be if the expression was expanded out without the black 1-0 domino. If the black domino is 1-1, then the rest of the expression denotes how many dominoes there would be in a black 1-0 domino expression, and in general, for a given black domino value, the colored part of the expression denotes how many dominoes there would be in an expression of the previous black domino value. Eventually, there will be multiple black dominoes (which use the same base-28 system as the regular ones), then for the largest numbers Eternal Notations supports, there will be a red 1-0 domino, which means the colored part of the expression denotes how many black dominoes would be in the full expression without the red 1-0 domino. As for weirder numbers, an empty black-and-white domino denotes a negative sign, and an empty cream and red domino denotes a reciprocal.

What about the other varieties? The other Colored Dominoes varieties differ in how high their dominoes go and thus what base the system works in: Double 9 goes up to the 9-9 domino (resulting in base 55), Double 12 goes up to the 12-12 domino (resulting in base 91), Double 15 goes up to the 15-15 domino (resulting in base 136), and Double 18 goes up to the 18-18 domino (resulting in base 190). As for the notation just called "Dominoes"? While the colored dominoes notations are cool, they're also the only notation in Eternal Notations that doesn't work in plain text, requiring HTML or some other markup language to work. As such, a plain text version of Dominoes is included as well: Unicode has characters for dominoes, but they only go up to 6-6, so only the Double 6 variant gets this plaintext alternative. Since different colors of dominoes wouldn't work, the character 🁢, which represents a face-down domino, is used to split the black dominoes from the regular ones, and later to split the red dominoes from the black ones.

Factorial

The factorial function, denoted with an exclamation mark, is a fairly well-known function: on integers, x! = x * (x - 1) * (x - 2) * (x - 3) * ... * 3 * 2 * 1. This grows faster than any exponential function, but slower than x^x. The factorial can be extended to non-whole numbers while retaining the recursive property x! = x * (x - 1)! via a function known as the Gamma function, though this extension is undefined for negative integers (it's defined for non-integer negative numbers, but it has vertical asymptotes at negative integers specifically). This notation writes numbers in terms of what number they're a factorial of, so 6 is written as 3!, 24 is written as 4!, 120 is written as 5!, and so on. For huge numbers, there may be multiple factorials taken: for example, 6!! would mean (6!)! = 720!, which is around 2.6e1,746 (though the notation hasn't actually switched to two factorials yet at this point). This isn't what multiple exclamation points is normally used for - normally "double factorial" means x * (x - 2) * (x - 4)..., but this is weaker than the usual factorial, so it's not of much use to Eternal Notations. Therefore, in Eternal Notations, "double factorial" means (x!)!. Anyways, once there are enough exclamation marks, they're truncated by writing one exclamation mark with the amount of exclamation marks after it: for example, 25!8 means 25!!!!!!!! (with 8 !'s).

Factorial Amount

Factorial notation can be thought of as a factorial-based equivalent of Logarithm, and if you do so, then Factorial Amount is the Super Logarithm equivalent: how many times do you need to apply the factorial function to 3 to reach the target number? 3!0 is 3, 3!1 is 3! = 6, 3!2 is 3!! = 720, 3!3 is 3!!! ≈ 2.6e1,746, and so on. For fractional amounts of factorial applications, an approximation similar to the linear approximation of tetration is used: x!y, for 0 < y < 1, takes a weighted geometric mean of x! and x: for example, x!0.75 = (x!)^0.75 * x^0.25. For y > 1, x!y = (x!(y-1))!. The amount of factorial applications will be negative for numbers between 2 and 3, meaning the "inverse factorial" function is applied some amount of times. The reason 3 was chosen as the base is because it's the smallest integer that works: 2! = 2, so no matter how many times you apply the factorial function to 2, it remains at 2. 2 would be 3!(-Infinity), so numbers between 1 and 2 are just written as plain numbers because you can't reach them from 3 using factorials and inverse factorials.

Factorial Scientific

This notation is similar to Scientific notation, except instead of the "exponent" being for powers of 10, it's for factorials. For example, the largest factorial below 60 is 4! = 24, so 60 is written as 2.5 * 4!. Because of how factorials work, the range for the mantissa here is between 1 and the "exponent": for example, if the factorial currently in use is 5!, then the mantissa can range from 1 to 5. This means that, for larger numbers, the mantissa can go higher before it resets and increments the exponent. Once the number gets too large, a single factorial is applied to the whole expression, such as (3 * 12!)!, then multiple factorials, and then the amount of factorials applied to the expression is written after an exclamation point: for example, 7.5 * 14! (!6) means (7.5 * 14!)!!!!!! (with 6!'s on the outside).

Factorial Hyperscientific

This notation is similar to Factorial Amount, but with one key difference: whereas in Factorial Amount the base was always 3 and the "hyperexponent" was allowed to be non-whole, here the hyperexponent is always a whole number and the base is allowed to vary. The base has a lower limit of 3, which means its upper limit is 3! = 6. This results in a notation which is basically the Hyperscientific equivalent of Factorial Scientific.

Factoradic

Factoradic is an example of a "mixed radix" number base, where not every place value operates under the same base. In factoradic, the rightmost digit acts as like binary digit (it can only be 0 or 1), the next digit acts like a ternary digit (it can be 0, 1, or 2), the next acts like a quaternary digit (it can be 0, 1, 2, or 3), and so on, with each place value allowing one more possible digit than the one after it. This turns out to make the place values be the factorials: there's a 1s place, a 2s place, a 6s place, a 24s place, a 120s place, a 720s place, and so on. For example, "3101" means 3 * 4! + 1 * 3! + 0 * 2! + 1 * 1! = 79. For digits in the 10!'s place and above, the typical convention of using A, B, C, etc. as the digits for 10, 11, 12, etc. is used. This notation behaves the same as the other number base notations, just using factoradic instead. Like the other number base notations, this one eventually switches to scientific notation - scientific notation's exponent is based on amount of digits in the number, which in this case means it's actually "factorial scientific", and likewise for hyperscientific later on. e is still used as the separator for scientific, but as with the other factorial notations, ! is used as the separator for hyperscientific.

Roots

Roots are one of the inverses of exponentiation: the nth root of x is the number y such that y^n = x. If you expand your domain and range to include negative numbers, then weird things can start happening with roots (this is how complex numbers were first created), but if we stick to positive numbers then we can get a single answer for any given root. The 2nd and 3rd roots are given special names, those being "square root" and "cube root" respectively. These notations use roots to write numbers: for example, Square Root writes 196 as 14^2, and Cube Root writes 512 as 8^3. For larger numbers, those roots may have to be applied multiple times: for example, Square Root writes 10²⁴ as ((1,000^2)^2)^2. Above that, the amount of square roots applied will be written as a second exponent, such as 1,000^2^8 meaning the square root was applied 8 times. For even larger numbers, the whole expression will be placed on a 2^2^ or 3^3^ expression to indicate "how many times do we have to apply the root to the number to get down to 2 or 3?", and then the amount of 2^2^'s or 3^3^'s will be truncated into an expression like ((2^2^)^7) to indicate that the "2^2^" prefix was applied 7 times. Increasing Root, on the other hand, starts with a root height of 2 but increases that height for larger numbers to keep the base under 10,000 (10,000 was chosen arbitrarily because it's (10^2)^2). For tetrational-sized numbers, this is essentially equivalent to a single logarithm, which for really big tetrational numbers doesn't have much impact.

Super Roots

Exponentiation has two inverses, those being roots and logarithms, and the same is true for tetration: tetration's two inverses are super-roots and super-logarithms, and unlike with roots and exponentiation, super-roots can't easily be rewritten as fractional-height tetrations (though this is partially because we have no agreed definition of fractional-height tetration, only approximations). These notations write numbers in terms of these super-roots: for example, in Super Square Root, 27 is written as 3↑↑2, 256 is 4↑↑2, 3,125 is 5↑↑2, 46,656 is 6↑↑2, and so on. Tritetrated, which uses a super-root degree of three, should probably be called "Super Cube Root", but this notation was called "Tritetrated" in the Antimatter Dimensions notations so I reused that name for the sake of familiarity. For larger numbers, the super-root may need to be applied multiple times, such as (15↑↑2)↑↑2, and eventually the amount of times the super-root is applied is written as an exponent on the ↑↑, such as 25(↑↑^7)2. Increasing Super Root, on the other hand, starts with a super-root degree of 2 but increases that height for larger numbers to keep the base under 65,536 (65,536 was chosen arbitrarily because it's 2↑↑4). For tetrational-sized numbers, square super-roots end up being approximately the same as single logarithms, cube super-roots end up being approximately the same as double logarithms, fourth super-roots end up being approximately the same as triple logarithms, and so on.

Penta Roots

These notations write numbers in terms of their pentational roots: for example, in Penta Square Root, 7625597484987 is written as 3↑↑↑2, e8.0723e153 is 4↑↑↑2, ee1.336e2,184 is 5↑↑↑2, eee2.069e36,305 is 6↑↑↑2, and so on. As with Super-Roots, the cube root equivalent is called "Tripentated" instead. For larger numbers, the super-root may need to be applied multiple times, such as (15↑↑↑2)↑↑↑2, and eventually the amount of times the super-root is applied would be written as an exponent on the ↑↑↑, such as 25(↑↑↑^7)2... if the notation actually got that far, that is. An Increasing Penta-Root notation would never get its height above 3, so I didn't bother including that here either.

Weak Hyperscientific

Exponentiation is not commutative: x^y and y^x usually return different values. As such, when defining tetration as repeated exponentiation, do you evaluate the tower of exponents from top to bottom or from bottom to top? Evaluating it from top to bottom gives the standard tetration used all over Eternal Notations, while evaluating it from bottom to top gives "weak" tetration. Whereas regular tetration (denoted as x↑↑y) shoots off into insane numbers incredibly quickly, weak tetration (denoted as x↓↓y) is more tame. In fact, unlike regular tetration, weak tetration can be expressed via a simple formula using (top-to-bottom) exponentiation: x↓↓y = x^{xy - 1}.

This notation is similar to Scientific and Hyperscientific, but it uses weak tetration instead. Since this is a weaker version of tetration, a lowercase f is used instead of an uppercase F. The base here is still 10, and increasing the "weak hyperexponent" by 1 raises the number to the power of ten, so xfy = (10↓↓y)^x.

Notably, weak tetration chooses to preserve x↓↓1 = x, but x↓↓0 is not 1: it's x^1/x (1 would actually be x↓↓(-Infinity)). As such, negative weak hyperexponents are seen on numbers close to 1, and numbers below 1 are written in terms of their reciprocal.

I included Weak Hyperscientific but not Weak Super-Logarithm because Weak Super-Logarithm would be very similar to Double Logarithm. Weak versions of higher hyperoperators do exist, but nobody's figured out a good way to approximate them for non-integer heights yet, so I couldn't add those to Eternal Notations.

Super Square Scientific

Scientific notation, except instead of using powers of 10, it uses "super-squares", numbers of the form x^x. Basically, wherever a 10^x shows up in scientific notation, replace it with an x↑↑2, and the result is this notation.

Exponent Tower

Exponent Tower notation expresses numbers as a tower of exponents where each term in the tower is 10 or less. The bottom term can be non-whole, but the rest of the terms are all whole numbers: whenever one term would reach 10, the next term is increased by 1 instead. Exponent Tower K is similar, but with a maximum of 1,000 instead of 10. Partway through the double-exponential range, the bottom term would become close enough to 1 that it would just appear as "1", so when that would happen, a 10 or a 1,000 is added at the bottom of the tower, and for tetrational numbers the amount of 10's or 1,000's at the bottom is written in this notation itself.

Prime

Prime numbers are integers that have no factors except 1 and themselves (1 itself is not considered prime): the first few are 2, 3, 5, 7, 11, 13, 17... and so on. Any integer can be expressed uniquely as a product of prime numbers (the result is called the "prime factorization" of that number), a fact so important to mathematicians that they call it the fundamental theorem of arithmetic, and this notation expresses numbers as their prime factorizations. When a prime occurs multiple times in a number's prime factorization, it's written with an exponent to indicate the number of times it appears. For example, 3 is just written as 3 because it's prime, 6 is written as 2 * 3, and 50 is written as 2 * 5². If you allow primes to have negative exponents, then the fundamental theorem of arithmetic extends to all positive rational numbers (and we can include the negative ones too if we allow multiplying by -1 a single time), so for non-whole numbers, this notation approximates them as fractions (with the same level of precision as Fraction (Medium)) and then takes the prime factorization of that: for example, 5/6 is written as 2^-1 * 3^-1 * 5.
There's no easy formula to calculate the nth prime, so factoring a number into primes is a very hard problem if the number is big enough. As such, this notation only checks prime factors below 10,000 (the last of which is 9,973), so if there are any prime factors in the number above 10,000, they'll slip through as leftovers at the end. However, this still allows the prime factorizations of whole numbers to be accurate up to 100,000,000 (10,000²), as below this point only one prime factor above 10,000 can slip through, which means if there is anything leftover it must be prime. This guarantee doesn't hold above 100,000,000, though: for example, 100,140,049 is 10,007² (10,007 is the first prime that's above 10,000), but the notation doesn't check for 10,007, so the whole 100,140,049 would make it through as a single leftover factor. Since we can't be precise beyond 100,000,000 anyway, we make that clear by writing numbers above 100,000,000 in terms of square roots, then cube roots, and so on, choosing whichever root has the smallest degree that keeps the displayed number below 100,000,000. For larger numbers, there will be a power tower of multiple prime factorizations where all but the topmost two are set to 10,000, and then once that gets high enough the notation switches to writing numbers in terms of super-roots.

Psi Letters and Psi Dash

These two notations were created by former Googology Wiki user PsiCubed2. PsiCubed2's Letter notation, referred to here as Psi Letters, was created to extend scientific/logarithmic notation to higher hyperoperators. E is used for scientific, F for tetration, and G for pentation (you've probably noticed that F is used as the tetrational equivalent of scientific's e all across Eternal Notations, but PsiCubed2's Letter Notation is actually where the use of F for this originates from). Psi Letters starts with scientific with E, but switches to the next letter whenever the number reaches 10. It turns out that, because Eternal Notations uses the linear approximation for tetration and pentation, this notation is the same as Logarithm below 10¹⁰, the same as Super Logarithm between 10¹⁰ and 10↑↑10, and the same as Penta-Logarithm above 10↑↑10.

The notation referred to as Psi Dash here was also created by PsiCubed2: the goal here was to reformat the numbers given in Psi Letters notation in a way such that they tell you what the number actually is, and such that chopping any amount of symbols off the end of an approximation will produce a still valid (albeit less precise) approximation for that number - for example, anything that starts with "F4-" must be between F4 and F5, and anything that starts with "G2-345" must be between G2-345 and G2-346, even something like G2-3457. It's a bit hard to describe Psi Dash without explaining the evaluation process of Psi Letters in detail, but here are some examples:

• If the letter is E, then the first number is the exponent and the second is the digits of the mantissa.
• If it begins with F2-, then the second number is the digits of the exponent and the third is the digits of the mantissa.
• If it begins with F3-, then the second number is the digits of the second exponent, the third is the digits of the first exponent, and the fourth is the digits of the mantissa.
• If it begins with F4-, then the second number is the digits of the third exponent, the third is the digits of the second exponent, the fourth is the digits of the first exponent, and the fifth is the digits of the mantissa.

...and so on. In the case of the letter being G, the first number will be the penta-exponent and the second will be the digits of the highest tetra-exponent, but what comes after that depends on the number. That being said, it's pretty easy in this notation to see when one number is larger than another.

Psi Letters and Psi-Dash work for any base 3 or higher, but because 2^2 = 2^^2 = 2^^^2 = 4, we have to fudge the rules a bit to make it work in binary. Instead of transitioning to the next letter when the first number reaches 2, we wait until it reaches 4, because with a base of 2, E4 = F3, F4 = G3, and so on. This means, beyond E4, the first number in Binary Psi-Dash will always be a 3 (which, since this is binary, is written as 11), and because it's multiple digits long, the "chopping off digits always produces a valid but rougher approximation" rule doesn't apply to those first digits (but it still applies to the digits of the later numbers). In binary, it takes a lot more dash entries to reach the same level of precision, especially for higher letters (including H for hexation, which is too big for base 10, but Psi-Dash in bases 2 and 3 do reach H before Eternal Notation reaches its limit).

Fast-Growing Hierarchy

The Fast-Growing Hierarchy is a system of increasingly powerful functions that are used by "googologists" (people who come up with ridiculously huge numbers) as a sort of "measuring stick" to judge how large those huge numbers are compared to each other. Here's a basic rundown:

• The least powerful function is called f₀, and it's just the successor function: f₀(n) = n + 1.
• f₁(n) = f₀(f₀(f₀...(n))), with n f₀'s in that expression. This means we add 1 to n, n times, which ends up reducing to f₁(n) = 2n.
• f₂(n) = f₁(f₁(f₁...(n))), with n f₁'s in that expression. Now we're repeatedly doubling n (n is doubled n times, to be specific), so this grows exponentially. To be specific, f₂(n) = n * 2ⁿ.
• f₃(n) = f₂(f₂(f₂...(n))), with n f₂'s in that expression. There's no explicit formula for this one, but since it's repeating an exponential function, we know it grows tetrationally: f₃(n) is similar to (but at least slightly greater than) 2↑↑n.

...and so on, with each function being a repeated form of the previous one. On their own, this sequence of functions already mirrors the growth rates of the sequence of hyperoperators (addition, multiplication, exponentiation, tetration, etc.). However, it gets much, much more powerful once "infinite ordinals" come into play. I won't go into full detail on how those work here, so for now, just consider "ω" to be something like a variable, and that whenever we see an ω in a Fast-Growing Hierarchy function and it's in the lowest term of that expression, we replace that ω with the argument to the function itself: f_ω(2) = f₂(2), f_ω(5) = f₅(5), f_ω(493) = f₄₉₃(493), and so on. However, in the case of f_{ω + 1}(3), we don't touch the ω until dealing with the +1 term first, so f_{ω + 1}(3) = f_ω(f_ω(f_ω(3))) (that's 3 iterations of f_ω(3)). Likewise, in f_{ω * 2}(3), only one of the two ω's is converted, so f_{ω * 2}(3) = f_{ω + ω}(3) = f_{ω + 3}(3), while f_ω²(3) = f_{ω * ω}(3) = f_{ω * 3}(3)... and so on.

That stuff with ω isn't important to Eternal Notations's implementation of the Fast-Growing Hierarchy, since even f₄ (being pentational) is too big for Eternal Notations, but it is relevant to the Hardy Hierarchy, a weaker version of the Fast-Growing Hierarchy. In the Hardy Hierarchy, H₀(n) just equals n, and H_{x + 1}(n) just equals H_x(n + 1) rather than being a repeated version of H_x. This means that, for finite x, H_x(n) is just n + x. The rules about replacing ω's with n's still hold, so H_ω(n) = H_n(n) = n + n = 2n, then H_{ω + 1}(n) = H_ω(n + 1) = 2n + 2, H_{ω * 2}(n) = H_{ω + ω}(n) = H_{ω + n}(n) = H_ω(2n) = 4n, H_{ω * 3}(n) = 8n, and so on. Since H_{ω * x}(n) = n * 2^x, H_ω²(n) = H_{ω * ω}(n) = H_{ω * n}(n) = n * 2ⁿ... which you may have noticed is the same as f₂(n). As it turns out, the Fast-Growing and Hardy Hierarchies are quite related: in general, H_ω^x(n) = f_x(n), and H_{a + b}(n) = H_a(H_b(n)) (where a + b may or may not involve ω's). This means that increasing the ordinals in the Hardy Hierarchy is equivalent to applying additional iterations of Fast-Growing Hierarchy functions.

These notations use these two hierarchies to abbreviate numbers. Both notations force the base argument to stay below 1. Fast-Growing Hierarchy notation keeps the amount of iterations of each function to three or less (so whenever a fourth iteration would happen, the next function gains another iteration instead), while Hardy Hierarchy notation keeps the coefficient of each term of the ordinal expression below 10 (so when it would reach 10, the coefficient on the next power of ω is increased by 1 instead).

Omega Layers

Omega Layers is an incremental game made by VeproGames (formerly known as cook1ee) in which there are infinite layers of prestige. Each layer's currency is a Greek letter: the base currency is α, the first prestige layer is β, the second prestige layer is γ, the the third prestige layer is δ, and so on. Omega Layers notation writes a number by answering the question "if you had this many α in Omega Layers, how much of the higher layer currencies would you have?".
For the first couple layers, each layer requires 1e24 of the previous currency to get 1 of the next, and the next layer grows at the rate of the 24th root of the previous, which means it takes x²⁴ times as much α to get x times as much β, and likewise for β to γ. However, starting at δ, each layer multiplies the degree of the root by 1.1 and raises the requirement to the power of 1.1 (the requirement is always 10^(the root)), so ε requires (1e24)^1.1 ≈ 2.51e26 δ, ζ requires (1e24)^1.12 ≈ 1.1e29 ε, and so on. However, this ramping stops after five layers, so from ι onwards, every layer requires around 4.49e38 of the previous one and grows at the rate of the 38.65224th root of the previous one.
The layer names go through the lowercase Greek letters first, then the uppercase letters, then all 48 of those are repeated again but this time as superscripts on an Ω, so after Ω is Ω^α, then Ω^β, then Ω^γ, and so on. After Ω^Ω, the 48 superscripts repeat again and again but with a different subscript on the Ω each time: the subscripts are ψ, ϝ, ϛ, ͱ, ϻ, ϙ, ͳ, and ϸ. This brings the total to 480 layers, and these 480 symbols are then used as digits in bijective base 480, with ↑ between each digit and with the digits in reverse order, so after Ω_ϸ^Ω is α↑α, then β↑α, then γ↑α, and so on; after Ω_ϸ^Ω↑α is α↑β, then β↑β. α↑α↑α comes after Ω_ϸ^Ω↑Ω_ϸ^Ω, then comes β↑α↑α... you get the idea (hopefully). Only up to four digits are shown - if there would be more than four digits, then only the last two digits are shown, followed by ↑↑ and then a letter indicating how many digits aren't shown, so η↑α↑↑ε would have five digits before the η↑α if it were expanded out in full. (The actual game Omega Layers writes the double-arrow number as a plain number rather than a layer symbol, but Eternal Notations writes it as a layer symbol to keep it interesting for larger numbers). Eventually the number after the ↑↑ becomes large enough to be written with a ↑↑ itself, and once there are enough of these, it switches to using a triple-arrow, where the number after the ↑↑↑ indicates how many double-arrows aren't shown.

As for the other two notations in this box: Omega Layers (Ramped) is like regular Omega Layers, except the "multiply the root by 1.1 and raise the requirement to the power of 1.1" starts right at γ and keeps going forever instead of stopping at θ, and Omega Layer Number returns the layer expression of that number (α is layer 1, β is layer 2, and so on).

Increasing Operator

This notation slowly moves up the hyperoperator sequence for larger and larger numbers. Numbers below 10 are written as-is. Above 10, 10 is repeatedly added in the expression to keep the leftover number under 10, so 19 is written as 10 + 9 and 36 is written as 10 + 10 + 10 + 6. Once there are too many "10 +"'s, they're truncated using multiplication, such as 10 * 7 + 6. The number multiplying that 10 can also be written in this notation, so 121 is 10 * (10 + 2) + 1. Once there are enough layers of this, it switches to repeatedly multiplying a whole expression by 10, such as 10 * 10 * 10 * 5.6 for 5,600. Once there are too many "10 *"'s, they're truncated using exponentiation, such as 10^9 * 6.5. That exponent can also be written in this notation, such as 10^(10 * 6 + 4) * 7.89. Once there are enough layers of this, it switches to repeatedly putting a whole expression as an exponent on a 10, such as 10^10^10^(10 + 5). Once there are too many "10^"'s, they're truncated using tetration, such as (10^)^8 4.5 for 4.5F8. That hyperexponent can also be written in this notation, such as (10^)^(10 * 10 * 10 * 6) 1. Once there are enough layers of this... well, we don't get that far, because Eternal Notations hits its limit before we'd get to the next stage.

In addition to the regular Increasing Operator notation described above (which is based on 10), variants are included here based on 2 and 3.

Omega

Omega is a notation created by VeproGames (formerly known as cook1ee). I'm not really sure how to summarize it, so here's how it works:
Numbers below 8,000 are written with a Greek letter and a subscript, where the Greek letter represents a multiple of 1,000 and the subscript represents the leftover number: β is 0, ζ is 1,000, λ is 2,000, ψ is 3,000, Σ is 4,000, Θ is 5,000, Ψ is 6,000, and ω is 7,000. For example, β₅₀ is 50, λ₇₆₃ is 2,763, and Θ₆₀₀ is 5,600. Next, ω^ is placed at the beginning of a number to indicate addition by 8,000, so ω^ψ₀ is 8,000 + 3,000 = 11,000 and ω^ω^ζ₃ is 8,000 + 8,000 + 1,003 = 25,003. If there would be too many ω^'s, they're truncated into an ω(n) expression, where the number inside the parentheses is the amount of ω^'s there would be (in other words, the number inside the parentheses is multiplied by 8,000); for example, ω(9)^Σ₂₀₈ is 8,000 * 9 + 208 = 72,208. If the number inside the parentheses is 10 or greater, it's also written in Omega notation, such as ω(β₁₀₀)^β₀ or ω(ω(8)^ψ₄₅₀)^Ψ₇₇₅. Once there are too many layers of parentheses, a number with brackets is introduced: in an ω[x](y) expression, x layers of parentheses are applied to y. For example, ω[8](Σ₀) would mean ω(ω(ω(ω(ω(ω(ω(ω(Σ₀)))))))) (that's 8 ω('s). Like how ω(x)^y equals 8,000x + y, ω[x](y) equals 8,000^x * y. If the number in the brackets is 100 or greater, then it's also written in Omega notation, and once there are too many layers of brackets, a number in braces is introduced: in an ω{x}[y] expression, x layers of brackets are applied to y. If the number in the braces is 100 or greater, then it's also written in Omega notation.
Expressions in Omega notation can get quite long, so Omega (Short) exists to return shorter ones: these expressions still follow the same rules, they just switch to the next brackets/braces type sooner than regular Omega does.

Fours

This notation is inspired by the "four fours" challenge, in which the goal is to write various numbers using mathematical operations on exactly four 4 digits and no other digits. Which operations are allowed for this varies from iteration to iteration, but typically allowed ones include the four basic operations (+, -, ×, ÷), exponentiation, square roots (for easy access to 2), and factorials (in case 24 ends up being useful somehow). This notation writes all numbers in terms of 4s, but it doesn't stick to having exactly four of them.
The integers from 0 to 15 get their own expressions: 0 is 4-4, 1 is 4÷4, 2 is √4, and so on. For numbers between 16 and 31, we add 4×4 (16) to an expression between 0 and 15. For larger numbers, that 4×4 is multiplied by a number that's also written in this notation. This continues until 1,024 (4⁵), at which point we switch to writing numbers in terms of their square root (using ^(√4)) as the exponent, then their fourth root (^4), then their eighth root (^(4+4)), and so on, doubling the root height each time. Once the root height gets too high, we write the whole expression as an exponent on a 4, such as 4^((4×4)^(4+4)). For larger numbers, there will be multiple layers of 4^, and once there would be too many of those, the notation switches to writing numbers in terms of super-roots, and then finally in terms of a tetra-exponent on a 4.

Polygonal

Polygonal numbers are numbers such that that many dots can be arranged in the form of a given regular polygon. The most well-known of these are the triangular and square numbers: the nth triangular number is the sum of the first n positive integers, i.e. 1 + 2 + 3 + ... + n, which has the formula n * (n+1) / 2. The nth square number is obviously n * n, but it's also the sum of the first n odd integers, i.e. 1 + 3 + 5 + ... + (2n - 1). Since both of these have outright formulas, they can easily be extended to non-whole n. These two notations use these two number sequences/formulas in pretty much the same progression, so I'll just explain Triangular notation here, as Square follows the same progression, just with square numbers instead of triangular ones.

Triangular notation expresses the nth triangular number as △n, so 21 is △6 and 55 is △10. For larger numbers, there will be multiple layers of triangular number taken, such as △(△(△99)). The notation then switches to a "bi-polygonal" expression, where the n in △△n indicates how many times you'd have to apply △ to 2 to reach the target number: for example, △△10 means △(△(△...(△2))) with 10 △'s. (2 was chosen as the base here because it's the smallest integer that works, since the 1st polygonal number for any amount of sides is still 1, but also because 2 is sort of the fundamental starting number for polygonal numbers: the 2nd triangular number is 3, the 2nd square number is 4, the 2nd pentagonal number is 5, and so on). For larger numbers, the number △△ is applied to is also written in this notation, eventually leading to multiple layers of △△, and once there are too many of those it switches to a "tri-polygonal" expression, where the n in △△△n indicates how many times you'd have to apply △△ to 2 to reach the target number: for example, △△△5 means △△(△△(△△(△△(△△2)))) (with 5 △△'s). △△n grows at a double-exponential rate, and △△△n grows at a tetrational rate of " two power tower layers per increase of n by 1".

Double Factorials

In this notation, numbers are written as products of powers of double factorials (numbers of the form (x!)!, which is just written as x!! here). Numbers below 720 are written as-is, as 3!! = 720 is the first double factorial featured here. Once we hit 720, numbers are expressed as a product of 3!! and a coefficient: for example, 1,080 is 1.5 * 3!!. For larger numbers, that 3!! is raised to a power, such as 50 * 3!!^2 or 700 * 3!!^3. This continues until 4!! is reached, at which point a 4!! term enters the product, such as 2 * 3!!^6 * 4!!^2. Further double factorial terms, each of which can have an exponent on them, enter the product once they're reached, though to avoid taking up too much space, only the largest eight terms are shown. This continues up until 3,628,800!! = 10!!!, at which point the entire expression is placed under a factorial. For larger numbers, multiple factorials will be placed on the entire expression, and then the amount of factorials will be written as a number after a single exclamation point, and once the amount of factorials exceeds 720, that amount is also written in Double Factorials notation.

Tritetrated Product essentially does the same thing as Double Factorials, except instead of products of powers of numbers of the form x!!, it's products of powers of numbers of the form x↑↑3.

Grid

Grid notation, as the name implies, writes a number as a grid of squares. The first row of the grid is the number itself, written in binary with empty squares (□) as 0s and filled squares (■) as 1s, but with the digits reversed, so the leftmost square is the 1s place, the next square is the 2s place, the next square is the 4s place, and so on, ending with the rightmost square being the 128s place. If the first row would have more than eight squares, then only the rightmost eight squares are shown, and the second row starts going up. The second row uses the same binary representation as the first row, and whatever number is in the second row, that's how many extra squares before the eight shown would be in the first row if the first row was written out in full; in other words, if the second row holds a number n, then the value of the first row is multiplied by 2ⁿ. Once the second row fills, it does the same thing, with the number in the third row indicating how many extra squares would be in the second row, and in general each row after the first indicates how many extra squares would be in the previous row. If the grid would have more than eight rows, only the final eight rows are shown, and a second 8x8 plane appears: the number represented by the second plane indicates how many extra rows would be in the first plane if the first plane was written out in full. In theory, this could keep going with more planes, and then with a second 8x8x8 cube that would represent the amount of extra planes in the first cube, and so on... but in practice, Eternal Notations's limit is reached shortly after the third row of the second plane starts increasing.

Tetration Float

In a computer, all data is stored as bits (often thought of as "0s and 1s"; each bit can be a 0 or a 1). Implementing integers using bits isn't too hard - just interpret a certain amount of bits as digits of a number in binary - but non-whole numbers are harder to get working. Most programming languages use floating-point to implement non-whole numbers, a system whose level of precision changes depending on the size of the number. In a 32-bit number, the bits are split into three groups: a single bit that controls the sign, eight bits that control the exponent in base-2 scientific notation, and 23 bits that control the fractional part of the mantissa (the whole part of the mantissa in base-2 scientific notation is always 1 except in special cases, so it's not included). This notation writes numbers in a theoretical tetrational equivalent of this system, which is less precise than usual floating point in exchange for fitting break_eternity's entire range of numbers into the 32 bits (for reference, break_eternity's numbers actually take up 192 bits each (though only 129 of those bits (at most) are actually needed), so this notation is much less precise than that).

The first three bits of this notation are special, the next nine are the tetration bits, the next ten are the exponent bits, and the last ten are the mantissa bits. Like in floating point, the mantissa does not include the implied leading 1, so a mantissa of 1 becomes 0000000000 and a mantissa of binary 1.101011 becomes 1010110000. Unlike in floating point, the exponent does not have a bias: if the exponent bits are 0000000010, the exponent is 2, as you'd expect (I'll get to numbers below 1 in a moment). If the tetration bits represent the number T, the exponent bits represent the number E, and the mantissa bits (with the implied leading 1) represent the number M, then the expression (without the three special bits) represents the number 2^2^2^...^(M * 2^E) with T 2's in that power tower before the parentheses.
Now for the special bits. The third bit is the "pentation bit": if the pentation bit is 1, then the 29-bit expression is made into a tetra-exponent on a 2. For example, if the pentation bit is 1, the tetration bits represent 3, the exponent bits represent 10, and the mantissa bits represent 1, then the number is 2^^(2^2^2^(1 * 2^10)). (Though in practice, if the pentation bit is 1 then the tetration bits always represent 0 - break_eternity hits its limit exactly at the point when the tetration bits would move to 1 with the pentation bit being 1.) The first bit is the sign bit: the number is positive if the sign bit is 0, negative if the sign bit is 1. The second bit is the reciprocal bit: if the reciprocal bit is 1, then once you've evaluated the rest of the expression, take the reciprocal of it. For example, whatever the representation of 100 is, 1/100 is the same thing but with the reciprocal bit set to 1 instead of 0.
Because of the reciprocal bit, there's no need for "denormalized" numbers, but there are still a few special cases. If the pentation bits and all nine tetration bits are all 1, the number is treated as infinite: Infinity if the sign bit is 0, -Infinity if the sign bit is 1, and this notation represents 0 as "the reciprocal of infinity". For an infinite number, the exponent and mantissa bits must all be 0s - if they're anything else, it's NaN.

It probably would be a bad idea to actually try and implement arithmetic on these numbers to turn them into an actual number representation system (they're not really precise enough to be usable), but as a notation, I think they work well enough.

Polynomial

These notations writes numbers as polynomial-like expressions, where x has a certain fixed value. Any occurance of a number above the value of x will be changed to be written in terms of x, so the only leftover numbers should be below the value of x. For example, when x = 10, 12 is written as x + 2, 56 is writen as 5x + 6, and 130 is written as x² + 3x. I said "polynomial-ish" because in a real polynomial the exponents on the x's are always nonnegative integers, but here the exponents will also be written in terms of x once they go above the value of x, so things like x^x, x^{3x + 5}, and x^{4xx + 1+ 6} can show up. To keep the expression from getting too long, only the highest 8 terms are shown, and once the number gets too high it stops showing multiple terms at all. For even higher numbers, it'll just put an "x^" at the beginning of the expression, and once there are too many of these x^'s it will truncate them into an (x^)^n expression: for example, (x^)^8 3x + 5 means x^x^x^x^x^x^x^x^(3x + 5) (with 8 x^'s)... and when that tetra-exponent is above the value of x, it's also written as a polynomial.
In addition to the x = 10 version, an x = 2 version and an x = 3 version have been provided.
As for Rational Function, it expresses numbers as fractions (using the same level of precision as Fraction (Medium)) where the numerator and denominator are polynomials.

Fractional Bases

All the other number bases included here have been whole number bases: binary is base 2, ternary is base 3, quaternary is base 4, seximal is base 6, and so on, and of course the normal decimal system is base 10. However, while it doesn't quite make as much sense as it does for whole numbers, it's possible for a number base to have a non-whole base number: for example, in base 1.5, the place values are 1, 1.5, 1.5^2, 1.5^3, and so on. These number bases have a big disadvantage, though: it's no longer clear what numbers are integers and what numbers aren't, as even integers will now often require decimal places to write. Aside from base 1.5 (which is included as a basic example of what a non-integer number base looks like), the other three fractional number bases here are based on important irrational mathematical constants: phi (the golden ratio, equal to (1 + √5)/2, which is around 1.618; this base is interesting because, while integers may require decimal places here, they'll only need a finite amount of decimal places), e (Euler's number, which is around 2.718; e is an important number in calculus), and pi (the ratio of a circle's circumference to its diameter, which is around 3.1415; probably the most famous irrational number).
(If you're wondering why these bases display so many decimal places, it's because of how Eternal Notations implements them: the way it implements other bases doesn't work with fractional bases, so these bases are made by bootstrapping Polynomial notation instead)

Parentheses

You thought Brackets was confusing? This notation is even worse!
...Okay, it actually follows pretty simple rules. The empty string is 0, closed parentheses around any string means 2^(whatever that string's value is), and two adjacent terms are added. For numbers between 1 and the tetrational range, those are the only rules... but they result in chaos. Let's walk through the first few: 1 is 2^0 so it's (), 2 is 2^1 so it's (()), 3 is 2 + 1 so it's (())(), 4 is 2^2 so it's ((())), 5 is 4 + 1 so it's ((()))(), 6 is 4 + 2 so it's ((()))(()), 7 is 4 + 2 + 1 so it's ((()))(())(), and 8 is 2^3 = 2^(2 + 1) so it's ((())()). The strings of nested parentheses get ridiculously long quickly: for example, 500 is 256 + 128 + 64 + 32 + 16 + 4, i.e. 2^8 + 2^7 + 2^6 + 2^5 + 2^4 + 2^2, and expanding that out further ultimately leads to 500 being written as (((())()))(((()))(())())(((()))(()))(((()))())(((())))((())).
Beyond 1024, only the largest ten terms are showed, though even with this provision the strings still get unreasonably long. For huge numbers, there would be too many nested parentheses to write out, so eventually brackets are introduced: if there's an expression in brackets, whatever comes after the brackets would be nested in that many additional parentheses if written out in full. For example, [((()))()](())() means "take (())() and nest it in ((()))() = 5 additional layers of parentheses", i.e. ((((((())()))))).
This notation typically rounds to the nearest whole number. Negative numbers have an unmatched ) at the beginning, and an expression in braces means "take the reciprocal of this expression".

Omega Meta Zero

Omega Meta Zero is a "zero-player incremental game" (i.e. an extended animation of a number going up) by VeproGames. It's basically a showcase of its notation, which is a revamped and extended version of the notation from Omega Layers. The notation just called "Omega Meta Zero" here is the Layer Number notation for this scheme, and Omega Meta Zero (Alpha Amount) is how the number actually shows up in Omega Meta Zero, which still pretends that there's a system of prestige layers in play. Unlike in Omega Layers, there's no ramping this time, but the distance between each layer is higher: each layer always requires 1.79e308 (2^1024, to be precise) of the previous one and grows at the rate of the 308.2547th (log10(2^1024)) root of the previous one. The actually interesting part of this notation is how the layer names work.

• The Greek letters are still used for the first few layers: α, β, γ, δ, and so on. Notably, unlike Omega Layers, the system isn't a bijective base this time, so α means 0, β means 1, γ means 2, and so on.
• After Ω is still Ω^α, then Ω^β, and so on, but now the tower height doesn't stop at 2, so after Ω^Ω is Ω^Ωα. This continues up until a tower height of 5, so the largest number in this stage is Ω^ΩΩΩΩ, which stands for 239.
• The archaic Greek letters (ϝ, ϛ, ͱ, ϻ, ϙ, ͳ, and ϸ) now show up separately instead of as subscripts, the expression resets the tower of Ω's entirely when the archaic Greek letter increases, and since the base isn't bijective anymore, ϝ is a zero digit, so after Ω^ΩΩΩΩ is ϛ(α), then ϛ(β), and so on all the way up to ϛ(Ω^ΩΩΩΩ), and after that is ͱ(α), and so on. The archaic Greek letters also do "towers", so the next one after ϸ is ϸ^ϝ, then the next one after ϸ^ϸ is ϸ^ϸϝ, and so on, with the tower height also going up to 5 here. There's also a third tier of symbols, which resets both the regular and archaic Greek letters when they increase. This third tier uses the alchemical symbols for the nine planets: ☿, ♀, ♁, ♂, ♃, ♄, ♅, ♆, and ♇. This stage of the system goes up to ♇^♇♇♇♇(ϸ^ϸϸϸϸ(Ω^ΩΩΩΩ)), which stands for 377,999.
• The three symbol tiers are then combined into a single "digit" in a base-378,000 system. Digits after the largest one are placed in brackets and as a subscript, so 378,000 is β_[α]. Only a maximum of three digits are shown, however: once the number would reach a fourth digit, it switches to a form of scientific notation, where two digits are shown and there's an expression before them in braces which represents the exponent in base-378,000 scientific notation (as if there was a decimal point after the first digit). Eventually, the exponent will get large enough that it's written in this scientific form itself - at around this point, the digits after the original exponent become basically meaningless, so those digits stop being written out, replaced with only the character ◯.
• Finally, at eeee9e15 (by which point the braces are four layers deep and nearing a fifth layer), the notation suddenly switches to base-10 hyperscientific, where the mantissa and hyperexponent are both written in Omega Meta Zero notation, and the hyperexponent is placed before the mantissa and is wrapped inside "<|" and "|>:", so mFh is written as <|h|>m, where h and m are written in this notation themselves.

Filling Fractions

This notation uses Unicode's fraction characters to represent filling-up "progress bars". The first digit fills up by halves, so 1 is written as ½ and 2 is written as 1, because after 2 the "halves progress fraction" is full. When a fraction is "full" and tries to increase again, it resets to 0 and the next one increases. The second fraction fills by thirds, and since the first fraction has three values (0, ½, 1), it increases by a third every increase by 3 of the number, so 3 is ⅓0, 4 is ⅓½, 5 is ⅓1, 6 is ⅔0, 9 is 10, and 11 is 11. The third fraction (which increases by 1 whenever the second fraction overflows, which happens at multiples of 12) goes up by fourths, the fourth fraction goes up by fifths, the fifth fraction goes up by sixths, and since Unicode doesn't have characters for all of the sevenths, the sixth fraction goes up by eighths. This is essentially a mixed-radix base where the digits are in bases 3, 4, 5, 6, 7, and 9, but represented as fractions.

After the eighths fraction fills, it goes into a second halves fraction, then a second thirds fraction, and so on, with the set of six fractions looping for higher digits - a / is placed between each set of six fractions. A single set of these fractions below the ones place is shown for non-integers, with a \ separating the ones place from the sub-ones set of fractions. For larger numbers, a double-slash ( // ) separates sets of fractions in the style of Hypersplit: if there's one double-slash, the set of fractions before the double-slash represents how many extra sets of six fractions have been truncated off the end of the set of fractions after the double-slash, like an exponent in scientific notation. If there are two double-slashes, the second and third sets are the exponent and mantissa from before, while the first set is a hyperexponent, representing how many extra layers of exponents would be in the full expression. If there are three double-slashes, the first and second sets are the exponent and mantissa for the hyperexponent, the third and fourth sets are the exponent and mantissa for the hypermantissa.

Blind

Do you hate numbers? Then you'll love this notation! In this notation, you can't see the numbers!

Powers of One

Whatever number you put into this notation, this notation will display 1 to the power of that number (1ⁿ).

This last one isn't really a "notation", exactly. Inspired by the "if every antimatter were a planck volume" bit on the Statistics screen in Antimatter Dimensions, this box takes a number and tries to give it a physical meaning, to get across how big the number actually is. Here's what it does for various sizes of numbers:

• For reasonably-sized numbers, it takes that many litres of water (a litre is a unit of volume equal to 1,000 cm³; for Americans, 1 litre is around 1.057 quarts. A typical large water bottle holds about a litre of water) and tells you how much volume could be filled with that much water. This starts with everyday objects like fridge freezers and school buses, then moves to landmarks like harbors, lakes, and oceans, then to celestial bodies like Earth and Jupiter, and finally to even bigger cosmic things like galaxies. The Wikipedia article Orders of magnitude (volume) was used for the volumes of some of these objects (it should be noted that Antimatter Dimensions also used that article as its source for that Statistics screen bit). Once the amount of water is too large for even the observable universe to work as a unit, it switches to using the same objects again but in a hypothetical 4D universe, then 5D, then 6D, and so on.
• Once the numbers get too big for that, it starts looking at exponential growth: if you started with a single bacteria that split in two every second and the bacterial colony had infinite space and resources to grow, how long would it take for its population to reach the target number?
• The amount of ways to rearrange n objects grows at the rate of n!, which is faster than exponential growth, so once the bacteria scenario becomes too cumbersome, it switches to counting the amount of ways to rearrange all of the atoms in a given object or set of objects. Then, once that too exceeds the universe, it goes back to the bacteria scenario but now counting the amount of ways to rearrange all of the bacteria, then it goes back to atoms but now counts the amount of ways to rearrange a list of all the rearrangements of the atoms, and so on, swapping back and forth between atoms and the bacteria scenario, rearranging rearrangements of rearrangements and so on...
• ...but ultimately, there is no way to make physical sense of tetrational numbers, no matter how hard you try - they're just too big to have any physical meaning at all. As such, for large enough tetrational numbers, it gives up on trying to express the number itself and switches to expressing how tall the power tower would be if you wrote out the number as a power tower of 10s. Even this, which is essentially looking at the super-logarithm of the number, exceeds the universe eventually, so we have to start looking at larger hypothetical universes to make it to break_eternity's limit.