How do you convert a decimal number to hex?

To convert decimal to hex, divide the number by 16 and record the remainder. Convert remainders 10 through 15 to letters A through F. Continue dividing the quotient by 16 until it reaches 0, then read remainders in reverse.

What is the hex value of decimal 255?

The decimal number 255 converts to hexadecimal as FF (or 0xFF).

Can I convert hex numbers back to decimal?

Yes. Switch the converter mode to Hex to Decimal, paste your base-16 value, and the tool will instantly compute the base-10 integer equivalent.

Is my data stored or transmitted to any server?

No. The entire conversion process executes 100% locally in your web browser using JavaScript. Zero data is transmitted to or stored on any server.

Decimal to Hex Converter: Base-10 to Base-16

Decimal to Hex Converter

Save on Google

Tip: enter one number to see the division steps, 2's complement, binary, octal and byte order. Several numbers (new line, space or comma), fractions like 10.625 and e notation like 5.72e2 also work.

Output Width Negative Fraction Group by 2 0x prefix lowercase

Output appears here

Tool Name	Explanation
Related Developer Tools
Decimal to Binary Converter	Converts decimal numbers into binary with steps, 2's complement and hex.
Binary to Hex Converter	Groups binary bits in fours and converts them into hex digits.
Hex to Binary Converter	Expands each hex digit into 4 bits with steps, decimal and octal.
Binary to Decimal Converter	Converts binary numbers into decimal with bit-by-bit steps, hex and octal.
Text to Hex Converter	Converts text into hexadecimal bytes with separator, case and prefix options.
Hex to Text Converter	Decodes hexadecimal bytes back into readable text.
Octal to Binary Converter	Expands each octal digit into 3 bits with steps, decimal and hex.
Text to Binary Converter	Converts text into 8-bit or 7-bit binary (0s and 1s) instantly.
Base64 Encode / Decode	Encodes text or files to Base64 and decodes Base64 strings instantly.
JSON to Go Struct Converter	Generates idiomatic Go structs with json tags from any JSON payload.
JSON to TypeScript Interface	Generates typed TypeScript interfaces from any JSON payload.
HTML to JSX Converter	Converts HTML markup into valid React JSX (className, self-closing tags, style objects).
TOML to JSON Converter	Transforms TOML config files into clean, formatted JSON or YAML.

Example 1: Convert 215 to Hex

Division by 16	Quotient	Remainder (Hex digit)	Digit #
215/16	13	7 (7)	0
13/16	0	13 (D)	1

Read the remainders from the last step to the first: 215 = D7 (13 x 16 + 7).

Example 2: Convert 3054 to Hex

Division by 16	Quotient	Remainder (Hex digit)	Digit #
3054/16	190	14 (E)	0
190/16	11	14 (E)	1
11/16	0	11 (B)	2

Read the remainders from the last step to the first: 3054 = BEE (11 x 256 + 14 x 16 + 14).

Decimal 0-255 to Hex Table

