Number Bases Guide: Binary, Octal, Decimal & Hex Tables

Computers count in binary, programmers read hex, and humans think decimal - same numbers, different costumes. 255 = 11111111₂ = 377₈ = 0xFF. Learn the place-value trick once with the complete 0-128 table below, and convert anything by hand or in code.

How to use the Number Converter

1. Enter digits (0b/0o/0x prefixes OK).
2. Pick the input base.
3. Read all bases plus scientific notation.

Formula

Key concepts, explained

Place value is everything

0x2F = 2×16 + 15 = 47. Each position left multiplies by the base - the same rule as decimal, generalized. Reading hex is just fast base-16 place value; practice with the table until 0x40 = 64 feels obvious.

Why programmers love hex

One hex digit = exactly 4 bits: bytes split into two clean digits (0xFF = 11111111). Colors (#FF0000), memory addresses, bitmasks - hex compresses binary 4:1 with zero ambiguity. Octal survives in Unix permissions (chmod 755) for its 3-bit fit.

Bases share one value

255, 0xFF, 377 octal and eight binary ones name the same number - costumes, not values. Octal groups binary in threes, hex in fours; decimal groups nothing and leans on memorized tables.

Convert through place value in either direction; the arithmetic never changes, only the digits available.

Two’s complement flips the top bit

Eight bits span −128..127: positives start with 0, negatives set the top bit. Negate by inverting all bits and adding one: 5 (00000101) becomes 11111011 (−5).

Sixteen bits stretch to −32,768..32,767; 32-bit signed tops at 2,147,483,647. Unsigned reclaims the top bit for double positive range.

Endianness orders bytes

Big-endian stores 0x1234 as bytes 12 34; little-endian flips to 34 12. x86 PCs run little, network protocols speak big (“network order”).

Hex dumps print file order; debuggers annotate host order - read the caption before the bytes.

Floats approximate, integers keep

Decimal 0.1 has no exact binary form, so 0.1 + 0.2 prints 0.30000000000000004. Money, scores and counters belong in integers (cents, not dollars).

Epsilon comparisons replace equality for floats; decimal types exist where law demands exactness.

Unicode is hex everywhere

Code points print hex by convention: U+1F600 grins, U+0041 is plain A. UTF-8 encodes them in 1-4 bytes; ASCII 0-127 rides unchanged inside.

Emoji modifiers and flags compose from multiple code points - one glyph, several numbers.

Colors are hex triples

#RRGGBB packs red, green, blue into six digits: #FF0000 screams red, #1DA1F2 tweets blue (RGB 29, 161, 242). Shorthand #F00 doubles each digit.

Alpha appends a fourth pair (#RRGGBBAA); print swaps to CMYK percentages instead.

Subnet masks count ones

A /24 mask holds 24 one-bits: 255.255.255.0, leaving 8 host bits = 256 addresses, 254 usable after network and broadcast. A /16 spans 65,536; a /8 holds 16.7 million.

CIDR slash counts the ones; dotted masks spell them out - same bits, two costumes.

Powers of two ladder the field

2¹⁰ ≈ 10³ (kilo), 2²⁰ ≈ 10⁶ (mega), 2³⁰ ≈ 10⁹ (giga): close enough to estimate storage, far enough to matter in court. Programmers round in powers, marketers in thousands.

RAM sticks follow powers strictly (8/16/32 GB); SSDs cheat decimal and rely on overprovisioning.

Octal survives in permissions

Three rwx bits fit one octal digit: 755 means rwxr-xr-x, 644 rw-r--r-- for files, 600 locked private. Umask subtracts from defaults.

Setuid/setgid/sticky prepend a fourth digit (4755, 2755, 1755) - the leading digit with the real power.

BCD lingers in hardware

Binary-coded decimal packs two digits per byte for calculators, clocks and seven-segment displays - wasteful but decimal-exact. Financial chips still speak it.

Humans read BCD dumps directly; binary needs the calculator.

Gray code counts singly

Adjacent Gray values differ in exactly one bit, so rotary encoders never glitch mid-transition. Position sensors and Karnaugh maps both exploit the property.

Convert binary↔Gray with shifts and XORs; the mapping is its own inverse in spirit.

Base64 is packaging, not encryption

Six bits per character turn 3 bytes into 4 text chars (+33 % size); padding = signs mark short tails. Email attachments and data URLs ride on it.

Anyone decodes it instantly - secrets need real ciphers underneath.

Hex addresses locate everything

IPv6 writes 128 bits as eight hex groups; MACs print 48 bits as twelve hex digits. Colons and dashes just chunk the same numbers.

SHA-256 digests print 64 hex chars (256 bits); UUIDs trim to 32 plus dashes. Length reveals the algorithm.

Scientific notation compresses zeros

Avogadro counts 6.02×10²³; electron charge reads 1.6×10⁻¹⁹ C. E-notation (6.02e23) types the same in code.

Engineers pick prefixes (k/M/G) where scientists keep exponents - same zeros, friendlier words.

Hex dumps read memory rows

Classic dumps print 16 bytes per row with hex offsets down the side - xxd and hexdump share the layout. ASCII gutters on the right expose embedded strings.

Corrupt files reveal themselves here: zeros where headers belong, text where pixels should be.

Bit shifts multiply fast

Left shift doubles per bit: 13 << 2 = 52 (×4). Right shift halves toward zero for unsigned values. Compilers silently swap multiplies for shifts.

Beyond width lies zero (or sign extension for signed right shifts) - shifting 32-bit ints by 32 is undefined mischief.

Masks isolate bit fields

AND keeps bits: 0xFF & 0x0F = 0x0F. OR sets them: 0xF0 | 0x0F = 0xFF. Flag enums compose permissions and states from single bits.

Clear with AND-NOT, toggle with XOR - four operations run all bit logic.

Bytes address memory

Thirty-two address bits reach 4 GB (2³² bytes) - the famous limit that forced 64-bit adoption. Sixty-four bits theoretically address 16 exbibytes, more storage than Earth will build.

Pointers print hex because addresses are just big numbers wearing costumes.

Hex colors fade with alpha

Appending alpha pairs fades colors: FF opaque, 00 transparent, 80 near half (128/255). Compositors blend by the same multiply every frame.

Design tools toggle hex/rgba views of identical values - pick whichever reads faster.

Checksums catch typos

Luhn checksums guard card numbers; ISBN-13 weights digits mod 10. Single transpositions trip the math while looking right.

Cryptographic hashes extend the idea: any change avalanches the digest.

Binary fractions terminate rarely

Halves, quarters and eighths end cleanly; tenths repeat forever like thirds in decimal. Money in binary floats inherits the wobble.

Fractions with denominator 2ⁿ only terminate - everything else approximates.

Bitwise ops fit one line

AND, OR, XOR, NOT, shifts: 0b1100 & 0b1010 = 0b1000. Flags pack eight booleans per byte; masks read them back.

Embedded registers expose hardware exactly this way - datasheets draw the bit maps.

ASCII fits seven bits

Codes 0-127 cover A (65/0x41), a (97/0x61) and 0 (48/0x30); digits run sequential so parsing subtracts 48. UTF-8 preserves every byte for compatibility.

Control codes 0-31 predate screens - bells, tabs and escapes from teletype days.

Ports number services

Sixteen bits address 0-65535: 80 HTTP, 443 HTTPS, 22 SSH by convention. Firewalls filter numbers, not names.

Ephemeral ports range high (32768+) for outbound replies - stateful tables track the dance.

Off-by-one haunts bases

Zero through 255 counts 256 values, not 255. Fencepost errors hide in every range: test 0, 1, 127, 128 and 255 boundaries explicitly.

Subnet, array and bitmask math all share the same off-by-one trap.

Null terminators hide bytes

C strings end with a zero byte, so “hello” occupies six, not five. Buffer overflows famously overwrote that terminator for decades.

Length-prefixed strings (Pascal, Go slices) skip the sentinel and store size alongside.

Security counts in bits

AES keys run 128/192/256 bits; each bit doubles brute-force cost. Hash outputs print hex at four bits per character.

Quantum threats halve effective symmetric strength - 256-bit keys hedge 128-bit futures.

Subnet masks in binary that route packets

IPv4 masks like 255.255.255.0 translate to /24 prefix lengths where 24 leading ones define network versus host bits precisely. AND operations between addresses and masks yield network IDs routers forward upon. Our converter turns dotted decimals into binary instantly for study.

CIDR notation replaced classful A/B/C addressing with flexible prefixes modern networks need. Practice with 192.168.1.0/24 home nets before corporate supernets. Mask addresses manually once.

chmod bits: rwx as octal fluently

Permission triples map r=4, w=2, x=1 summing per owner, group and others: 755 means rwxr-xr-x for web files typically. Recursive chmod risks system files where sudo plus wildcards destroy installations famously. Our converter turns octal to binary for teaching instantly.

Symbolic modes (u+x, g-w) adjust surgically without recalculating octal. Default umasks subtract from 777 (dirs) and 666 (files) automatically. Learn octal fluently for servers.

Hex colors picked by numbers confidently

Web colors encode red, green and blue in hex pairs where #FF0000 screams red and #808080 grays neutrally. Alpha channels append pairs (RRGGBBAA) for transparency levels. Our converter turns decimals into hex for custom palettes instantly.

Contrast ratios decide accessibility where pretty palettes fail WCAG thresholds. Eyedroppers sample screens into codes directly. Pick numbers confidently.

Two complement negatives without fear

Signed integers invert bits plus one to negate: 5 (00000101) becomes -5 (11111011) in 8-bit worlds. Ranges span -128 to 127 asymmetrically with one extra negative famously. Overflow wraps silently where languages vary in checking.

Our converter demonstrates flips instantly across bit widths. Debuggers display hex where decimal misleads signedness. Flip bits, add one.

ASCII codes behind every keystroke

Capital A lives at 65 (0x41) with lowercase 32 higher at 97; digits start 48 where parsing subtracts 48 per char. Control codes below 32 drive terminals historically (newline 10, escape 27). Our converter turns characters into codes for debugging instantly.

UTF-8 extends ASCII compatibly where multibyte sequences encode world scripts. Hex dumps reveal file structures plainly. Subtract 48 for digits.

Floating point 0.1 + 0.2 mystery solved

Binary fractions cannot represent 0.1 exactly, summing to 0.30000000000000004 famously; decimal types or integer cents fix money math reliably. Epsilon comparisons replace equality checks in floating code universally. Our decimal companions detail money handling; converters show binary reasons.

Print full precision when debugging to expose representation gaps. Never accumulate currency in floats. Compare with epsilon.

Endianness: byte order that breaks files

Little-endian x86 stores least-significant bytes first where network protocols transmit big-endian first; headers declare orders explicitly. Hex editors reveal BOM markers (FF FE versus FE FF) identifying text encodings instantly. Our converter reorders bytes for manual inspection directly.

Struct packing plus alignment pad binaries where parsers must match exactly. Test cross-platform file code on both orders. Mind byte order.

Checksums and CRCs that catch corruption

Modbus CRCs plus zip checksums detect transmission errors through polynomial remainders that single-bit flips alter reliably. Our converter turns hex dumps into manual recalculations for learning. Cryptographic hashes extend detection into security where CRCs merely detect accidents.

Verify downloads against published hashes routinely before installing. Git identifies content by SHA-1 famously. Check hashes habitually.

Gray code where one bit changes

Rotary encoders use Gray sequences where adjacent positions differ singly, preventing glitchy intermediate reads mechanical contacts produce. Karnaugh maps order cells in Gray for minimization adjacency visually. Our converter translates binary-Gray both directions for study.

Absolute encoders beat incremental where power-loss position matters. Robotics relies on Gray silently. Change one bit adjacently.

BCD: decimal digits in nibbles historically

Seven-segment drivers plus financial systems encode each decimal digit in 4-bit nibbles where 0x12 means twelve, not eighteen. RTC chips still expose BCD registers hobbyists decode manually. Our converter translates packed BCD for datasheet work directly.

x87 FBLD instructions loaded BCD rarely used today. Decimal floating types supersede BCD generally. Decode nibbles decimally.

MIDI note numbers to frequencies musically

Middle C (C4) maps to MIDI 60 with A4 440 Hz at 69; formulas convert numbers to hertz exponentially across 128 notes. DAWs display both where producers think notes and synths think frequencies. Our converter bridges musical and physical domains instantly.

Pitch bend plus tuning offsets add cents deviations around MIDI integers. Drum maps assign percussion to fixed notes conventionally. Think notes, synth frequencies.

Unicode planes beyond emoji basics

Code points U+0000 to U+10FFFF organize planes where Basic Multilingual covers common scripts and astral planes hold emoji plus historic scripts. UTF-16 surrogate pairs encode astral characters where UTF-8 uses variable bytes elegantly. Our converter turns code points into encodings for debugging.

Normalization forms (NFC/NFD) compare strings canonically where visually identical text differs binarily. Emoji ZWJ sequences combine code points into families. Normalize before comparing.

Barcodes: UPC check digits mod 10

Twelve-digit UPCs validate through weighted sums mod 10 catching single-digit errors reliably at scanners. Our converter recalculates check digits for label printing directly. ISBN-13 extends identical logic to books with 978 prefixes.

QR codes add Reed-Solomon error correction surviving damage substantially. Verify check digits before mass printing. Validate digits early.

Credit-card Luhn checks in one pass

Luhn doubles alternate digits summing digits over 9, validating numbers where totals mod 10 equal zero; it catches typos, never fraud. Test cards (4111...) pass Luhn by design for development. Our converter validates numbers for form UX instantly.

Issuer prefixes plus lengths identify networks before authorization. Never log full PANs where tokens suffice. Validate locally, authorize remotely.

Unix permissions beyond 755 practically

Setuid (4755) runs as owners where sudo manages better mostly; setgid (2755) inherits groups for shared directories usefully. Sticky bits (1777) protect /tmp deletions appropriately. Our converter decodes special bits alongside basics for audits.

World-writable files invite exploits scanners flag automatically. Principle of least privilege trims bits routinely. Audit special bits quarterly.

Coordinated Universal Time in epoch seconds

Epoch converters turn 1700000000 into 2023 dates for log forensics instantly where ISO strings sort humanly. Leap seconds complicate exact counts our time companions detail. Our converter bridges human and machine time directly.

APIs accept both formats where documentation specifies exactly. Store integers, display locals. Convert epochs carefully.

IP octets dotted decimally demystified

Each octet holds 0 to 255 (8 bits) where 192.168.1.1 splits networks from hosts via masks our subnet section details. Private ranges (10/8, 172.16/12, 192.168/16) never route publicly. Our converter turns dotted quads into 32-bit integers for firewall rules directly.

IPv6 hex groups expand addressing enormously where compression rules (::) confuse beginners. Ping plus traceroute diagnose with numbers, not names. Learn octets fundamentally.

MAC addresses: OUI vendor prefixes

First three bytes identify manufacturers (Apple, Intel) through IEEE registries where Wireshark resolves names automatically. Spoofing changes software addresses where burned-in ROM stays authoritative physically. Our converter turns hex to binary for filter masks directly.

Randomized probe MACs preserve phone privacy partially. Allow-lists fail against spoofing trivially. Identify vendors, authenticate separately.

HTML entities: ampersand codes that render

Entities like &amp; (&), &lt; (<) and &#169; (©) escape markup where raw characters break parsing. Named references cover common symbols while numeric forms reach all Unicode. Our converter turns code points into entities for templates directly.

UTF-8 meta charset declarations prevent mojibake more fundamentally than entities. Escape user content server-side universally. Encode markup safely.

URL percent-encoding that travels safely

Spaces become %20, slashes %2F and non-ASCII UTF-8 bytes percent-triples where raw characters break routing. Our converter encodes components for query strings directly. Decode logs before reading attack payloads.

Path versus query encoding differs subtly (+ means space in queries only). Encode components, not whole URLs.

Base64: binary through text channels

Email attachments plus data URIs encode bytes in 64 ASCII characters at 33 percent overhead where raw binary corrupts text protocols. Padding equals signs align final quanta. Our converter encodes small payloads for debugging directly.

URLs prefer base64url variants swapping +/ for -_ without padding. JWTs chain three base64url segments with signatures. Encode attachments, never passwords.

JWT segments decoded without libraries

Headers, payloads and signatures join with dots where base64url decoding reveals claims instantly for debugging. Expiry (exp) plus issuer (iss) fields decide acceptance before signature math. Our converter decodes segments for inspection directly.

Verify signatures server-side always; client decoding proves nothing securely. Rotate secrets plus short expiries routinely. Inspect payloads, verify signatures.

UUID versions: random versus time-ordered

Version 4 randomizes 122 bits uniquely enough for distributed keys; version 7 adds timestamps sorting chronologically in databases efficiently. Our converter turns hex strings into byte layouts for debugging directly.

Sequential UUIDs fragment indexes less than random ones substantially. Never encode secrets in UUIDs guessable partially. Version 7 for databases generally.

Resistor color codes read instantly

Bands map black-0 through white-9 with multipliers and tolerances where 4-band yellow-violet-red-gold means 4.7k 5 percent directly. Our converter turns colors into values for verification instantly. Multimeters confirm in-circuit readings mislead.

SMD codes print numbers (472 means 4.7k) where tiny packages skip markings entirely. E-series standardizes values manufactured actually. Read bands from non-tolerance end.

Capacitor 104 means 100 nF decoded

Ceramic codes read picofarads with multipliers: 104 equals 10 followed by 4 zeros (100,000 pF = 100 nF). Letters denote tolerances and dielectrics (X7R, NP0) critically. Our converter decodes markings for substitutions directly.

Electrolytics print values plainly where polarity matters absolutely. Voltage ratings must meet or exceed circuits. Decode ceramics numerically.

Crystal frequencies that clock boards

Microcontrollers clock 8, 12 and 16 MHz crystals where UART baud divides evenly-ish; real-time clocks use 32.768 kHz (2^15) dividing to 1 Hz precisely. Load capacitors must match crystal specs for startup reliability.

Overclocking margins depend on silicon plus cooling, never crystals alone. Oscilloscopes verify actual clocks under load. Match load caps exactly.

DIP switches addressed in binary directly

Eight-position DIP banks set addresses where ON equals 1 weighted by position; our converter turns switch patterns into decimals for manuals instantly. Termination plus baud switches configure industrial gear without displays.

Photograph positions before changing anything field-serviceable. Plastic tools flip recessed switches without damage. Read switches as binary.

Finger binary counts to 1,023 on two hands

Assign each finger powers of two (1, 2, 4 ... 512) where raised means one; both hands span 0 to 1,023 impressively at parties. Our converter verifies finger patterns for learners instantly.

Practice small sums visibly before attempting full range. Nerd credibility compounds with fluency. Raise powers, sum fingers.

Braille 6-dot binary that reads fingers

Six dots encode letters plus numbers through raised patterns where Number Sign prefixes digit meanings. Our converter turns text into Braille patterns for craft projects directly. Learn Grade 1 basics before contractions.

Label makers emboss household items accessibly. Respect Braille literacy through proper formatting. Feel dots systematically.

Step-by-step walkthrough

Walkthrough: 0b110101 by hand

1. Positions (right to left): 32,16,8,4,2,1.
2. Bits set: 32 + 16 + 4 + 1 = 53.
3. Hex: group 0011|0101 → 0x35. Check above.

Walkthrough: 0x2F to decimal?

1. Split: 2 × 16 plus 15.
2. Compute: 32 + 15.
3. Result: 47.

Walkthrough: 255 to binary?

1. Subtract powers: 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1.
2. All eight bits set.
3. Write: 11111111₂ = 0xFF = 377₈.

Walkthrough: chmod 754 decoded?

1. Split digits: 7, 5, 4.
2. Map: 7 = rwx, 5 = r-x, 4 = r--.
3. Read: rwxr-xr--.

Walkthrough: /24 usable hosts?

1. Host bits: 32 − 24 = 8.
2. Total: 2^8 = 256.
3. Minus network and broadcast: 254 usable.

Walkthrough: #1DA1F2 to RGB?

1. Split pairs: 1D, A1, F2.
2. Convert: 0x1D = 29, 0xA1 = 161, 0xF2 = 242.
3. Result: RGB(29, 161, 242).

Walkthrough: 0xFF AND 0x0F?

1. Nibbles: F&0 = 0, F&F = F.
2. Combine: 0x0F.
3. Decimal: 15 - low nibble isolated.

Worked examples

Complete reference tables

Decimal, binary, octal and hex at a glance

Programmers memorize powers of two; everything else is one calculator run away.

Decimal, binary, octal and hex at a glance

Programmers memorize powers of two; everything else is one calculator run away.

Decimal, binary, octal and hex at a glance

Programmers memorize powers of two; everything else is one calculator run away.

Powers of two

Common mistakes to avoid

• Reading 0x10 as ten (it is sixteen).
• Forgetting leading zeros change bit positions.
• Decimal-thinking in hex (0x19 + 1 = 0x1A, not 0x20).
• Signed vs unsigned interpretation of top bits.
• Writing 0x19 as decimal 19 in code (prefixes decide).
• Counting /24 as 255 hosts (254 after network and broadcast).
• Case-mixing hex where linters demand one style.
• Assuming 1 KB on disk equals 1,000 bytes (clusters round up).
• XOR masks without aligning widths first.

Pro tips

• Learn 0-15 in all bases cold - everything composes.
• Chunk binary in fours from the right.
• Programmers: 0x prefix in code, # in colors.
• Powers of two to 2^16 cover most debugging.
• Windows calculator programmer mode flips bases live.
• Python: 0b/0o/0x literals plus bin()/hex() builtins.
• JavaScript parseInt always passes the radix explicitly.
• CSS #RGB shorthand doubles each digit.
• Subnet blocks: 256 minus mask octet (a /25 splits .0-.127/.128+).

Where you will use this

Programming

Colors, masks, addresses, permissions.

Networking

IPs (decimal), MACs (hex), subnet masks (binary).

Exams

CS fundamentals love base drills.

Embedded

Registers and bitfields speak hex natively.

Cryptography

Digests print hex: SHA-256 fills 64 chars.

Databases

UUIDs store 128-bit hex with dashes.

Color pickers

Design tools trade #RRGGBB with sliders.

Glossary

Frequently asked questions

Popular searches

binary to decimal · hex to decimal · decimal to binary · number base converter · 0xFF decimal · binary converter · binary to hex · chmod explained · subnet /24 AND network CIDR home corporate · chmod 755 rwx umask symbolic servers · hex colors RRGGBB alpha contrast WCAG · two complement invert plus one ranges debuggers · ASCII 65 97 48 UTF-8 dumps parsing · floating 0.1 epsilon integer cents money · endianness BOM headers parsers orders · checksums CRC hashes downloads git verify · Gray encoders Karnaugh robotics absolute · BCD nibbles RTC datasheets decimal · MIDI 60 69 hertz DAWs bend drums · Unicode planes UTF-8 NFC emoji ZWJ · UPC mod 10 ISBN QR Reed-Solomon print · Luhn PAN tokens authorize networks · setuid setgid sticky least privilege audits · epoch 1700000000 ISO APIs integers locals · IP octets private masks ping traceroute · MAC OUI spoofing randomized privacy allow-lists · HTML entities ampersand numeric UTF-8 escape · URL percent components queries logs payloads · Base64 overhead padding JWT passwords · JWT exp iss verify rotate expiries · UUID v4 v7 indexes secrets databases · resistor bands SMD E-series meters markings · capacitor 104 X7R electrolytics polarity ratings · crystal 8 12 16 32.768 load overclocking scopes · DIP binary termination baud photograph tools · finger binary 1023 powers parties sums · Braille Number Sign Grade 1 labels formatting · finger sums party recitation fluency · Braille embossing literacy formatting readers genuinely always

Related tools: Binary Translator · Roman Numerals Converter · ASCII Table