Base Converter Calculator - Convert Between Number Systems

Convert numbers between binary, octal, decimal, hexadecimal and other bases up to 36. Essential for programmers and students.

Base Converter
Convert numbers between bases 2 and 36. Supports fractional parts with adjustable precision.
Custom
Custom
Uppercase
Result
Output in base 10. Copy or share the result easily.
Allowed characters for base 2: 0101
Conversion History
Recent conversions (last 10). Click apply to reuse.
History persists for this session.
No history yet. Convert something to see it here.
Tips & Notes
Accuracy and formatting considerations
  • Fractional conversion uses floating arithmetic; rounding may occur beyond the specified precision.
  • Grouping inserts spaces for readability; copy result without spaces if needed.
  • Uppercase applies to alphabetic digits A–Z when bases exceed 10.
  • Custom bases must be between 2 and 36 inclusive.
  • Use presets to quickly switch between common conversions like binary, decimal, octal, and hexadecimal.
↑

Quick Navigation

›Understanding Number Bases
›Common Base Systems
›Conversion Methods
›Binary Operations
›Hexadecimal Guide
›Programming Applications
›Conversion Tips & Tricks
›Advanced Topics
›Common Mistakes
›Frequently Asked Questions

Universal Converter: Transform numbers between any base from 2 to 36, supporting integers, fractions, and negative numbers with precise conversion algorithms.

Understanding Number Bases

Flip a light switch and you're working with binary—on or off, one or zero—the same two-state system that powers every digital device from your phone to supercomputers. But while computers think in binary, humans struggle with endless strings of ones and zeros, which is where hexadecimal swoops in as our translator, packing four binary digits into a single character that our brains can actually process. Each number system—whether the base-10 decimal we learn as children or the base-16 hexadecimal beloved by programmers—operates on the same positional principle where a digit's location determines its value through powers of the base. The DePaul University binary systems tutorial walks through how modern computers represent data using these different bases, from basic integers to complex data structures. Grasping these different numbering systems and their conversion methods opens doors to understanding everything from memory addresses to network protocols, transforming mysterious hexadecimal dumps into readable information and demystifying the programming applications that depend on them.

🔢 Positional Notation

Each digit's value depends on its position, representing base^position multiplied by the digit value.

💻 Digital Foundation

Binary underlies all digital computing, with each bit representing an on/off state in circuits.

🎯 Precision Control

Different bases offer varying precision and compactness for representing numerical values.

🔄 Universal Conversion

Convert between any bases from 2 to 36 using systematic algorithms and techniques.

Common Base Systems and Their Uses

Different number bases serve specific purposes in computing and mathematics. Binary (base-2) forms the foundation of digital electronics, while hexadecimal (base-16) provides a compact representation for binary data. Octal (base-8) has historical significance and current applications in Unix systems. Understanding when and why to use each system enhances your ability to work with binary operations and hexadecimal notation.

  • Binary (Base-2): Uses only 0 and 1. Foundation of all digital computing, representing electrical states (on/off). Essential for understanding computer architecture, bitwise operations, and digital logic.

  • Octal (Base-8): Uses digits 0-7. Historically important in early computing systems. Still used in Unix/Linux file permissions where each digit represents read, write, and execute permissions.

  • Decimal (Base-10): Uses digits 0-9. The standard system for human calculations and everyday mathematics. Natural for humans due to having ten fingers.

  • Hexadecimal (Base-16): Uses 0-9 and A-F. Compact representation of binary data, widely used for memory addresses, color codes, and debugging. Each hex digit represents exactly 4 binary bits.

  • Base-64: Uses 64 characters including letters, numbers, and symbols. Essential for encoding binary data as text for transmission over text-only protocols like email and JSON.

💡 Base System Comparison

Binary
2 digits: 0-1 - Hardware level operations
Decimal
10 digits: 0-9 - Human calculations
Hexadecimal
16 digits: 0-F - Compact binary representation

Number Base Conversion Methods

