O Que Vem Depois De Quadrilhão

What Comes After Quadrillion: The Naming Systems and Why They Matter in Practice

Most people who ask about o que vem depois de quadrilhão are looking for the next name in the counting sequence. That is straightforward enough, but the real answer depends entirely on which numbering system you are working with. There are two major systems in use, and they diverge at quadrillion. If you use the short scale — which is standard in the US, modern UK, and most scientific literature — then quadrillion is 10^15, and the next number is quintillion at 10^18. From there it continues linearly: sextillion (10^21), septillion (10^24), octillion (10^27), nonillion (10^30), decillion (10^33), and it keeps going with the Latin root incremented by one each step. The long scale, used in many European countries historically, defines quadrillion differently as 10^24. Under that system, quintillion becomes 10^30. The gap between each named number doubles. This is not a minor distinction. It matters if you are reading older scientific papers from continental Europe or working with legacy systems. In practical computation, the question usually comes up when you hit the limits of your language's number types. I ran into this directly when processing astronomical dataset files where certain aggregate counters were stored in JSON responses. JavaScript's Number type maxes out at 2^53 - 1, which is roughly 9 × 10^15. That sits right between quadrillion and quintillion in the short scale. Any calculation above that threshold silently loses precision. I was computing a checksum over a dataset that had accumulated values past 10^18 and got back incorrect results without any error being thrown. JavaScript does not warn you. It just rounds to the nearest representable float64 value. The workaround is to use BigInt in modern JavaScript environments, or fall back to a string-based arithmetic library for older runtimes. In Python, arbitrary precision integers handle this natively, so you rarely hit a wall unless you are deliberately mixing in floating-point libraries like NumPy, which default to float64 and will overflow or lose precision well before you reach nonillion. I found that out the hard way when running a NumPy aggregation on a 12GB dataset — the cumulative sum rolled over into negative territory because float64 cannot accurately represent integers above 2^53. Switching to Python's built-in int type fixed it immediately, but the initial debugging took several hours because the overflow produced no exception.

For extremely large numbers beyond what most programming languages handle comfortably, the gmpy2 library gives you access to the GNU MP Bignum library. It supports exact arithmetic on integers of virtually unlimited size. If you are doing something like enumerating all possible combinations in a combinatorial problem where the answer exceeds quintillion, gmpy2 is the tool you use. The trade-off is speed. Arbitrary precision arithmetic is significantly slower than native CPU integer operations. A multiplication of two 100-digit numbers in gmpy2 takes roughly 10 to 50 microseconds depending on your hardware. That sounds small until you are doing millions of them.

Naming Beyond Decillion

After decillion (10^33), the sequence continues using the same Latin prefix pattern: undecillion (10^36), duodecillion (10^39), tredecillion (10^42), quattuordecillion (10^45), quinqudecillion (10^48), sexdecillion (10^51), septendecillion (10^54), octodecillion (10^57), novemdecillion (10^60), vigintillion (10^63). The pattern holds indefinitely. Each step adds three zeros in the short scale. This is defined formally in the ISO 80000-1 standard, which most engineers and scientists rely on when they need unambiguous terminology. The system was popularized in English-speaking countries in the 19th century and has since become the de facto standard in technical fields. A common pitfall is assuming that all countries use the short scale. France switched from the long scale to the short scale officially in 1961, but you will still encounter long-scale usage in French mathematics textbooks published before that date. Germany similarly transitioned, though the long scale persists in some German-speaking academic contexts. If you are translating technical documentation or reading multilingual research, this discrepancy can cause a factor-of-10^9 error if you misidentify the system. That is a catastrophic mistake in fields like cryptography or particle physics where the difference between 10^18 and 10^27 is the difference between feasible and infeasible key spaces.

When the Names Stop Being Useful

The real limit of these naming systems appears around googol (10^100) and googolplex (10^(10^100)). No practical computational system deals with numbers this large in everyday work. I have never encountered a legitimate use case for exact integer representation beyond roughly 10^500 in my experience, and even that is rare. Most applications that need large number support are working in modular arithmetic or using approximations, not storing the full value. One area where exact large-number representation does matter is integer factorization and primality testing. Cryptographic libraries like those used in RSA implementations need to handle numbers with hundreds or thousands of digits. But they do not care about whether you call 10^33 a decillion. They care about bit length. A 1024-bit RSA key is approximately 10^308. The naming system becomes irrelevant at that scale. You work in bits or decimal digits, not in named powers of ten. If you need a quick reference for the sequence, the most reliable source is the Mathieu Blondel Python library or simply checking the OEIS sequence A000000 range for extended large number names. There is no official download link because this is a naming convention, not software. But if you need to programmatically convert between names and values, a simple mapping dictionary in Python covers the first few dozen names and handles the conversion in milliseconds.

The important thing to keep in mind is that beyond a certain point, the names are purely academic. In actual computation, you are working with exponents and digit strings, not verbal labels. The naming system is useful for communication between humans, not for machines. If someone asks you what comes after quadrillion in conversation, you now know the answer depends on which convention they learned, and you know to clarify which system they are using before you give a definitive number.