Decimal	Hex	Binary (8-bit)	Octal
0	`00`	`00000000`	`000`
1	`01`	`00000001`	`001`
2	`02`	`00000010`	`002`
3	`03`	`00000011`	`003`
4	`04`	`00000100`	`004`
5	`05`	`00000101`	`005`
6	`06`	`00000110`	`006`
7	`07`	`00000111`	`007`
8	`08`	`00001000`	`010`
9	`09`	`00001001`	`011`
10	`0A`	`00001010`	`012`
11	`0B`	`00001011`	`013`
12	`0C`	`00001100`	`014`
13	`0D`	`00001101`	`015`
14	`0E`	`00001110`	`016`
15	`0F`	`00001111`	`017`
16	`10`	`00010000`	`020`
17	`11`	`00010001`	`021`
18	`12`	`00010010`	`022`
19	`13`	`00010011`	`023`
20	`14`	`00010100`	`024`
21	`15`	`00010101`	`025`
22	`16`	`00010110`	`026`
23	`17`	`00010111`	`027`
24	`18`	`00011000`	`030`
25	`19`	`00011001`	`031`
26	`1A`	`00011010`	`032`
27	`1B`	`00011011`	`033`
28	`1C`	`00011100`	`034`
29	`1D`	`00011101`	`035`
30	`1E`	`00011110`	`036`
31	`1F`	`00011111`	`037`
32	`20`	`00100000`	`040`
33	`21`	`00100001`	`041`
34	`22`	`00100010`	`042`
35	`23`	`00100011`	`043`
36	`24`	`00100100`	`044`
37	`25`	`00100101`	`045`
38	`26`	`00100110`	`046`
39	`27`	`00100111`	`047`
40	`28`	`00101000`	`050`
41	`29`	`00101001`	`051`
42	`2A`	`00101010`	`052`
43	`2B`	`00101011`	`053`
44	`2C`	`00101100`	`054`
45	`2D`	`00101101`	`055`
46	`2E`	`00101110`	`056`
47	`2F`	`00101111`	`057`
48	`30`	`00110000`	`060`
49	`31`	`00110001`	`061`
50	`32`	`00110010`	`062`
51	`33`	`00110011`	`063`
52	`34`	`00110100`	`064`
53	`35`	`00110101`	`065`
54	`36`	`00110110`	`066`
55	`37`	`00110111`	`067`
56	`38`	`00111000`	`070`
57	`39`	`00111001`	`071`
58	`3A`	`00111010`	`072`
59	`3B`	`00111011`	`073`
60	`3C`	`00111100`	`074`
61	`3D`	`00111101`	`075`
62	`3E`	`00111110`	`076`
63	`3F`	`00111111`	`077`
64	`40`	`01000000`	`100`
65	`41`	`01000001`	`101`
66	`42`	`01000010`	`102`
67	`43`	`01000011`	`103`
68	`44`	`01000100`	`104`
69	`45`	`01000101`	`105`
70	`46`	`01000110`	`106`
71	`47`	`01000111`	`107`
72	`48`	`01001000`	`110`
73	`49`	`01001001`	`111`
74	`4A`	`01001010`	`112`
75	`4B`	`01001011`	`113`
76	`4C`	`01001100`	`114`
77	`4D`	`01001101`	`115`
78	`4E`	`01001110`	`116`
79	`4F`	`01001111`	`117`
80	`50`	`01010000`	`120`
81	`51`	`01010001`	`121`
82	`52`	`01010010`	`122`
83	`53`	`01010011`	`123`
84	`54`	`01010100`	`124`
85	`55`	`01010101`	`125`
86	`56`	`01010110`	`126`
87	`57`	`01010111`	`127`
88	`58`	`01011000`	`130`
89	`59`	`01011001`	`131`
90	`5A`	`01011010`	`132`
91	`5B`	`01011011`	`133`
92	`5C`	`01011100`	`134`
93	`5D`	`01011101`	`135`
94	`5E`	`01011110`	`136`
95	`5F`	`01011111`	`137`
96	`60`	`01100000`	`140`
97	`61`	`01100001`	`141`
98	`62`	`01100010`	`142`
99	`63`	`01100011`	`143`
100	`64`	`01100100`	`144`
101	`65`	`01100101`	`145`
102	`66`	`01100110`	`146`
103	`67`	`01100111`	`147`
104	`68`	`01101000`	`150`
105	`69`	`01101001`	`151`
106	`6A`	`01101010`	`152`
107	`6B`	`01101011`	`153`
108	`6C`	`01101100`	`154`
109	`6D`	`01101101`	`155`
110	`6E`	`01101110`	`156`
111	`6F`	`01101111`	`157`
112	`70`	`01110000`	`160`
113	`71`	`01110001`	`161`
114	`72`	`01110010`	`162`
115	`73`	`01110011`	`163`
116	`74`	`01110100`	`164`
117	`75`	`01110101`	`165`
118	`76`	`01110110`	`166`
119	`77`	`01110111`	`167`
120	`78`	`01111000`	`170`
121	`79`	`01111001`	`171`
122	`7A`	`01111010`	`172`
123	`7B`	`01111011`	`173`
124	`7C`	`01111100`	`174`
125	`7D`	`01111101`	`175`
126	`7E`	`01111110`	`176`
127	`7F`	`01111111`	`177`
128	`80`	`10000000`	`200`
129	`81`	`10000001`	`201`
130	`82`	`10000010`	`202`
131	`83`	`10000011`	`203`
132	`84`	`10000100`	`204`
133	`85`	`10000101`	`205`
134	`86`	`10000110`	`206`
135	`87`	`10000111`	`207`
136	`88`	`10001000`	`210`
137	`89`	`10001001`	`211`
138	`8A`	`10001010`	`212`
139	`8B`	`10001011`	`213`
140	`8C`	`10001100`	`214`
141	`8D`	`10001101`	`215`
142	`8E`	`10001110`	`216`
143	`8F`	`10001111`	`217`
144	`90`	`10010000`	`220`
145	`91`	`10010001`	`221`
146	`92`	`10010010`	`222`
147	`93`	`10010011`	`223`
148	`94`	`10010100`	`224`
149	`95`	`10010101`	`225`
150	`96`	`10010110`	`226`
151	`97`	`10010111`	`227`
152	`98`	`10011000`	`230`
153	`99`	`10011001`	`231`
154	`9A`	`10011010`	`232`
155	`9B`	`10011011`	`233`
156	`9C`	`10011100`	`234`
157	`9D`	`10011101`	`235`
158	`9E`	`10011110`	`236`
159	`9F`	`10011111`	`237`
160	`A0`	`10100000`	`240`
161	`A1`	`10100001`	`241`
162	`A2`	`10100010`	`242`
163	`A3`	`10100011`	`243`
164	`A4`	`10100100`	`244`
165	`A5`	`10100101`	`245`
166	`A6`	`10100110`	`246`
167	`A7`	`10100111`	`247`
168	`A8`	`10101000`	`250`
169	`A9`	`10101001`	`251`
170	`AA`	`10101010`	`252`
171	`AB`	`10101011`	`253`
172	`AC`	`10101100`	`254`
173	`AD`	`10101101`	`255`
174	`AE`	`10101110`	`256`
175	`AF`	`10101111`	`257`
176	`B0`	`10110000`	`260`
177	`B1`	`10110001`	`261`
178	`B2`	`10110010`	`262`
179	`B3`	`10110011`	`263`
180	`B4`	`10110100`	`264`
181	`B5`	`10110101`	`265`
182	`B6`	`10110110`	`266`
183	`B7`	`10110111`	`267`
184	`B8`	`10111000`	`270`
185	`B9`	`10111001`	`271`
186	`BA`	`10111010`	`272`
187	`BB`	`10111011`	`273`
188	`BC`	`10111100`	`274`
189	`BD`	`10111101`	`275`
190	`BE`	`10111110`	`276`
191	`BF`	`10111111`	`277`
192	`C0`	`11000000`	`300`
193	`C1`	`11000001`	`301`
194	`C2`	`11000010`	`302`
195	`C3`	`11000011`	`303`
196	`C4`	`11000100`	`304`
197	`C5`	`11000101`	`305`
198	`C6`	`11000110`	`306`
199	`C7`	`11000111`	`307`
200	`C8`	`11001000`	`310`
201	`C9`	`11001001`	`311`
202	`CA`	`11001010`	`312`
203	`CB`	`11001011`	`313`
204	`CC`	`11001100`	`314`
205	`CD`	`11001101`	`315`
206	`CE`	`11001110`	`316`
207	`CF`	`11001111`	`317`
208	`D0`	`11010000`	`320`
209	`D1`	`11010001`	`321`
210	`D2`	`11010010`	`322`
211	`D3`	`11010011`	`323`
212	`D4`	`11010100`	`324`
213	`D5`	`11010101`	`325`
214	`D6`	`11010110`	`326`
215	`D7`	`11010111`	`327`
216	`D8`	`11011000`	`330`
217	`D9`	`11011001`	`331`
218	`DA`	`11011010`	`332`
219	`DB`	`11011011`	`333`
220	`DC`	`11011100`	`334`
221	`DD`	`11011101`	`335`
222	`DE`	`11011110`	`336`
223	`DF`	`11011111`	`337`
224	`E0`	`11100000`	`340`
225	`E1`	`11100001`	`341`
226	`E2`	`11100010`	`342`
227	`E3`	`11100011`	`343`
228	`E4`	`11100100`	`344`
229	`E5`	`11100101`	`345`
230	`E6`	`11100110`	`346`
231	`E7`	`11100111`	`347`
232	`E8`	`11101000`	`350`
233	`E9`	`11101001`	`351`
234	`EA`	`11101010`	`352`
235	`EB`	`11101011`	`353`
236	`EC`	`11101100`	`354`
237	`ED`	`11101101`	`355`
238	`EE`	`11101110`	`356`
239	`EF`	`11101111`	`357`
240	`F0`	`11110000`	`360`
241	`F1`	`11110001`	`361`
242	`F2`	`11110010`	`362`
243	`F3`	`11110011`	`363`
244	`F4`	`11110100`	`364`
245	`F5`	`11110101`	`365`
246	`F6`	`11110110`	`366`
247	`F7`	`11110111`	`367`
248	`F8`	`11111000`	`370`
249	`F9`	`11111001`	`371`
250	`FA`	`11111010`	`372`
251	`FB`	`11111011`	`373`
252	`FC`	`11111100`	`374`
253	`FD`	`11111101`	`375`
254	`FE`	`11111110`	`376`
255	`FF`	`11111111`	`377`

