Does ATASCII really match ASCII exactly in this range?

Yes, in the printable range shown here (codes 32-126), ATASCII passes through identically to standard ASCII, this is one of the more ASCII-compatible 8-bit home-computer character sets of its era, unlike PETSCII, which diverges more.

So where does ATASCII actually differ from ASCII?

The most significant difference is outside this printable chart: ATASCII uses byte 0x9B (155 decimal) as its end-of-line marker, instead of ASCII's 0x0A (line feed) or the CR/LF pair used elsewhere. ATASCII also defines an extended graphics set in the 128-255 range, outside standard ASCII entirely.

Why does this chart stop at 126 instead of covering ATASCII's full graphics set?

This chart deliberately covers only the 7-bit ASCII-compatible printable range (32-126) to mirror the ASCII Table Generator and PETSCII Table Generator; the 128-255 graphics range is a separate, much larger extended character set outside this category's strict 7-bit ASCII scope.

How does this compare to the PETSCII Table Generator?

PETSCII (Commodore 64) diverges from ASCII noticeably in its printable range, no lowercase letters in default mode, a few punctuation substitutions. ATASCII stays fully ASCII-compatible across the same range, with its main quirk (the 0x9B EOL byte) living outside the printable range entirely.

ATASCII Table Generator - Atari 8-Bit Character Set Reference

Dec	Hex	Char
32	20
33	21	!
34	22	"
35	23	#
36	24	$
37	25	%
38	26	&
39	27	'
40	28	(
41	29	)
42	2A	*
43	2B	+
44	2C	,
45	2D	-
46	2E	.
47	2F	/
48	30	0
49	31	1
50	32	2
51	33	3
52	34	4
53	35	5
54	36	6
55	37	7
56	38	8
57	39	9
58	3A	:
59	3B	;
60	3C	<
61	3D	=
62	3E	>
63	3F	?
64	40	@
65	41	A
66	42	B
67	43	C
68	44	D
69	45	E
70	46	F
71	47	G
72	48	H
73	49	I
74	4A	J
75	4B	K
76	4C	L
77	4D	M
78	4E	N
79	4F	O
80	50	P
81	51	Q
82	52	R
83	53	S
84	54	T
85	55	U
86	56	V
87	57	W
88	58	X
89	59	Y
90	5A	Z
91	5B	[
92	5C	\
93	5D	]
94	5E	^
95	5F	_
96	60	`
97	61	a
98	62	b
99	63	c
100	64	d
101	65	e
102	66	f
103	67	g
104	68	h
105	69	i
106	6A	j
107	6B	k
108	6C	l
109	6D	m
110	6E	n
111	6F	o
112	70	p
113	71	q
114	72	r
115	73	s
116	74	t
117	75	u
118	76	v
119	77	w
120	78	x
121	79	y
122	7A	z
123	7B	{
124	7C	\|
125	7D	}
126	7E	~

Overview

Introduction

Atari 8-bit computers used their own character set, ATASCII, which turns out to be far closer to plain ASCII than its Commodore 64 counterpart, PETSCII.

This chart lays out ATASCII codes 32-126 to show exactly how closely it tracks ASCII, and flags the one major divergence that lives outside this printable range.

What Is ATASCII Table Generator?

A static reference chart covering the printable range of Atari ATASCII, codes 32 through 126, alongside decimal and hex values.

It's the ATASCII sibling of the ASCII Table Generator and PETSCII Table Generator, useful for comparing all three character sets side by side.

How ATASCII Table Generator Works

Every code from 32 to 126 is converted directly with `String.fromCharCode`, since ATASCII's printable range passes through identically to ASCII.

The chart doesn't cover code 0x9B (155), ATASCII's actual end-of-line byte, since that falls outside the 32-126 printable range this chart focuses on; it's documented separately instead.

When To Use ATASCII Table Generator

Use it when working with Atari 8-bit program listings, disk images, or retro-computing projects that reference ATASCII byte values.

It's also useful for confirming that a given printable character's byte value is safe to treat the same in ASCII and ATASCII contexts.

Often used alongside ASCII Table Generator, PETSCII Table Generator and ASCII to ATASCII Converter.

Features

Advantages

Confirms at a glance that ATASCII's printable range matches ASCII exactly, no lookup or substitution needed for codes 32-126.
Flags ATASCII's one major real divergence, the 0x9B end-of-line byte, clearly rather than letting it hide as an assumption.
Consistent chart format with the ASCII and PETSCII table generators, making cross-platform comparison straightforward.

Limitations

Covers only the printable 32-126 range; ATASCII's extended graphics character set (128-255) isn't included here.
Doesn't include the 0x9B end-of-line byte itself as a chart row, since it falls outside the 32-126 printable range; it's documented in the FAQ and developer notes instead.

Examples

A code that matches ASCII exactly

Input

Output

Dec 65, Hex 41, Char A

ATASCII code 65 is uppercase A, identical to ASCII, this holds true across the entire 32-126 printable range.

Filtering for a punctuation character

Input

Output

Dec 126, Hex 7E, Char ~

Tilde at the top of the printable range also passes through identically between ATASCII and ASCII.

Best Practices & Notes

Best Practices

Remember that files saved on real Atari 8-bit hardware use 0x9B for line endings, if you're processing an actual ATASCII text file, convert that byte to a newline before treating it as plain ASCII text.
Use the filter box to jump straight to a code you're cross-referencing from a program listing or memory dump.

Developer Notes

The printable range is generated with a plain `String.fromCharCode(code)` loop, since ATASCII genuinely doesn't diverge from ASCII there; `ATASCII_EOL_BYTE` (0x9B / 155) is exported as a documented constant separately, since it's the platform's one significant divergence and falls outside this table's 32-126 scope.

ATASCII Table Generator Use Cases

Looking up an ATASCII byte value while reading or writing Atari 8-bit program listings
Confirming which printable characters are safe to treat identically between ASCII and ATASCII contexts
Retro-computing and Atari 8-bit emulation projects that need a quick character code reference

Common Mistakes

Assuming a text file exported from Atari 8-bit software uses ASCII's 0x0A line feed for line breaks, it actually uses 0x9B.
Expecting ATASCII to diverge from ASCII within the printable range the way PETSCII does, it doesn't; the real difference lives outside this chart's scope.

Tips

If you're converting a real ATASCII text file, handle the 0x9B end-of-line byte as a special case before treating the rest of the bytes as plain ASCII.
Compare with the PETSCII Table Generator to see a home-computer character set with much more significant ASCII divergence.

ATASCII Table Generator