ASCII table and character ramp builder

What is ASCII?

ASCII stands for American Standard Code for Information Interchange. It assigns numbers to letters, digits, punctuation and controls. ASCII art arranges printable characters into a picture.

Open the image converter or browse generated examples.

Working with a list of numbers? Convert ASCII numbers to text and back.

The 7-bit range

Seven bits encode 128 values: decimal 0-127, hexadecimal 00-7F.
In an 8-bit byte, ASCII occupies the low seven bits with the high bit zero.
The printable range is 32-126: 95 characters including space. Space advances the position without drawing a mark.
Values 0-31 are controls, such as tab (9), line feed (10), carriage return (13) and escape (27).
DEL is 127 (0x7F), outside the printable range. Unicode classifies it as a control, not a drawing character.

For the code table and byte representation, see RFC 20. The Unicode Basic Latin chart lists the corresponding characters and controls.

Build a printable ASCII character ramp

Enter characters in darkest-to-lightest order for the image converter's Standard mode. Order, duplicates and leading/trailing spaces are kept exactly. The tool does not rank glyph density: that depends on the font.

Black to white: 64 opaque grayscale samples through the real Standard converter, with neutral adjustments and no dithering. This demonstrates selection order, not font coverage.

@@@@%%%%%%%#######*******+++++++=======-------:::::::.......

Exact ramp, escaped: "@%#*+=-:. ". Spaces appear inside the quotes; quotes and escape backslashes are not exported.

Copy the raw ramp, then open the image converter and upload an image. In Options, choose Standard ASCII Art, open Advanced image settings and paste into Character Set. Leave meaningful spaces intact. No ramp is put in the link, browser storage or analytics.

ASCII code table: 0-127

Find a code or control name

Show codes

128 of 128 codes. Append buttons add printable characters to the end of your ramp, including repeats.

