Formula: GB = Bytes ÷ 1,073,741,824

That's 2^30 bytes in binary

The Journey from Bytes to GB

1 Byte
0.000000001 GB
Single character
1 KB
0.000001 GB
Small text file
1 MB
0.001 GB
Digital photo
1 GB
1.0 GB
HD movie

Bytes to GB Examples

1,000,000

= 0.000931 GB

1 million bytes

100,000,000

= 0.0931 GB

100 MB file

536,870,912

= 0.5 GB

Half gigabyte

1,073,741,824

= 1 GB

Exact gigabyte

5,368,709,120

= 5 GB

Large download

17,179,869,184

= 16 GB

RAM capacity

Bytes to GB Reference

Bytes GB (Binary) GB (Decimal) Context
1 9.31×10⁻¹⁰ GB 1×10⁻⁹ GB Single byte
1,024 9.54×10⁻⁷ GB 1.02×10⁻⁶ GB 1 Kilobyte
1,048,576 0.000977 GB 0.001049 GB 1 Megabyte
10,737,418 0.01 GB 0.0107 GB 10 MB mark
107,374,182 0.1 GB 0.107 GB 100 MB mark
268,435,456 0.25 GB 0.268 GB Quarter GB
536,870,912 0.5 GB 0.537 GB Half GB
1,000,000,000 0.931 GB 1.0 GB 1 billion bytes
1,073,741,824 1.0 GB 1.074 GB True gigabyte
34,359,738,368 32 GB 34.36 GB Common RAM size

Understanding Byte-Level Precision

Why Bytes to GB?

Direct conversion use cases:

  • APIs: Return sizes in bytes
  • File systems: Report exact byte counts
  • Databases: Store sizes as BIGINT bytes
  • Programming: Memory allocation in bytes
  • Networks: Transfer counts in bytes

Most systems work in bytes internally

Programming Examples

// JavaScript
const bytes = file.size;
const gb = bytes / (1024**3);

// Python
import os
bytes = os.path.getsize(file)
gb = bytes / (1024**3)

// SQL
SELECT
  file_size_bytes / 1073741824.0 AS gb
FROM files;

Precision Matters

Why exact byte counts:

  • Checksums require exact bytes
  • Bandwidth billing per byte
  • Storage quotas enforced by bytes
  • Memory limits in bytes
  • File comparison needs precision
Float GB Loses precision
Integer bytes Always exact

Maximum Values

System byte limits:

32-bit signed 2 GB max
32-bit unsigned 4 GB max
64-bit signed 8,589,934,592 GB
JavaScript Number 9,007,199 GB safe
File system (ext4) 16,777,216 GB

Real-World Byte Counts

Common file sizes in bytes:

  • Empty file: 0 bytes
  • Text "Hello": 5 bytes
  • Typical email: 75,000 bytes
  • Web page: 2,000,000 bytes
  • MP3 song: 8,000,000 bytes
  • App update: 100,000,000 bytes
  • Movie file: 2,000,000,000 bytes

Common Byte Counts and What They Mean

Raw byte counts turn up in Windows file properties (“Size: 1.00 GB (1,073,741,824 bytes)”), in code, in server logs and in API responses. These are the figures people most often need to translate.

Bytes GB (binary) GB (decimal) Where you see it
1,073,741,8241.001.07Exactly 1 GiB (230)
4,294,967,2954.004.29FAT32 maximum file size
4,700,000,0004.384.70Single-layer DVD
25,000,000,00023.2825.00Single-layer Blu-ray
128,000,000,000119.21128.00“128 GB” phone or SSD

If a byte count is too small to read sensibly in gigabytes, use the bytes to MB or bytes to KB converter. To see what a given capacity will actually hold, try the how many files fit calculator or the storage calculator.

Frequently Asked Questions

Why is 1 GB exactly 1,073,741,824 bytes in binary?

It's 2^30 (2 to the power of 30). In binary: 2^10 = 1024 (KB), 2^20 = 1,048,576 (MB), 2^30 = 1,073,741,824 (GB). This power-of-2 progression aligns with how computer memory is addressed using binary digits.

When should I work with bytes instead of GB?

Use bytes when you need exact precision: file integrity checks, quota enforcement, bandwidth accounting, API responses, database storage, or any calculation where rounding errors matter. Convert to GB only for human-readable display.

How do I handle numbers this large in programming?

Use 64-bit integers (long/int64) for exact byte counts up to 9.2 exabytes. For JavaScript, numbers are safe up to 2^53-1 (about 9 petabytes). For larger values or when precision is critical, use BigInt or specialized libraries.

Why do file properties show both bytes and GB?

Bytes provide the exact size for technical operations (copying, comparing, checksums), while GB gives humans a quick understanding of scale. Operating systems show both because different use cases require different precision levels.

What's the most efficient way to sum many byte values?

Accumulate in bytes (as integers) and convert to GB only at the end. This prevents rounding errors that compound when adding floating-point GB values. For billions of files, consider using arbitrary-precision arithmetic libraries.