Powers of 2 in Hex

Power	Decimal	Hex
2^0	1	`1`
2^1	2	`2`
2^2	4	`4`
2^3	8	`8`
2^4	16	`10`
2^5	32	`20`
2^6	64	`40`
2^7	128	`80`
2^8	256	`100`
2^9	512	`200`
2^10	1024	`400`
2^11	2048	`800`
2^12	4096	`1000`
2^13	8192	`2000`
2^14	16384	`4000`
2^15	32768	`8000`
2^16	65536	`10000`
2^17	131072	`20000`
2^18	262144	`40000`
2^19	524288	`80000`
2^20	1048576	`100000`
2^21	2097152	`200000`
2^22	4194304	`400000`
2^23	8388608	`800000`
2^24	16777216	`1000000`
2^25	33554432	`2000000`
2^26	67108864	`4000000`
2^27	134217728	`8000000`
2^28	268435456	`10000000`
2^29	536870912	`20000000`
2^30	1073741824	`40000000`
2^31	2147483648	`80000000`
2^32	4294967296	`100000000`

Powers of 16 in Hex

Power	Decimal	Hex
16^0	1	`1`
16^1	16	`10`
16^2	256	`100`
16^3	4096	`1000`
16^4	65536	`10000`
16^5	1048576	`100000`
16^6	16777216	`1000000`
16^7	268435456	`10000000`
16^8	4294967296	`100000000`