Converting between number bases requires systematic approaches that vary depending on the source and target bases. The most common methods include division-remainder for converting from decimal, and positional expansion for converting to decimal. Special shortcuts exist for conversions between powers of 2 (binary, octal, hexadecimal). Master these techniques to efficiently work with programming applications and avoid common conversion errors.

📊 Division-Remainder Method

For Decimal to Any Base:
  • Divide the decimal number by the target base
  • Record the remainder (this becomes a digit)
  • Continue with the quotient until it becomes 0
  • Read remainders in reverse order
Example: 156 to Binary
  • 156 ÷ 2 = 78 remainder 0
  • 78 ÷ 2 = 39 remainder 0
  • 39 ÷ 2 = 19 remainder 1
  • Continue... Result: 10011100

🔢 Positional Expansion Method

For Any Base to Decimal:
  • Multiply each digit by base^position
  • Position starts at 0 from the right
  • Sum all the products
  • Result is the decimal equivalent
Example: Binary 1101 to Decimal
  • 1×2³ = 8
  • 1×2² = 4
  • 0×2¹ = 0
  • 1×2⁰ = 1
  • Sum: 8+4+0+1 = 13

⚡ Quick Conversion Shortcuts

Conversions between bases that are powers of 2 can be done by grouping digits:
Binary ↔ Octal
Group binary by 3 digits
Binary ↔ Hex
Group binary by 4 digits
Octal ↔ Hex
Convert through binary

Binary Operations and Arithmetic

Binary arithmetic forms the foundation of all computer calculations. Understanding how to perform addition, subtraction, multiplication, and division in binary, along with bitwise operations, is essential for low-level programming, embedded systems, and computer architecture. These operations directly translate to how processors execute instructions at the hardware level. Explore hexadecimal representations for more compact notation of binary operations.

Binary Addition Rules

  • • 0 + 0 = 0
  • • 0 + 1 = 1
  • • 1 + 0 = 1
  • • 1 + 1 = 10 (0 with carry 1)
  • • 1 + 1 + 1 = 11 (1 with carry 1)

Bitwise Operations

  • • AND: Sets bit if both bits are 1
  • • OR: Sets bit if either bit is 1
  • • XOR: Sets bit if bits are different
  • • NOT: Inverts all bits
  • • Shift: Moves bits left or right

Two's Complement for Negative Numbers

