The hexadecimal value 0x09 equals 9 in decimal. Below you'll find the step-by-step conversion, binary equivalent, ASCII meaning, programming examples, and more.
0x09 is a hexadecimal (base-16) number. The 0x prefix is a standard notation used in programming to identify hexadecimal values. The actual hex digits are 09.
In the hexadecimal number system, each digit represents a power of 16. The available digits are 0–9 and A–F, where A = 10, B = 11, C = 12, D = 13, E = 14, and F = 15.
Since both digits in 09 are within the 0–9 range, this is one of the simpler hex values to convert — it looks the same as a regular decimal number, but the calculation method is different because the base is 16, not 10.
Converting hexadecimal to decimal uses a positional notation formula. Here's exactly how to convert 0x09 to decimal:
Where d₁ is the leftmost digit and d₀ is the rightmost digit.
The hex number 09 has two digits:
Therefore, 0x09 in hexadecimal = 9 in decimal.
0x09 equals 9 because the left digit is 0 and the right digit is 9, making the calculation 0 × 16 + 9 × 1 = 9. In this specific case, since the left digit is 0, the 16¹ position contributes nothing. The entire value comes from the rightmost digit (9), which sits in the 16⁰ (ones) position. This makes 0x09 one of the hex values where the decimal result matches the hex digits — but only because the value is below 10. For hex values 0A (10) and above, the decimal result starts to diverge.
Here's how 0x09 looks in every common number base:
| Number System | Base | Value |
|---|---|---|
| Hexadecimal | Base 16 | 09 |
| Decimal | Base 10 | 9 |
| Octal | Base 8 | 11 |
| Binary | Base 2 | 00001001 |
Each hex digit maps to exactly 4 binary bits:
This binary value 00001001 represents the decimal number 9: the 2³ bit (8) and the 2⁰ bit (1) are set, giving 8 + 1 = 9.
To convert 0x09 to octal, first convert to decimal (9), then divide by 8:
In the ASCII character table, 0x09 (decimal 9) represents the Horizontal Tab (HT) character. This is a non-printable control character — it doesn't display as a visible symbol on screen.
The horizontal tab character advances the cursor to the next tab stop position. In most systems, tab stops are set at every 8 characters, though many editors use 4 spaces. It's one of the most commonly used control characters.
In almost every programming language, the tab character is represented by the escape sequence \t:
| Hex | Decimal | ASCII | Description |
|---|---|---|---|
| 0x07 | 7 | BEL | Bell (alert beep) |
| 0x08 | 8 | BS | Backspace |
| 0x09 | 9 | HT | Horizontal Tab ← this one |
| 0x0A | 10 | LF | Line Feed (new line) |
| 0x0B | 11 | VT | Vertical Tab |
| 0x0D | 13 | CR | Carriage Return |
Together, 0x09 (tab), 0x0A (line feed), and 0x0D (carriage return) are the three most commonly encountered whitespace control characters in programming and text processing.
Here's how you handle the hex value 0x09 in popular programming languages:
0x09 is used in the real world as a horizontal tab character for formatting text files, separating data in CSVs, and aligning terminal outputs. The hex value 0x09 appears in many contexts across computing and programming:
Tab-separated values (TSV) files use 0x09 as the column delimiter between data fields.
The tab character aligns output in columns when printing formatted data to the terminal.
When pasting tabular data, 0x09 tells the spreadsheet to place data in the next column.
When inspecting files in a hex editor, you'll frequently see 09 bytes representing tab characters.
In HTML, 0x09 is treated as whitespace. It can also be written as the entity 	 or 	.
Many network protocols and data formats use 0x09 as a field separator or whitespace token.
Here's a handy reference showing hex values around 0x09 and their decimal, binary, octal, and ASCII equivalents:
| Hex | Decimal | Binary | Octal | ASCII |
|---|---|---|---|---|
| 0x00 | 0 | 00000000 | 0 | NUL |
| 0x01 | 1 | 00000001 | 1 | SOH |
| 0x02 | 2 | 00000010 | 2 | STX |
| 0x03 | 3 | 00000011 | 3 | ETX |
| 0x04 | 4 | 00000100 | 4 | EOT |
| 0x05 | 5 | 00000101 | 5 | ENQ |
| 0x06 | 6 | 00000110 | 6 | ACK |
| 0x07 | 7 | 00000111 | 7 | BEL |
| 0x08 | 8 | 00001000 | 10 | BS |
| 0x09 | 9 | 00001001 | 11 | HT ◄ |
| 0x0A | 10 | 00001010 | 12 | LF |
| 0x0B | 11 | 00001011 | 13 | VT |
| 0x0C | 12 | 00001100 | 14 | FF |
| 0x0D | 13 | 00001101 | 15 | CR |
| 0x0E | 14 | 00001110 | 16 | SO |
| 0x0F | 15 | 00001111 | 17 | SI |
| 0x10 | 16 | 00010000 | 20 | DLE |
The 0x prefix is a widely recognized convention in programming that marks a number as hexadecimal. It originated in the C programming language and is now used across virtually all modern languages.
The 0x prefix is used because the 0 signals a numeric literal and the x stands for hexadecimal. The prefix uses 0 (which signals a non-decimal literal in many languages) followed by x (for hexadecimal). This prevents ambiguity — without it, the number 09 might be interpreted as decimal 9 or even cause an error in languages that treat leading-zero numbers as octal.
| Notation | Example | Used In |
|---|---|---|
| 0x prefix | 0x09 | C, C++, Java, JavaScript, Python, C# |
| # prefix | #09 | HTML/CSS color codes |
| h suffix | 09h | Assembly language (Intel syntax) |
| $ prefix | $09 | Pascal, Motorola assembly |
| &H prefix | &H09 | Visual Basic |
| 16# prefix | 16#09# | Ada, VHDL |
For the value 0x09, the signed and unsigned interpretations are identical because the most significant bit is 0.
In 2's complement representation, any byte where the most significant bit (MSB) is 0 is positive, and its signed value equals its unsigned value. Since 0x09 = 00001001, the MSB is 0, so the signed value is also 9.
| Bit Position | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
|---|---|---|---|---|---|---|---|---|
| Binary Value | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 |
| Power of 2 | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
| Contribution | 0 | 0 | 0 | 0 | 8 | 0 | 0 | 1 |
Total: 8 + 1 = 9
The most common mistake is confusing the number base — treating 0x09 as octal instead of hexadecimal. Here are the errors developers frequently encounter:
In JavaScript (pre-ES5) and some C compilers, a leading zero (like 09) is interpreted as octal notation. Since 9 is not a valid octal digit (octal only uses 0–7), this causes a syntax error or unexpected behavior. Always use the 0x prefix to explicitly indicate hexadecimal.
When using parseInt() in JavaScript without specifying the radix, the function may guess the wrong base. Always pass 16 as the second argument for hex conversion.
0x09, 0X09, and 0x09 are all equivalent in every major programming language. Hex digits A–F are case-insensitive, so 0xFF and 0xff are identical. However, some style guides prefer lowercase for consistency.
Some functions expect raw hex digits without the 0x prefix, while others accept it. Know which is which for your language:
Hexadecimal was first adopted in computing in the 1960s as a human-friendly shorthand for binary data. Here is a brief timeline of how hex notation evolved into the universal standard used today:
Base 16 is used because 16 is a power of 2 (2⁴ = 16), which means each hex digit maps perfectly to exactly 4 binary bits. Computers operate in binary (base 2), but binary strings are long and error-prone for humans to read. Hexadecimal solves this because of this 1:4 mapping, making conversion between hex and binary instantaneous — no math required, just a lookup table.
In the 1950s and 1960s, octal (base 8) was the dominant shorthand because early computers used 12-bit, 24-bit, and 36-bit word sizes — all divisible by 3 (the number of bits per octal digit). When IBM introduced the System/360 mainframe in 1964 with 8-bit bytes and 32-bit words, hexadecimal became the natural choice because these are divisible by 4 (the number of bits per hex digit).
The 0x prefix was introduced in the C programming language (circa 1972) by Dennis Ritchie and Brian Kernighan at Bell Labs. The design rationale: the leading 0 signals a non-decimal literal to the compiler's lexer, and the x stands for hexadecimal. This convention was inherited by C++, Java, JavaScript, Python, C#, Go, Rust, Swift, and virtually every modern language.
Today, hexadecimal is ubiquitous in computing: memory addresses, color codes (#FF0000), MAC addresses (00:1A:2B:3C:4D:5E), Unicode code points (U+0041), byte-level debugging, cryptographic hashes (SHA-256), and low-level hardware programming all rely on hex notation. The value 0x09 specifically appears constantly as the ASCII tab character in text processing, data formats, and protocol specifications.
0x09 is stored as a single byte (8 bits) with the binary pattern 00001001 in computer memory. Here is how it is represented at the hardware level and in different data contexts:
In memory, 0x09 occupies exactly one byte. A byte is the fundamental addressable unit of memory in modern computers, consisting of 8 bits. The value 9 requires only 4 bits (1001), but it is stored in a full byte with the upper 4 bits set to zero: 00001001.
For a single-byte value like 0x09, byte order (endianness) is irrelevant — it is the same in both big-endian and little-endian systems. Endianness only affects multi-byte values (2 bytes or more). This makes single-byte hex values like 0x09 portable across all architectures without byte-swapping concerns.
| Data Type | Size | Hex Representation | Binary |
|---|---|---|---|
| uint8 / byte | 1 byte | 09 | 00001001 |
| uint16 / short | 2 bytes | 00 09 | 00000000 00001001 |
| uint32 / int | 4 bytes | 00 00 00 09 | 00000000 ... 00001001 |
| uint64 / long | 8 bytes | 00 00 00 00 00 00 00 09 | 00000000 ... 00001001 |
When you view a file in a hex editor, the byte 09 appears frequently in text files wherever a tab character is used for indentation or data separation. In a typical hex dump, it looks like this:
In this TSV file hex dump, the 09 bytes are the tab delimiters separating the data fields "Name", "Age", and "City".
Yes, 0x09 represents the same Horizontal Tab character in both ASCII and Unicode — Unicode is a superset of ASCII for the first 128 code points (U+0000 to U+007F). The Unicode code point for the tab character is U+0009, which corresponds directly to ASCII 0x09.
| Property | Value |
|---|---|
| Code Point | U+0009 |
| Name | CHARACTER TABULATION |
| Block | Basic Latin (ASCII) |
| Category | Control (Cc) |
| Bidirectional Class | Segment Separator (S) |
| UTF-8 Encoding | 09 |
| UTF-16 Encoding | 0009 |
| UTF-32 Encoding | 00000009 |
In UTF-8 encoding, any Unicode code point from U+0000 to U+007F is encoded as a single byte, identical to its ASCII value. Therefore, U+0009 (tab) is encoded as the single byte 0x09 in UTF-8. This means UTF-8 encoded text files have the exact same byte value for tab as ASCII files — there is no encoding difference for this character.
In HTML documents, you can represent the tab character using these entity notations:
However, in rendered HTML, tab characters are treated as whitespace and collapsed to a single space by default. To preserve tab formatting, use the CSS property white-space: pre or the <pre> element.
\t in code.0x09 in decimal is 9. The 0x prefix indicates hexadecimal notation, and the value 09 in base 16 equals 0 × 16 + 9 × 1 = 9 in base 10.
0x09 in binary is 00001001. Each hex digit converts to 4 bits: 0 → 0000, 9 → 1001.
0x09 is the Horizontal Tab (HT) character in ASCII. It's a non-printable control character represented in code as \t. It moves the cursor to the next tab stop, typically every 4 or 8 characters.
The 0x prefix is a notation convention from the C programming language that marks a number as hexadecimal (base 16). It's now universally used in C, C++, Java, JavaScript, Python, and many other languages. So 0x09 means "the hex number 09."
Yes, 0x09 equals decimal 9. For hex values 0x00 through 0x09, the decimal equivalent matches the hex digits. Starting from 0x0A (decimal 10), hex and decimal values begin to diverge because hex uses letters A–F for values 10–15.
0x09 in octal is 11. Convert to decimal first (9), then to octal: 9 ÷ 8 = 1 remainder 1, so octal = 11.
In Python, use int('09', 16) which returns 9. You can also use int('0x09', 16) or simply write the hex literal 0x09 directly in your code — Python automatically treats it as the integer 9.
In JavaScript, use parseInt('09', 16) which returns 9. Or use the hex literal 0x09 directly. You can also use Number('0x09') to get 9.
No. 0x09 is a non-printable control character (Horizontal Tab). ASCII printable characters start at 0x20 (space, decimal 32) and go through 0x7E (tilde ~, decimal 126). All values below 0x20 are control characters.
In terms of value, they are the same — both equal 9. The difference is notation: 0x09 explicitly indicates hexadecimal (base 16), while 9 without a prefix is assumed to be decimal (base 10). In programming, using 0x09 makes your intent clear when working with hex values, bit masks, or byte-level data.
Yes, if written as 09 without the 0x prefix in strict mode, it may cause a SyntaxError. This happens because a leading zero signals octal notation in some contexts, and 9 is not a valid octal digit. Always use 0x09 for hexadecimal values to avoid this issue.
0x09 corresponds to Unicode code point U+0009, officially named "CHARACTER TABULATION." It is identical to the ASCII tab character because Unicode's first 128 code points are the same as ASCII. In UTF-8, it is encoded as the single byte 0x09.
0x09 requires 4 bits to represent (binary 1001), but is stored as a full 8-bit byte (00001001) in computer memory. The upper 4 bits are zero-padded. As a single byte, it uses 8 bits of storage.
Hexadecimal is used instead of binary because it is far more compact and human-readable. Each hex digit represents exactly 4 binary bits, so a byte can be written as 2 hex digits instead of 8 binary digits. For example, 0x09 (2 characters) is much easier to read and remember than 00001001 (8 characters). This makes hex ideal for memory addresses, color codes, debugging, and low-level programming.