Common Decimal Numbers in Hex

Number	Decimal	Hex	Binary
Subnet mask octet (/25)	128	`80`	`10000000`
Subnet mask octet (/26)	192	`C0`	`11000000`
Subnet mask octet (/27)	224	`E0`	`11100000`
Subnet mask octet (/28)	240	`F0`	`11110000`
Subnet mask octet (/29)	248	`F8`	`11111000`
Subnet mask octet (/30)	252	`FC`	`11111100`
Subnet mask octet (/31)	254	`FE`	`11111110`
Subnet mask octet (/24)	255	`FF`	`11111111`
SSH port	22	`16`	`10110`
SMTP port	25	`19`	`11001`
DNS port	53	`35`	`110101`
HTTP port	80	`50`	`1010000`
HTTPS port	443	`1BB`	`110111011`
MySQL port	3306	`CEA`	`110011101010`
PostgreSQL port	5432	`1538`	`1010100111000`
Alternate HTTP port	8080	`1F90`	`1111110010000`
Loopback first octet	127	`7F`	`1111111`
Private IP first octet (10.x.x.x)	10	`A`	`1010`
Private IP first octet (192.168.x.x)	192	`C0`	`11000000`
Private IP second octet (192.168.x.x)	168	`A8`	`10101000`
Ten	10	`A`	`1010`
One hundred	100	`64`	`1100100`
One thousand	1000	`3E8`	`1111101000`
Max signed 8-bit	127	`7F`	`1111111`
Max unsigned 8-bit	255	`FF`	`11111111`
Values in a byte	256	`100`	`100000000`
One kibibyte	1024	`400`	`10000000000`
Page size	4096	`1000`	`1000000000000`
Max signed 16-bit	32767	`7FFF`	`111111111111111`
Max unsigned 16-bit	65535	`FFFF`	`1111111111111111`
Values in 16 bits	65536	`10000`	`10000000000000000`
Max RGB hex FFFFFF	16777215	`FFFFFF`	`111111111111111111111111`
Max signed 32-bit	2147483647	`7FFFFFFF`	`1111111111111111111111111111111`
Max unsigned 32-bit	4294967295	`FFFFFFFF`	`11111111111111111111111111111111`
Days from 1970 to 2000	10957	`2ACD`	`10101011001101`
ASCII letter A	65	`41`	`1000001`
ASCII letter a	97	`61`	`1100001`
ASCII digit 0	48	`30`	`110000`
ASCII space	32	`20`	`100000`
ASCII line feed	10	`A`	`1010`

RGB Values to Hex Colors

Color	RGB (Decimal)	Hex Color
Black	rgb(0, 0, 0)	`#000000`
White	rgb(255, 255, 255)	`#FFFFFF`
Red	rgb(255, 0, 0)	`#FF0000`
Green (lime)	rgb(0, 255, 0)	`#00FF00`
Blue	rgb(0, 0, 255)	`#0000FF`
Yellow	rgb(255, 255, 0)	`#FFFF00`
Cyan	rgb(0, 255, 255)	`#00FFFF`
Magenta	rgb(255, 0, 255)	`#FF00FF`
Gray	rgb(128, 128, 128)	`#808080`
Silver	rgb(192, 192, 192)	`#C0C0C0`
Orange	rgb(255, 165, 0)	`#FFA500`
Navy	rgb(0, 0, 128)	`#000080`
Teal	rgb(0, 128, 128)	`#008080`
Maroon	rgb(128, 0, 0)	`#800000`
Olive	rgb(128, 128, 0)	`#808000`
Purple	rgb(128, 0, 128)	`#800080`