Two's complement is the standard method for representing negative numbers in binary. This system allows computers to perform subtraction using the same circuits as addition, simplifying hardware design. To find the two's complement: invert all bits (one's complement), then add 1. This representation provides a unique zero and makes arithmetic operations consistent. Understanding two's complement is crucial for system programming and debugging signed integer issues.

Two's Complement Examples (8-bit)

+5
00000101
-5
11111011
-128
10000000

Hexadecimal: The Programmer's Friend

Hexadecimal notation is ubiquitous in programming because it provides a compact, human-readable representation of binary data. Each hexadecimal digit maps to exactly 4 binary bits, making conversions straightforward. From memory addresses to color codes, understanding hex is essential for debugging, system programming, and web development. Master the relationship between hex and binary to efficiently work with low-level code and optimize your workflow.

🎨 Color Codes

  • #FFFFFF: White (RGB: 255,255,255)
  • #FF0000: Red (RGB: 255,0,0)
  • #00FF00: Green (RGB: 0,255,0)
  • #0000FF: Blue (RGB: 0,0,255)

💾 Memory Addresses

  • 0x00000000: Null pointer
  • 0x7FFFFFFF: Max 32-bit signed
  • 0xFFFFFFFF: Max 32-bit unsigned
  • 0xDEADBEEF: Debug marker

🔧 Hex to Binary Map

  • 0-3: 0000, 0001, 0010, 0011
  • 4-7: 0100, 0101, 0110, 0111
  • 8-B: 1000, 1001, 1010, 1011
  • C-F: 1100, 1101, 1110, 1111

🔍 Hexadecimal in Practice

Debugging
Memory dumps and stack traces
Web Dev
CSS colors and Unicode
Networking
MAC and IPv6 addresses
Security
Cryptographic hashes

Programming Applications

Crack open a debugger and you'll see hexadecimal everywhere—memory addresses, register values, color codes, even network packet dumps all speak this compact language that sits halfway between human-readable and machine-native. A systems programmer reading a core dump needs to instantly translate between hex and binary to understand what the processor was doing when things went sideways, while a web developer juggling CSS colors mentally converts #FF5733 into its RGB components without thinking twice. The University of Illinois at Chicago computer science curriculum emphasizes how understanding number systems underpins everything from low-level bit manipulation to high-level data encoding schemes. Network engineers work with subnet masks in both decimal and binary, cryptographers deal with keys represented in hex, and embedded systems developers constantly shift between bases while configuring hardware registers. These skills compound across your programming career—what starts as reading hex dumps evolves into recognizing patterns, spotting errors at a glance, and designing more efficient data representations. Apply these concepts practically with our Hash Generator for cryptographic applications or our IP Subnet Calculator for network engineering tasks.

💻 Key Programming Applications

🔐
Cryptography and hashing algorithms
🌐
Network programming and protocols
⚙️
Embedded systems and IoT devices
🎮
Game development and graphics

🔒 Bitwise Operations

• Flags & Permissions: Unix file modes
• Bit Masking: Extract specific bits
• Optimization: Fast multiplication/division
• Compression: Pack multiple values

📡 Data Encoding

• Base64: Email attachments, JWT tokens
• URL Encoding: Special characters in URLs
• Unicode: Character encoding (UTF-8/16)
• Checksums: Data integrity verification

🖥️ System Programming

• Memory Management: Pointer arithmetic
• Device Drivers: Hardware registers
• Assembly: Machine code instructions
• Debugging: Stack traces, core dumps

Conversion Tips and Tricks

Mastering quick conversion techniques can significantly speed up your work with different number bases. These shortcuts and mental math tricks are especially useful during debugging sessions, code reviews, or whiteboard interviews. Practice these methods to develop intuition for number base relationships and avoid common pitfalls in conversions.

⚡ Quick Mental Conversions

• Powers of 2: Memorize 2^0 through 2^16 for instant binary conversions
• Hex Chunks: Think in 4-bit groups (nibbles) for hex↔binary
• Decimal Approximations: 2^10 ≈ 1000, useful for quick estimates
• Octal Groups: Group binary by 3 for quick octal conversions

📝 Best Practices

• Prefix Notation: Use 0x for hex, 0b for binary, 0o for octal
• Group Digits: Space or underscore for readability (0xFF_FF_FF_FF)
• Document Bases: Always specify the base in comments
• Validate Input: Check for valid digits in the source base

Memorization Aids

Memorizing key powers and patterns accelerates mental conversions and helps you spot errors quickly during debugging sessions. These fundamental values appear repeatedly in programming contexts—from memory allocation to bitwise operations. The key is finding the right balance between growth potential and risk tolerance for your specific situation. This balance shifts over time as your goals, timeline, and life circumstances evolve. Having instant recall of common conversions between binary, decimal, and hexadecimal saves valuable time during code reviews, whiteboard interviews, and system design discussions.

📊 Essential Powers

• 2^8 = 256: One byte range
• 2^16 = 65,536: Two bytes (word)
• 2^32 = 4,294,967,296: 32-bit address space
• 16^2 = 256: Two hex digits = one byte

🎯 Common Patterns

• 0xFF = 255: Maximum byte value
• 0x80 = 128: Sign bit in signed byte
• 0xDEADBEEF: Common debug marker
• 0xCAFEBABE: Java class file magic number

Advanced Topics in Number Systems

Beyond basic conversions, advanced applications of number systems include floating-point representation, arbitrary precision arithmetic, and specialized encoding schemes. These concepts are vital for scientific computing, cryptography, and data compression. Learning about the limitations and trade-offs of different representations helps in choosing the right approach for specific applications.

🔬 IEEE 754 Floating-Point

  • Single Precision: 1 sign, 8 exponent, 23 mantissa bits
  • Double Precision: 1 sign, 11 exponent, 52 mantissa bits
  • Special Values: Infinity, NaN, denormalized numbers
  • Rounding Errors: Why 0.1 + 0.2 ≠ 0.3 in binary

🔗 Arbitrary Precision

  • BigInteger: Unlimited integer precision
  • BigDecimal: Exact decimal arithmetic
  • Performance: Trade-offs vs. native types
  • Applications: Cryptography, financial calculations

🎓 Specialized Number Systems

BCD
Binary-Coded Decimal for exact decimal math
Gray Code
Minimizes bit changes between values
Excess-3
Self-complementing decimal code
One-Hot
Only one bit set at a time

Common Conversion Mistakes to Avoid

Even experienced programmers can make errors when converting between number bases. Learning about common pitfalls helps prevent bugs and ensures accurate calculations. While the mathematics might seem complex at first, breaking down the calculation into steps makes it much more manageable. Understanding what each component represents helps you see how changes in one variable affect the overall outcome. These mistakes often occur during manual conversions, when working with signed numbers, or when dealing with fractional values. Learn to recognize and avoid these errors to maintain precision in your work.

❌ Common Errors

• Leading Zero Confusion: 0755 is octal, not decimal 755
• Sign Extension Errors: Incorrect handling of negative numbers
• Overflow Issues: Not accounting for maximum representable values
• Fractional Precision Loss: Assuming exact decimal-binary conversion

✅ Prevention Strategies

• Use Explicit Prefixes: Always specify base with 0x, 0b, 0o
• Validate Ranges: Check min/max values for data types
• Test Edge Cases: Include 0, -1, max values in tests
• Use Built-in Functions: Leverage language conversion utilities

Debugging Conversion Issues

When conversion errors occur, they often manifest in subtle ways that can be difficult to trace. A systematic debugging approach involves verifying input validity, checking for overflow conditions, and confirming the correct interpretation of signed versus unsigned values. Cross-referencing results with multiple conversion tools, examining intermediate steps, and using debugger memory views in different bases can quickly pinpoint where conversions go wrong in your code. These results compound over time, making consistent application of sound principles more valuable than trying to time perfect conditions. Small, steady improvements often outperform dramatic but unsustainable changes.

🐛 Symptoms of Errors

• Unexpected negative values from unsigned data
• Colors appearing wrong in graphics
• File permissions not working as expected
• Network addresses incorrectly parsed

🔍 Debugging Tools

• Print values in multiple bases for comparison
• Use debugger memory view in hex
• Verify with online converters
• Add assertions for valid ranges

Historical Context and Evolution

The development of different number bases reflects the evolution of mathematics and computing. While decimal arose from human anatomy (10 fingers), binary emerged from the fundamental on/off states of electronic switches. The adoption of hexadecimal and octal in computing represents practical compromises between human readability and machine efficiency. Learning about this history provides context for why certain bases dominate specific domains.

Ancient civilizations used various bases: Babylonians used base-60 (still visible in our 60-minute hours), while the Mayans developed a sophisticated base-20 system. The binary system, though ancient in concept, became practical only with the advent of electronic computers. Today, as quantum computing emerges, we may see new number systems designed for quantum states, extending beyond traditional binary representation.

Key Takeaways for Number Base Conversions

Master the fundamental conversion methods: division-remainder for decimal to any base, and positional expansion for any base to decimal. Use grouping shortcuts for conversions between binary, octal, and hexadecimal. Our calculator supports all bases from 2 to 36 with precise integer conversion and configurable fractional precision.

Binary operations form the foundation of all computer arithmetic. Understanding two's complement for negative numbers and bitwise operations is essential for system programming. Practice with our Binary Calculator to build intuition for binary arithmetic and logical operations.

Hexadecimal serves as the bridge between human-readable and machine representation. From color codes to memory addresses, hex notation is ubiquitous in programming. Each hex digit maps to exactly 4 binary bits, making mental conversions straightforward with practice. Use our Hex Calculator for complex operations.

Avoid common conversion mistakes by using explicit base prefixes (0x, 0b, 0o) and understanding the limitations of floating-point representation. For programming applications, leverage built-in conversion functions and validate ranges. Regular practice with different bases builds the intuition needed for efficient debugging and system design.

Frequently Asked Questions

A number base (radix) defines how many unique digits are used to represent numbers. Base-10 (decimal) uses 0-9, base-2 (binary) uses 0-1, base-16 (hexadecimal) uses 0-9 and A-F. Each position in a number represents a power of the base. For example, in base 10, the number 345 means 3×10² + 4×10¹ + 5×10⁰.
Binary to hex conversion is straightforward: group binary digits into sets of 4 (starting from the right), then convert each group to its hex equivalent. For example, 1101 1010 in binary becomes DA in hex (1101=13=D, 1010=10=A). Reverse the process for hex to binary. This works because 16 = 2⁴, making each hex digit map to exactly 4 binary digits.
Hexadecimal is popular in programming because it's more compact than binary while maintaining a direct relationship to it. Memory addresses, color codes, and byte values are easier to read in hex. For example, the RGB color white (255,255,255) is simply #FFFFFF in hex. Additionally, each hex digit represents exactly 4 bits, making it perfect for representing bytes (2 hex digits = 8 bits = 1 byte).
Octal (base-8) is primarily used in Unix/Linux file permissions where each digit represents read (4), write (2), and execute (1) permissions. For example, chmod 755 means owner has full permissions (7=4+2+1), while group and others have read and execute (5=4+1). Octal was also historically used in older computing systems because it groups binary digits into sets of 3.
To convert decimal fractions to another base, multiply the fractional part by the target base repeatedly, taking the integer part at each step. For example, to convert 0.625 to binary: 0.625×2=1.25 (take 1), 0.25×2=0.5 (take 0), 0.5×2=1.0 (take 1), giving 0.101 in binary. Note that some fractions may result in repeating patterns in certain bases.
Base-64 encoding uses 64 characters (A-Z, a-z, 0-9, +, /) to represent binary data as ASCII text. It's vital for transmitting binary data over text-only protocols like email or JSON. Every 3 bytes of binary data become 4 base-64 characters, increasing size by about 33%. It's widely used in web development for embedding images in CSS/HTML and in authentication tokens.
Negative numbers in different bases use the same minus sign notation in standard representation. However, computers use two's complement for binary negative numbers. To find two's complement: invert all bits (one's complement) then add 1. For example, -5 in 8-bit binary is 11111011. This system allows computers to perform subtraction using addition circuits and provides a unique representation for zero.
maximum values depend on whether numbers are signed or unsigned. For unsigned: 8 bits = 255 (0xFF), 16 bits = 65,535 (0xFFFF), 32 bits = 4,294,967,295 (0xFFFFFFFF), 64 bits = 18,446,744,073,709,551,615. For signed numbers using two's complement, the range is approximately half, from -(2^(n-1)) to (2^(n-1))-1, where n is the number of bits.
Base-36 uses all 10 digits (0-9) and all 26 letters (A-Z), exhausting the standard alphanumeric characters. While higher bases are theoretically possible using additional symbols, base-36 provides the maximum compression using only commonly available characters. It's often used for generating short, human-readable identifiers from large numbers, such as YouTube video IDs or shortened URLs.
Binary floating-point follows the IEEE 754 standard, using scientific notation in base-2. A 32-bit float has 1 sign bit, 8 exponent bits, and 23 mantissa bits. The number is calculated as: (-1)^sign × mantissa × 2^exponent. This representation allows for a huge range but can't exactly represent all decimal fractions, leading to rounding errors like 0.1 + 0.2 ≠ 0.3 in many programming languages.

Related Calculators

Updated October 20, 2025
Published: July 19, 2025