Computed, not transcribed
Values are computed with BigInt, so every digit above 2⁵³ is exact rather than rounded to a JavaScript double. The binary-size column uses the IEC prefixes (Ki, Mi, Gi …), which are powers of 1024 by definition.
2⁰ to 2⁶⁴ with exact values, hexadecimal notation and the matching binary data sizes — the table behind every byte, kibibyte and address space.
Powers listed
2⁰ – 2⁶⁴
Digits at 2⁶⁴
20
2¹⁰
1 KiB
2⁶⁰
1 EiB
2¹⁰ is 1,024, 2²⁰ is 1,048,576, and 2⁶⁴ is 18,446,744,073,709,551,616 — the ceiling of a 64-bit address space.
65 of 65 rows
| Power | Exact value | Hex | Digits | Data size |
|---|---|---|---|---|
| 2⁰ | 1 | 0x1 | 1 | — |
| 2¹ | 2 | 0x2 | 1 | — |
| 2² | 4 | 0x4 | 1 | — |
| 2³ | 8 | 0x8 | 1 | — |
| 2⁴ | 16 | 0x10 | 2 | — |
| 2⁵ | 32 | 0x20 | 2 | — |
| 2⁶ | 64 | 0x40 | 2 | — |
| 2⁷ | 128 | 0x80 | 3 | — |
| 2⁸ | 256 | 0x100 | 3 | — |
| 2⁹ | 512 | 0x200 | 3 | — |
| 2¹⁰ | 1,024 | 0x400 | 4 | 1 KiB |
| 2¹¹ | 2,048 | 0x800 | 4 | 2 KiB |
| 2¹² | 4,096 | 0x1000 | 4 | 4 KiB |
| 2¹³ | 8,192 | 0x2000 | 4 | 8 KiB |
| 2¹⁴ | 16,384 | 0x4000 | 5 | 16 KiB |
| 2¹⁵ | 32,768 | 0x8000 | 5 | 32 KiB |
| 2¹⁶ | 65,536 | 0x10000 | 5 | 64 KiB |
| 2¹⁷ | 131,072 | 0x20000 | 6 | 128 KiB |
| 2¹⁸ | 262,144 | 0x40000 | 6 | 256 KiB |
| 2¹⁹ | 524,288 | 0x80000 | 6 | 512 KiB |
| 2²⁰ | 1,048,576 | 0x100000 | 7 | 1 MiB |
| 2²¹ | 2,097,152 | 0x200000 | 7 | 2 MiB |
| 2²² | 4,194,304 | 0x400000 | 7 | 4 MiB |
| 2²³ | 8,388,608 | 0x800000 | 7 | 8 MiB |
| 2²⁴ | 16,777,216 | 0x1000000 | 8 | 16 MiB |
| 2²⁵ | 33,554,432 | 0x2000000 | 8 | 32 MiB |
| 2²⁶ | 67,108,864 | 0x4000000 | 8 | 64 MiB |
| 2²⁷ | 134,217,728 | 0x8000000 | 9 | 128 MiB |
| 2²⁸ | 268,435,456 | 0x10000000 | 9 | 256 MiB |
| 2²⁹ | 536,870,912 | 0x20000000 | 9 | 512 MiB |
| 2³⁰ | 1,073,741,824 | 0x40000000 | 10 | 1 GiB |
| 2³¹ | 2,147,483,648 | 0x80000000 | 10 | 2 GiB |
| 2³² | 4,294,967,296 | 0x100000000 | 10 | 4 GiB |
| 2³³ | 8,589,934,592 | 0x200000000 | 10 | 8 GiB |
| 2³⁴ | 17,179,869,184 | 0x400000000 | 11 | 16 GiB |
| 2³⁵ | 34,359,738,368 | 0x800000000 | 11 | 32 GiB |
| 2³⁶ | 68,719,476,736 | 0x1000000000 | 11 | 64 GiB |
| 2³⁷ | 137,438,953,472 | 0x2000000000 | 12 | 128 GiB |
| 2³⁸ | 274,877,906,944 | 0x4000000000 | 12 | 256 GiB |
| 2³⁹ | 549,755,813,888 | 0x8000000000 | 12 | 512 GiB |
| 2⁴⁰ | 1,099,511,627,776 | 0x10000000000 | 13 | 1 TiB |
| 2⁴¹ | 2,199,023,255,552 | 0x20000000000 | 13 | 2 TiB |
| 2⁴² | 4,398,046,511,104 | 0x40000000000 | 13 | 4 TiB |
| 2⁴³ | 8,796,093,022,208 | 0x80000000000 | 13 | 8 TiB |
| 2⁴⁴ | 17,592,186,044,416 | 0x100000000000 | 14 | 16 TiB |
| 2⁴⁵ | 35,184,372,088,832 | 0x200000000000 | 14 | 32 TiB |
| 2⁴⁶ | 70,368,744,177,664 | 0x400000000000 | 14 | 64 TiB |
| 2⁴⁷ | 140,737,488,355,328 | 0x800000000000 | 15 | 128 TiB |
| 2⁴⁸ | 281,474,976,710,656 | 0x1000000000000 | 15 | 256 TiB |
| 2⁴⁹ | 562,949,953,421,312 | 0x2000000000000 | 15 | 512 TiB |
| 2⁵⁰ | 1,125,899,906,842,624 | 0x4000000000000 | 16 | 1 PiB |
| 2⁵¹ | 2,251,799,813,685,248 | 0x8000000000000 | 16 | 2 PiB |
| 2⁵² | 4,503,599,627,370,496 | 0x10000000000000 | 16 | 4 PiB |
| 2⁵³ | 9,007,199,254,740,992 | 0x20000000000000 | 16 | 8 PiB |
| 2⁵⁴ | 18,014,398,509,481,984 | 0x40000000000000 | 17 | 16 PiB |
| 2⁵⁵ | 36,028,797,018,963,968 | 0x80000000000000 | 17 | 32 PiB |
| 2⁵⁶ | 72,057,594,037,927,936 | 0x100000000000000 | 17 | 64 PiB |
| 2⁵⁷ | 144,115,188,075,855,872 | 0x200000000000000 | 18 | 128 PiB |
| 2⁵⁸ | 288,230,376,151,711,744 | 0x400000000000000 | 18 | 256 PiB |
| 2⁵⁹ | 576,460,752,303,423,488 | 0x800000000000000 | 18 | 512 PiB |
| 2⁶⁰ | 1,152,921,504,606,846,976 | 0x1000000000000000 | 19 | 1 EiB |
| 2⁶¹ | 2,305,843,009,213,693,952 | 0x2000000000000000 | 19 | 2 EiB |
| 2⁶² | 4,611,686,018,427,387,904 | 0x4000000000000000 | 19 | 4 EiB |
| 2⁶³ | 9,223,372,036,854,775,808 | 0x8000000000000000 | 19 | 8 EiB |
| 2⁶⁴ | 18,446,744,073,709,551,616 | 0x10000000000000000 | 20 | 16 EiB |
The “Exact value” column is computed with BigInt. From 2⁵³ upward an ordinary JavaScript number could no longer hold the digits without error — here they are correct to the last place.
The “Data size” column uses the IEC prefixes Ki, Mi, Gi. They are exact powers of 1024 and therefore the only units that fit powers of two without rounding.
Every tenth row is highlighted: that is where the data size steps up to the next IEC tier.
Hover the chart to read the precise values.
On a logarithmic axis, doubling is a straight line — every tenth power is worth roughly three powers of ten.
Hover the chart to read the precise values.
Roughly every 3.32 doublings adds one decimal digit — that is the reciprocal of log₁₀(2).
Hover the chart to read the precise values.
This is why a “1 TB” drive shows about 0.91 TiB in the operating system: the manufacturer counts in decimal, the system in binary.
Values are computed with BigInt, so every digit above 2⁵³ is exact rather than rounded to a JavaScript double. The binary-size column uses the IEC prefixes (Ki, Mi, Gi …), which are powers of 1024 by definition.
Last checked against the sources on August 6, 2026.
2¹⁰ is 1,024. Because that is close to 1,000, this power is called “kibi” (Ki) — 1 KiB is 1,024 bytes.
2⁶⁴ is 18,446,744,073,709,551,616 — a 20-digit number. It is the count of distinct values a 64-bit register can hold.
1 kB is 1,000 bytes, 1 KiB is 1,024 bytes. The gap is 2.4 % and grows with every tier: at TiB versus TB it is already 10.0 %.
About every 3.32 powers adds one decimal digit, because log₁₀(2) is roughly 0.301. 2¹⁰ has 4 digits, 2²⁰ has 7, 2³⁰ has 10.
Because a bit has exactly two states. n bits therefore distinguish 2ⁿ values, which fixes address spaces, colour depths, buffer sizes and the ranges of data types.
Yes. They are computed with BigInt, which represents integers of arbitrary size exactly. An ordinary floating-point number would start rounding above 2⁵³.
From the ASCII table to SI prefixes and the physical constants — every lookup table in one place.
Open the Number Base Converter