All 7-bit ASCII codes; controls cannot be appended to a character ramp.
Decimal	Hex	7-bit binary	Character / name	Ramp
0	0x00	0000000	NUL - Null	Control
1	0x01	0000001	SOH - Start of heading	Control
2	0x02	0000010	STX - Start of text	Control
3	0x03	0000011	ETX - End of text	Control
4	0x04	0000100	EOT - End of transmission	Control
5	0x05	0000101	ENQ - Enquiry	Control
6	0x06	0000110	ACK - Acknowledge	Control
7	0x07	0000111	BEL - Bell	Control
8	0x08	0001000	BS - Backspace	Control
9	0x09	0001001	HT - Horizontal tab	Control
10	0x0A	0001010	LF - Line feed	Control
11	0x0B	0001011	VT - Vertical tab	Control
12	0x0C	0001100	FF - Form feed	Control
13	0x0D	0001101	CR - Carriage return	Control
14	0x0E	0001110	SO - Shift out	Control
15	0x0F	0001111	SI - Shift in	Control
16	0x10	0010000	DLE - Data link escape	Control
17	0x11	0010001	DC1 - Device control 1	Control
18	0x12	0010010	DC2 - Device control 2	Control
19	0x13	0010011	DC3 - Device control 3	Control
20	0x14	0010100	DC4 - Device control 4	Control
21	0x15	0010101	NAK - Negative acknowledge	Control
22	0x16	0010110	SYN - Synchronous idle	Control
23	0x17	0010111	ETB - End of transmission block	Control
24	0x18	0011000	CAN - Cancel	Control
25	0x19	0011001	EM - End of medium	Control
26	0x1A	0011010	SUB - Substitute	Control
27	0x1B	0011011	ESC - Escape	Control
28	0x1C	0011100	FS - File separator	Control
29	0x1D	0011101	GS - Group separator	Control
30	0x1E	0011110	RS - Record separator	Control
31	0x1F	0011111	US - Unit separator	Control
32	0x20	0100000	`SPACE`
33	0x21	0100001	`!`
34	0x22	0100010	`"`
35	0x23	0100011	`#`
36	0x24	0100100	`$`
37	0x25	0100101	`%`
38	0x26	0100110	`&`
39	0x27	0100111	`'`
40	0x28	0101000	`(`
41	0x29	0101001	`)`
42	0x2A	0101010	`*`
43	0x2B	0101011	`+`
44	0x2C	0101100	`,`
45	0x2D	0101101	`-`
46	0x2E	0101110	`.`
47	0x2F	0101111	`/`
48	0x30	0110000	`0`
49	0x31	0110001	`1`
50	0x32	0110010	`2`
51	0x33	0110011	`3`
52	0x34	0110100	`4`
53	0x35	0110101	`5`
54	0x36	0110110	`6`
55	0x37	0110111	`7`
56	0x38	0111000	`8`
57	0x39	0111001	`9`
58	0x3A	0111010	`:`
59	0x3B	0111011	`;`
60	0x3C	0111100	`<`
61	0x3D	0111101	`=`
62	0x3E	0111110	`>`
63	0x3F	0111111	`?`
64	0x40	1000000	`@`
65	0x41	1000001	`A`
66	0x42	1000010	`B`
67	0x43	1000011	`C`
68	0x44	1000100	`D`
69	0x45	1000101	`E`
70	0x46	1000110	`F`
71	0x47	1000111	`G`
72	0x48	1001000	`H`
73	0x49	1001001	`I`
74	0x4A	1001010	`J`
75	0x4B	1001011	`K`
76	0x4C	1001100	`L`
77	0x4D	1001101	`M`
78	0x4E	1001110	`N`
79	0x4F	1001111	`O`
80	0x50	1010000	`P`
81	0x51	1010001	`Q`
82	0x52	1010010	`R`
83	0x53	1010011	`S`
84	0x54	1010100	`T`
85	0x55	1010101	`U`
86	0x56	1010110	`V`
87	0x57	1010111	`W`
88	0x58	1011000	`X`
89	0x59	1011001	`Y`
90	0x5A	1011010	`Z`
91	0x5B	1011011	`[`
92	0x5C	1011100	`\`
93	0x5D	1011101	`]`
94	0x5E	1011110	`^`
95	0x5F	1011111	`_`
96	0x60	1100000	`
97	0x61	1100001	`a`
98	0x62	1100010	`b`
99	0x63	1100011	`c`
100	0x64	1100100	`d`
101	0x65	1100101	`e`
102	0x66	1100110	`f`
103	0x67	1100111	`g`
104	0x68	1101000	`h`
105	0x69	1101001	`i`
106	0x6A	1101010	`j`
107	0x6B	1101011	`k`
108	0x6C	1101100	`l`
109	0x6D	1101101	`m`
110	0x6E	1101110	`n`
111	0x6F	1101111	`o`
112	0x70	1110000	`p`
113	0x71	1110001	`q`
114	0x72	1110010	`r`
115	0x73	1110011	`s`
116	0x74	1110100	`t`
117	0x75	1110101	`u`
118	0x76	1110110	`v`
119	0x77	1110111	`w`
120	0x78	1111000	`x`
121	0x79	1111001	`y`
122	0x7A	1111010	`z`
123	0x7B	1111011	`{`
124	0x7C	1111100	`\|`
125	0x7D	1111101	`}`
126	0x7E	1111110	`~`
127	0x7F	1111111	DEL - Delete	Control

Convert ASCII numbers to text in Python

Each number identifies one character. Decimal 65 32 66 10 means A, a space, B and a line feed. This decodes text; it does not draw a banner. For large letters made from characters, use the text-to-ASCII generator.

With Python 3 installed, save this complete example as ascii_codes.py. Run python3 ascii_codes.py, or py -3 ascii_codes.py on Windows. Use whitespace-separated decimal values, not commas or hexadecimal prefixes:

codes = "65 32 66 10"
values = [int(token) for token in codes.split()]
text = bytes(values).decode("ascii")
print(repr(text))

Output:

'A B\n'

repr shows the line feed as \n instead of sending it to the terminal. Its surrounding quotes are a display convention, not characters in the decoded text. Other controls, such as ESC, are escaped too. Inspect unfamiliar codes before displaying their raw text.