Decimal Fractions in Hex

Decimal	Hex	Type
0.5	`0.8`	Exact
0.25	`0.4`	Exact
0.125	`0.2`	Exact
0.75	`0.C`	Exact
0.375	`0.6`	Exact
0.0625	`0.1`	Exact
1.5	`1.8`	Exact
2.75	`2.C`	Exact
10.625	`A.A`	Exact
0.1	`0.19999999`	Repeats, cut at 8 digits
0.2	`0.33333333`	Repeats, cut at 8 digits
0.3	`0.4CCCCCCC`	Repeats, cut at 8 digits
0.6	`0.99999999`	Repeats, cut at 8 digits
3.14159	`3.243F3E03`	Repeats, cut at 8 digits
2.71828	`2.B7E132B5`	Repeats, cut at 8 digits

Negative Numbers in Two's Complement Hex

Decimal	Positive Hex	8-bit Two's Complement	16-bit Two's Complement	32-bit Two's Complement
-1	`1`	`FF`	`FFFF`	`FFFFFFFF`
-2	`2`	`FE`	`FFFE`	`FFFFFFFE`
-3	`3`	`FD`	`FFFD`	`FFFFFFFD`
-5	`5`	`FB`	`FFFB`	`FFFFFFFB`
-8	`8`	`F8`	`FFF8`	`FFFFFFF8`
-10	`A`	`F6`	`FFF6`	`FFFFFFF6`
-16	`10`	`F0`	`FFF0`	`FFFFFFF0`
-32	`20`	`E0`	`FFE0`	`FFFFFFE0`
-64	`40`	`C0`	`FFC0`	`FFFFFFC0`
-100	`64`	`9C`	`FF9C`	`FFFFFF9C`
-127	`7F`	`81`	`FF81`	`FFFFFF81`
-128	`80`	`80`	`FF80`	`FFFFFF80`
-200	`C8`	not in range	`FF38`	`FFFFFF38`
-255	`FF`	not in range	`FF01`	`FFFFFF01`
-1000	`3E8`	not in range	`FC18`	`FFFFFC18`

Technical Q&A / FAQ Matrix

Technical Developer Question	Exact Solution & Code Snippet
How do I convert decimal to hex in JavaScript?	`(255).toString(16).toUpperCase()`
How do I convert decimal to hex in Python?	`format(255, 'X')`
How do I convert decimal to hex in Go?	`strconv.FormatInt(255, 16)`
How do I convert decimal to hex in Java?	`Integer.toHexString(255)`
How do I convert decimal to hex in C#?	`(255).ToString("X")`
How do I convert decimal to hex in PHP?	`echo dechex(255);`
How do I convert decimal to hex in Rust?	`format!("{:X}", 255)`
How do I convert decimal to hex on Linux?	`printf '%X\n' 255`
How do I pad hex to 2 digits?	`JavaScript: (5).toString(16).padStart(2, '0'). Python: format(5, '02X'). Result: 05.`
How do I convert decimal to hex by hand?	`Divide the number by 16 repeatedly and write down each remainder, using A to F for 10 to 15. Read the remainders from bottom to top. For 215: 215/16=13 r7, 13/16=0 r13 (D), so D7.`
How do I get a hex color from RGB values?	`Convert each channel to 2 hex digits and join them. rgb(255, 165, 0) becomes FF A5 00, which is #FFA500.`
What is the largest number in 8, 16 and 32 bits?	`Unsigned: 255 (FF), 65535 (FFFF) and 4294967295 (FFFFFFFF). Signed two's complement: 127 (7F), 32767 (7FFF) and 2147483647 (7FFFFFFF).`
How are negative numbers written in hex?	`With two's complement. -1 in 8 bits is FF, in 16 bits is FFFF. For -5 in 8 bits: 05 inverted is FA, plus 1 is FB.`
How do I convert a decimal fraction to hex?	`Multiply the fraction by 16 repeatedly and write down the integer part each time. For 0.5: 0.5 x 16 = 8.0, so 0.8.`
Why is hex 0.1 not exact?	`Decimal 0.1 is 0.1999... in hex and never ends, so the tool cuts it at the chosen number of digits.`
How do I convert hex back to decimal?	`JavaScript: parseInt('D7', 16). Python: int('D7', 16). Result: 215.`