Convert text back to ASCII numbers

Run this as a separate example. The string contains the same space and final line feed:

text = "A B\n"
codes = " ".join(str(value) for value in text.encode("ascii"))
print(codes)

65 32 66 10

Keep a separator between values. Without a stated format, 6566 could mean 65 66 or 6 56 6; the latter includes controls. The decoder above treats an unseparated token as one integer, rather than guessing boundaries. This is encoding, not encryption.

When strict ASCII should fail

128 through 255 fit in a byte but are not ASCII. Decoding them with "ascii" raises UnicodeDecodeError.
Negative values and values above 255 cannot enter bytes(values); Python raises ValueError. A comma-separated token such as 65,32 also raises ValueError during integer parsing.
Encoding an accented letter, a box-drawing line or an emoji with "ascii" raises UnicodeEncodeError. Use the encoding your data actually requires; do not silently ignore or replace characters to make the error disappear.

The existing code table includes controls; the character ramp accepts only printable values 32-126. Signed byte arrays and "extended ASCII" require a known encoding and a separate interpretation. Python's bytes decoding and string encoding documentation describe these operations. This website does not run the Python code.

ASCII, extended encodings and Unicode

"Extended ASCII" is an informal name for different 8-bit encodings, not a single extra character set. Code pages such as CP437 and Windows-1252 assign different meanings above 127. Selecting the wrong encoding can change the displayed text.

Unicode includes ASCII as U+0000 through U+007F. UTF-8 encodes those values as the same single bytes, so ASCII text is also valid UTF-8. Other characters can require several bytes. See RFC 3629.

Blocks, box-drawing lines and emoji in this app are Unicode text, not strict ASCII. Use Standard, Simple, Binary or Detailed with only printable ASCII symbols when that distinction matters. UTF-8 support does not guarantee that a font contains every glyph.

To diagnose tabs, no-break spaces or invisible formatting in existing text, use the Unicode and invisible character inspector. It reveals code points and previews targeted repairs without automatically removing joiners or emoji sequences.

A historical reference

RFC 20, published in October 1969, describes ASCII for network interchange and reproduces the 1968 code table. It documents text encoding, not the invention date of ASCII art. Text art uses that limited palette to suggest outlines and shading; today this app generates those character grids from images or FIGlet font definitions.

Using text art in a project

Copy and TXT preserve characters, spaces and line breaks, not the receiving app's styling. Use a fenced code block in a README or chat, or a preformatted monospace text area. Keep leading/trailing spaces and disable wrapping. Unicode blocks, lines and emoji need suitable fonts and may occupy different widths.

A programming language, file format or terminal may use ASCII symbols for syntax while also accepting Unicode text. Git diffs do not require ASCII-only source files. Check the receiving tool's encoding and font rather than treating ASCII as a universal requirement.

For conversion settings, follow the image tutorial. For banners, read the FIGlet guide. The algorithm explanation covers how this converter selects characters.

Frequently asked questions

What file types are used for ASCII art?

This tool saves characters as TXT or renders them as PNG. TXT remains editable; PNG is useful when the destination changes text spacing.

Can I turn any image into ASCII art?

Use still PNG, JPG, single-frame GIF, still WebP or uncompressed BMP. Animated PNG/WebP, multi-frame GIF and user SVG, AVIF and other unsupported formats are rejected before image decoding; export one frame to a still PNG first. Bundled Twemoji SVG artwork is a trusted site-asset exception. Choose one image up to 10 MiB (10,485,760 bytes) and 24 million decoded pixels. Conversion allows at most 40,000 sampling cells and 1,000 sampling rows. Reduce width or resize/crop the input if a limit is exceeded. A clear subject and simple background are a useful starting point; small details can disappear in a text grid.

Where can I use ASCII art?

Try a README code block, a terminal banner or a preformatted chat message. Preview in the destination before sharing; support for spacing and Unicode glyphs varies.

Navigation