Python 2, 1074 1064 1042 1039 1038 bytes

Each program has the form print'\<octal char code>', except:

• ' → print"\47"
• 0 through 8 → print~-<N+1>
• 9 → print-~8
• \ → print'%c'%92
• i → exec'pr\151nt"\151"'
• n → exec'pri\156t"\156"'
• p → exec'\160rint"\160"'
• r → exec'p\162int"\162"'
• t → exec'prin\164"\164"'

For reference and ease of testing, here's the full list of programs, newline-separated.

print'\40'
print'\41'
print'\42'
print'\43'
print'\44'
print'\45'
print'\46'
print"\47"
print'\50'
print'\51'
print'\52'
print'\53'
print'\54'
print'\55'
print'\56'
print'\57'
print~-1
print~-2
print~-3
print~-4
print~-5
print~-6
print~-7
print~-8
print~-9
print-~8
print'\72'
print'\73'
print'\74'
print'\75'
print'\76'
print'\77'
print'\100'
print'\101'
print'\102'
print'\103'
print'\104'
print'\105'
print'\106'
print'\107'
print'\110'
print'\111'
print'\112'
print'\113'
print'\114'
print'\115'
print'\116'
print'\117'
print'\120'
print'\121'
print'\122'
print'\123'
print'\124'
print'\125'
print'\126'
print'\127'
print'\130'
print'\131'
print'\132'
print'\133'
print'%c'%92
print'\135'
print'\136'
print'\137'
print'\140'
print'\141'
print'\142'
print'\143'
print'\144'
print'\145'
print'\146'
print'\147'
print'\150'
exec'pr\151nt"\151"'
print'\152'
print'\153'
print'\154'
print'\155'
exec'pri\156t"\156"'
print'\157'
exec'\160rint"\160"'
print'\161'
exec'p\162int"\162"'
print'\163'
exec'prin\164"\164"'
print'\165'
print'\166'
print'\167'
print'\170'
print'\171'
print'\172'
print'\173'
print'\174'
print'\175'
print'\176'

To test:

$ python printables.py | sed ':a;N;$!ba;s/\n//g'
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

-1 bytes thanks to @Sp3000!

CJam, 269 bytes

Each of the programs are in the form '<char - 1>) except for:

• Space => S, 1 byte
• ' => 39c, 3 bytes
• ) => '*(, 3 bytes
• 0 => T, 1 byte
• 1 => X, 1 byte
• 2 => Y, 1 byte
• 3 => Z, 1 byte
• 4-9 => <num-1>), 2 bytes

Score is: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

Ruby, 869 bytes

For the 63 characters @ through ~, we have a 10-byte solution:

$><<"\xxx"     (3 digit octal code)
$><<92.chr     (special case for \)

For most (21) characters from space through ?, we have a 9-byte solution:

puts"\xx"     (2 digit octal code)

There are eleven special cases left:

$><<34.chr    (10 bytes for ")
p$.           (3 bytes for 0)
p~-2          \
p~-3           \ (4 bytes for 1-8)
...            /
p~-9          /
p 1+8         (5 bytes for 9)

In total, the score is 10×63 + 9×21 + 10 + 3 + 8×4 + 5 = 869.

MATL, 305, 302, 300 297 bytes

Every single program looks like this:

33c
34c
35c
....

Except for

• Digits. Here are the programs for 0-9:

  O
  l
  H
  I
  K
  4Q
  5Q
  6Q
  7Q
  8Q
  

• 'c'. This program is

  'C'k
  

• space. This is

  0c
  

  Since today I learned, that MATL treats character 0 as space. Thanks @LuisMendo!

You can use matl.tio to verify any of them.

For reference, here is all of them:

0c
33c
34c
35c
36c
37c
38c
39c
40c
41c
42c
43c
44c
45c
46c
47c
O
l
H
I
K
4Q
5Q
6Q
7Q
8Q
58c
59c
60c
61c
62c
63c
64c
65c
66c
67c
68c
69c
70c
71c
72c
73c
74c
75c
76c
77c
78c
79c
80c
81c
82c
83c
84c
85c
86c
87c
88c
89c
90c
91c
92c
93c
94c
95c
96c
97c
98c
'C'k
100c
101c
102c
103c
104c
105c
106c
107c
108c
109c
110c
111c
112c
113c
114c
115c
116c
117c
118c
119c
120c
121c
122c
123c
124c
125c
126c

Brachylog, 546 477 bytes

Credits to Fatalize for the code for @.

In the list below, the first character is the character to be printed (for easy reference).

  @S
! @Ht
" @P:2m
# @P:3m
$ @P:4m
% @P:5m
& @P:6m
' @P:7m
( @P:8m
) @P:9m
* @P:10m
+ @P:11m
, @H:5m
- @P:13m
. @P:14m
/ @P:15m
0 1-
1 0+
2 1+
3 2+
4 3+
5 4+
6 5+
7 6+
8 7+
9 8+
: @P@4bhbbbh
; @P:27m
< @P:28m
= @P:29m
> @P:30m
? @P:31m
@ "?":"A"ybh
A @Zt@u
B @Ch@u
C @P:35m
D @P:36m
E @P:37m
F @P:38m
G @P:39m
H @P:40m
I @P:41m
J @P:42m
K @P:43m
L @P:44m
M @P:45m
N @P:46m
O @P:47m
P @A:15m@u
Q @P:49m
R @P:50m
S @P:51m
T @P:52m
U @Vt@u
V @P:54m
W @Qt@u
X @P:56m
Y @Wt@u
Z @At@u
[ @P:59m
\ @P:60m
] @P:61m
^ @P:62m
_ @P:63m
` @P:64m
a @Vh
b @Ch
c @Dbh
d @A:3m
e @Vbh
f @A:5m
g @A:6m
h @A:7m
i @A:8m
j @A:9m
k @C:7m
l @C:8m
m @D@2ht
n @A:13m
o @H:4m
p @A:15m
q @Z:9m
r @Z:8m
s @Z:7m
t @Z:6m
u @Vt
v @Z:4m
w @Qt
x @Z:2m
y @Wt
z @At
{ @P:91m
| @P:92m
} @Prbh
~ @Pt

They are all predicates, so Z needs to be the argument to receive the output: Try it online!

Explanation

@P is this string:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

which contains every printable ASCII.

><>, 443 437 bytes

TIO interpreter link. There's a lot of patterns here:

• [num][num]*o;: Multiplication of two numbers, then output the result as a char with o and halt with ;. ><> digits go up to 15, i.e. 0123456789abcdef.
  • Similarly [num][num]-n;, which takes the difference of two numbers and outputs as a number with n instead.

• '-o[invalid char]: ><> is toroidal, so when the instruction pointer reaches the end of a line it moves back to the beginning. In this case, this causes the code to be executed twice, i.e. '-o[char]'-o[char]. The first '-o[char]' part pushes three chars to the stack, - calculates 'o' - [char] then o outputs the result as a character. ><> then errors out when it reaches [char], either due to an unrecognised command or from popping an empty stack.

  • Similarly '-n[invalid char], which outputs as a number.
  • Similarly '[num][op]o[invalid char], which applies [op] with [num] on [char], erroring out on char. For example, '2+oJ outputs L, which is two more than J.
  • ''s code is "-oH, using " instead.
  • -'s code is '%oB, using % instead.

• ln;: Push length of stack, output as num then halt, giving 0. Similarly lln; for 1 and 'ln; for 3.

• 4|n+: Push 4, bounce off the | and push another 4, add, then output 8 as num. Bounce off the | again, and error out trying to execute n again on an empty stack.
  • Similarly 3|n* for 9.
  • Similarly [num]|o* for @Qdy.
• '1-:00p: The most interesting one, for the o case. To avoid using o in our code, we need to use p to place an o in the codebox, then run it. The initial '1-:00p' sets the stack up to have a p on top, and 1- decrements it into an o. : duplicates this o, and 00p places one o at (0, 0), turning the codebox into o1-:00p. The instruction pointer wraps again, outputting the other o. The (0, 0) char is then replaced a few more times before the program finally errors out.

      '-oO
!     '-oN
"     '-oM
#     '-oL
$     '-oK
%     '-oJ
&     '-oI
'     "-oH
(     '-oG
)     '-oF
*     '-oE
+     '-oD
,     '-oC
-     '%oB
.     '-oA
/     '-o@
0     ln;
1     lln;
2     '-o=
3     'ln;
4     '-o;
5     61-n;
6     '-nh
7     '-ng
8     4|n+
9     3|n*
:     '1-o;
;     '6-oA
<     6a*o;
=     '2+o;
>     '3+o;
?     79*o;
@     8|o*
A     '-o.
B     '-o-
C     '-o,
D     '-o+
E     '-o*
F     '-o)
G     '-o(
H     89*o;
I     '1-oJ
J     '-o%
K     '-o$
L     '2+oJ
M     7b*o;
N     '-o!
O     '5+oJ
P     8a*o;
Q     9|o*
R     '8+oJ
S     '9+oJ
T     7c*o;
U     'b+oJ
V     'c+oJ
W     'd+oJ
X     8b*o;
Y     'f+oJ
Z     9a*o;
[     7d*o;
\     'c-oh
]     'b-oh
^     'a-oh
_     '9-oh
`     8c*o;
a     '7-oh
b     7e*o;
c     9b*o;
d     a|o*
e     '3-oh
f     '2-oh
g     '1-oh
h     '2-oj
i     8d*o;
j     '2+oh
k     '3+oh
l     9c*o;
m     '5+oh
n     ab*o;
o     '1-:00p
p     8e*o;
q     '3-ot
r     '2-ot
s     '1-ot
t     '1+os
u     9d*o;
v     '2+ot
w     '3+ot
x     ac*o;
y     b|o*
z     '6+ot
{     '7+ot
|     '8+ot
}     '9+ot
~     9e*o;

Dyalog APL, 527 522 bytes

(non-competing because APL cannot really be written using ASCII only)

Most are in the format nn⊃⎕AV or nnn⊃⎕AV, the exceptions being:

⊃''     ⍝ space: extract one char from an empty string
⎕THIS   ⍝ hash: this namespace
⊃1↓⍕÷2  ⍝ period: the first char after stripping one char from 1÷2, i.e. 0.5
⊃⍬      ⍝ zero: extract one number from an empty numeric list
≢#      ⍝ one: tally the root namespace
⍴⍬⍬     ⍝ two: count two empty lists
⎕WX     ⍝ three: default "Window Expose" setting
×⍨2     ⍝ four: 2×2
6-1     ⍝ five: 6-1
!3      ⍝ six: 3!
6+1     ⍝ seven: 6+1
2*3     ⍝ eight: 2³
3*2     ⍝ nine: 3²
⊃⎕a     ⍝ A: first character (Dyalog system names are case insensitive)
2⊃⎕A    ⍝
⋮        ⍝  B-Y: n'th character
25⊃⎕A   ⍝
⊃⌽⎕A    ⍝ Z: last character

Here is the entire list:

⊃''
205⊃⎕AV
216⊃⎕AV
⎕THIS
62⊃⎕AV
13⊃⎕AV
219⊃⎕AV
14⊃⎕AV
186⊃⎕AV
249⊃⎕AV
181⊃⎕AV
170⊃⎕AV
195⊃⎕AV
169⊃⎕AV
⊃1↓⍕÷2
157⊃⎕AV
⊃⍬
≢#
⍴⍬ ⍬
⎕WX
×⍨2
6-1
!3
6+1
2*3
3*2
241⊃⎕AV
194⊃⎕AV
161⊃⎕AV
163⊃⎕AV
165⊃⎕AV
173⊃⎕AV
232⊃⎕AV
⊃⎕a
2⊃⎕A
3⊃⎕A
4⊃⎕A
5⊃⎕A
6⊃⎕A
7⊃⎕A
8⊃⎕A
9⊃⎕A
10⊃⎕A
11⊃⎕A
12⊃⎕A
13⊃⎕A
14⊃⎕A
15⊃⎕A
16⊃⎕A
17⊃⎕A
18⊃⎕A
19⊃⎕A
20⊃⎕A
21⊃⎕A
22⊃⎕A
23⊃⎕A
24⊃⎕A
25⊃⎕A
26⊃⎕A
156⊃⎕AV
159⊃⎕AV
250⊃⎕AV
236⊃⎕AV
17⊃⎕AV
238⊃⎕AV
18⊃⎕AV
19⊃⎕AV
20⊃⎕AV
21⊃⎕AV
22⊃⎕AV
23⊃⎕AV
24⊃⎕AV
25⊃⎕AV
26⊃⎕AV
27⊃⎕AV
28⊃⎕AV
29⊃⎕AV
30⊃⎕AV
31⊃⎕AV
32⊃⎕AV
33⊃⎕AV
34⊃⎕AV
35⊃⎕AV
36⊃⎕AV
37⊃⎕AV
38⊃⎕AV
39⊃⎕AV
40⊃⎕AV
41⊃⎕AV
42⊃⎕AV
43⊃⎕AV
124⊃⎕AV
193⊃⎕AV
126⊃⎕AV
176⊃⎕AV

Brainfuck, 1770 bytes

DNP: 46 (.)

>-[-[-<]>>+<]>-.
>-[-[-<]>>+<]>.
>-[-[-<]>>+<]>+.
>-[++>+[<]>+]>.
+[->-[---<]>-]>.
>-[+<[-<]>>++]<.
>+[-->+[<]>-]>-.
>+[-->+[<]>-]>.
>+[-->+[<]>-]>+.
--[>+<++++++]>--.
--[>+<++++++]>-.
-------[>-<-]>[->-------------------------------------------------------------------<].
--[>+<++++++]>+.
++++++>+<[+>+<]>[+>+++++++++<]>.
+[-[--<]>>--]<.
-[>+<-----]>---.
-[>+<-----]>--.
-[>+<-----]>-.
-[>+<-----]>.
-[>+<-----]>+.
-[>+<-----]>++.
-[>+<-----]>+++.
>-[++>+[+<]>]>-.
>-[++>+[+<]>]>.
>-[++>+[+<]>]>+.
>-[++[+<]>>+<]>.
>+[+[<]>->++]<.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+[-[>+<<]>-]>--.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+[-[>+<<]>-]>.
-[+[>+<<]>+]>.
>+[+[<]>>+<+]>.
--[++>+[<]>+]>.
+[->-[--<]>-]>.
+[->-[--<]>-]>+.
+[->-[--<]>-]>++.
-[+[>---<<]>+]>.
-[>+<-------]>--.
-[>+<-------]>-.
-[>+<-------]>.
-[>+<-------]>+.
-[>+<-------]>++.
>+[+<[-<]>>++]<.
>+++[[-<]>>--]<.
+[+[>>+<+<-]>]>.
-[+>++[++<]>]>-.
-[+>++[++<]>]>.
-[>+<---]>----.
-[>+<---]>---.
-[>+<---]>--.
-[>+<---]>-.
-[>+<---]>.
-[>+<---]>+.
-[>+<---]>++.
-[+[+<]>>+]<.
-[+[+<]>>+]<+.
-[+[+<]>>+]<++.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+[->---[-<]>-]>.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
>-->+[+[+<]>>+]<.
>+[+[>+<+<]>]>-.
>+[+[>+<+<]>]>.
+[-[---<]>>-]<-.
+[-[---<]>>-]<.
>-[--[<]>+>-]<.
-[>++<-----]>--.
-[>++<-----]>-.
-[>++<-----]>.
-[>++<-----]>+.
+[->-[<]>--]>-.
+[->-[<]>--]>.
+[->-[<]>--]>+.
>+[++[++>]<<+]>.
>+[++[++>]<<+]>+.
+[->-[<]>+>--]>.
-[>--<-------]>.
>+[+>+[<]>->]<.
>+[+>+[<]>->]<+.
-[+>+++++[<]>+]>.
>+[-->++[<]>-]>.
+[->->-[<]>--]>.
+[->->-[-<]>-]>.
+[->>-[-<+<]>]>.
----[>+++++<--]>.
------[>+++<--]>.
>+[>+[<]>->+]<-.
>+[>+[<]>->+]<.
----[>+++<--]>.
--[>+<--]>----.
--[>+<--]>---.
--[>+<--]>--.
--[>+<--]>-.

All except 43, 45, 60, 62, 91 and 93 are shamelessly stolen from Esolangs.org

05AB1E, 417 bytes

!   62D>B
"   63D>B
#   64D>B
$   65D>B
%   66D>B
&   67D>B
'   68D>B
(   69D>B
)   70D>B
*   71D>B
+   72D>B
,   73D>B
-   74D>B
.   75D>B
/   76D>B
0   1<
1   X
2   Y
3   Z
4   3>
5   4>
6   5>
7   6>
8   7>
9   8>
:   77D>B
;   78D>B
<   79D>B
=   80D>B
>   81D1+B
?   82D>B
@   83D>B
A   Th
B   T>h
C   T>>h
D   T3+h
E   T4+h
F   T5+h
G   16D>B
H   17D>B
I   18D>B
J   19D>B
K   20D>B
L   21D>B
M   22D>B
N   23D>B
O   24D>B
P   25D>B
Q   26D>B
R   27D>B
S   28D>B
T   29D>B
U   30D>B
V   31D>B
W   33D>B
X   33D>B
Y   A`\u
Z   A`u
[   84D>B
\   85D>B
]   86D>B
^   87D>B
_   88D>B
`   89D>B
a   A`r
b   A`r\
c   38D>B
d   39D>B
e   40D>B
f   41D>B
g   42D>B
h   43D>B
i   44D>B
j   45D>B
k   46D>B
l   47D>B
m   48D>B
n   49D>B
o   50D>B
p   51D>B
q   52D>B
r   53D>B
s   54D>B
t   55D>B
u   56D>B
v   57D>B
w   58D>B
x   A`\\
y   A`\
z   A`
{   90D>B
|   91D>B
}   92D>B
~   93D>B

Explanation

Most are 5 bytes long of the form: convert nr to base nr+1.
> needs an extra byte since we can't use increment for that.

a,b,x,y,z,Y,Z are extracted from A which contains the alphabet in lower case.

A,B,C,D,E,F are numbers converted to hex.

0-9 are simple increment/decrements as well as predefined variables.

Pyke, 364 362 355 bytes

2*1 + 3*2 + 14*3 + 2*4 + 5 + 73*4

All in the form w<chr(charcode+32)>.C (4 bytes) except for:

• -> d 1 byte
• 0 -> Z 1 byte
• 1 -> ~W 2 bytes
• a -> Gh 2 bytes
• z -> Ge 2 bytes
• First 10 lowercase alphabet letters (except a) in form G<number>@ (3 bytes)
• k -> GT@ 3 bytes
• > -> ~Bh 3 bytes
• ] -> ~Be 3 bytes
• Z -> ~le 3 bytes
• 9 -> ~ue 3 bytes
• w -> G22@ 4 bytes
• . -> ~B4@ 4 bytes
• C -> ~K38@ 5 bytes

Online Pyke interpreter

Fourier, 306 bytes, 1 DNP

Pretty much all of the programs follow the pattern na where n is the character code of each of the characters. For example:

!       33a
"       34a
#       35a
$       36a
%       37a
&       38a
'       39a

Try it online!

So I'll just list the exceptions:

0 (Zero)

Since the accumulator is preset to zero, we can display this using a single character:

o

Try it online!

1

Similar to zero, this increments the accumulator to get 1.

^o

Try it online!

5

The ASCII code for 5 is 53, so I had to work around this:

6vo

Try it online!

a

Due to a being the character output function, there is no other way to produce the character a, so this my only DID NOT PROGRAM.

BBC Basic, 422 413 bytes

Download interpreter free at http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

9 bytes saved thanks to Leaky Nun.

General form

V.<character code>

32..99 excluding 12 special cases: 56x4= 224 bytes

100..126 : 27x5= 135 bytes

12 special cases : 54 bytes

Most numbers follow the general form, but I included them all here to show where the problem is.

First character is the character to be printed.

. VDU46       :REM Full form of the command used in general form: send character 46 to VDU)
V P.CHR$86    :REM short for PRINT CHR$(86)
0 V.48       
1 V.49
2 V.50
3 V.51
4 V.52
5 P.1+4
6 V.54
7 V.55
8 V.56
9 V.57

WolframAlpha, 368 bytes

General format:

u+<character code in hexadecimal>

Exceptions:

Character   Code
+           plus
0           1-1
1           0!
2           1+1
3           1+2
4           2+2
5           2+3
6           3!
7           3+4
8           4+4
9           4+5
u           U+75

Here is the full list:

u+20
u+21
u+22
u+23
u+24
u+25
u+26
u+27
u+28
u+29
u+2A
plus
u+2C
u+2D
u+2E
u+2F
1-1
0!
1+1
1+2
2+2
2+3
3!
3+4
4+4
4+5
u+3A
u+3B
u+3C
u+3D
u+3E
u+3F
u+40
u+41
u+42
u+43
u+44
u+45
u+46
u+47
u+48
u+49
u+4A
u+4B
u+4C
u+4D
u+4E
u+4F
u+50
u+51
u+52
u+53
u+54
u+55
u+56
u+57
u+58
u+59
u+5A
u+5B
u+5C
u+5D
u+5E
u+5F
u+60
u+61
u+62
u+63
u+64
u+65
u+66
u+67
u+68
u+69
u+6A
u+6B
u+6C
u+6D
u+6E
u+6F
u+70
u+71
u+72
u+73
u+74
U+75
u+76
u+77
u+78
u+79
u+7A
u+7B
u+7C
u+7D
u+7E

JavaScript (ES6), 1083 1068 bytes

General form:

alert`\xhex`

Exceptions:

0 alert(9-9)
...
8 alert(9-1)
9 alert(8+1)
\ alert(atob`XA`)
` alert('\x60')
a \u0061lert`\x61`
e al\u0065rt`\x65`
l a\u006cert`\x6c`
r ale\u0072t`\x72`
t aler\u0074`\x74`
x alert`\u0078`

Edit: Saved 15 bytes thanks to @GOTO0.

><>, 531 bytes

The programs take two main forms:

##*o;
"chr-1"1+o;

The first is for characters with character codes with two factors both less than 16, the other is for the other cases. Most numbers that I use the second form for have many equal length solutions, but I chose that one for readability.

Exceptions:

" b3*1+o; Would be "!"1+o; normally
0 11-n; n outputs as a number
1 22/n;
2-9 #1+n;
; ":"1+o* Ends in an error

Full list:

! b3*o;
" b3*1+o;
# 57*o;
$ 66*o;
% "$"1+o;
& "%"1+o;
' d3*o;
( a4*o;
) "("1+o;
* ")"1+o;
+ ","1-o;
, b4*o;
- 95*o;
. "-"1+o;
/ "."1+o;
0 11-n;
1 22/n;
2 11+n;
3 21+n;
4 31+n;
5 41+n;
6 51+n;
7 61+n;
8 71+n;
9 81+n;
: "9"1+o;
; ":"1+o*
< a6*o;
= "<"1+o;
> "="1+o;
? 97*o;
@ 88*o;
A d5*o;
B b6*o;
C "B"1+o;
D "C"1+o;
E "D"1+o;
F a7*o;
G "F"1+o;
H 98*o;
I "H"1+o;
J "D"1+o;
K e5*o;
L "K"1+o;
M b7*o;
N d6*o;
O "D"1+o;
P a8*o;
Q 99*o;
R "Q"1+o;
S "R"1+o;
T c7*o;
U "T"1+o;
V "U"1+o;
W "V"1+o;
X b8*o;
Y "X"1+o;
Z a9*o;
[ c7*o;
\ "["1+o;
] "\"1+o;
^ "]"1+o;
_ "^"1+o;
` c8*o;
a "`"1+o;
b e7*o;
c b9*o;
d aa*o;
e "d"1+o;
f "e"1+o;
g "g"1+o;
h d8*o;
i e7*o;
j "i"1+o;
k "j"1+o;
l c9*o;
m "l"1+o;
n ba*o;
o DNP
p e8*o;
q "p"1+o;
r "q"1+o;
s "r"1+o;
t "s"1+o;
u c9*o;
v "u"1+o;
w "v"1+o;
x ca*o;
y bb*o;
z "y"1+o;
~ e9*o;

Actually, 383 382 381 bytes

1 byte thanks to Mego.

For easy reference, the first column is the character code, the second column is the character, and the third column is the code.

The code for 0 is a single space.

032   :32c
033 ! HN
034 " 9Fc
035 # :35c
036 $ :36c
037 % :37c
038 & :38c
039 ' :39c
040 ( :40c
041 ) 9R$N
042 * :42c
043 + :43c
044 , :44c
045 - :45c
046 . :46c
047 / :47c
048 0  
049 1 0Y
050 2 0P
051 3 1P
052 4 3u
053 5 2P
054 6 3!
055 7 3P
056 8 6F
057 9 NF
058 : 9P;+c
059 ; :59c
060 < :60c
061 = :61c
062 > :62c
063 ? :63c
064 @ :64c
065 A :65c
066 B :66c
067 C :67c
068 D :68c
069 E :69c
070 F :70c
071 G :71c
072 H :72c
073 I :73c
074 J :74c
075 K :75c
076 L :76c
077 M :77c
078 N :78c
079 O :79c
080 P :80c
081 Q :81c
082 R :82c
083 S :83c
084 T :84c
085 U :85c
086 V :86c
087 W :87c
088 X :88c
089 Y :89c
090 Z :90c
091 [ k$F
092 \ :92c
093 ] k$N
094 ^ :94c
095 _ :95c
096 ` :96c
097 a :97c
098 b :98c
099 c :12#"%x"%
100 d :100c
101 e :101c
102 f :102c
103 g :103c
104 h :104c
105 i :105c
106 j :106c
107 k :107c
108 l :108c
109 m :109c
110 n :110c
111 o :111c
112 p :112c
113 q 9PPc
114 r 9R$F
115 s :115c
116 t :116c
117 u :117c
118 v :118c
119 w 5!Dc
120 x 5!c
121 y 5!uc
122 z :122c
123 { :123c
124 | :124c
125 } :125c
126 ~ :126c

Try it online!

Golfing suggestions are welcome.

Hexagony, 376 373 bytes, 1 DNP

Thanks to FryAmTheEggman for saving 3 bytes.

Almost all programs have the same form:

  P0;@
! P1;@
" P2;@
...
| Y2;@
} Y3;@
~ Y4;@

There are a few exceptions though:

• It's impossible to print ; without using ;, hence 1 DNP.
• To print @, we cannot use @ to terminate the program. Instead we use either S2;: or S3;%. This terminates with a division-by-zero error, but that error is not visible on STDOUT. So this is still four bytes.
• There is one clash for U which would require U3;@. There are several ways to fix this, including switching to lower-case, i.e. n9;@, or using increment or decrement, i.e. T);@ or V(;@. In any case it's still four bytes.
• Memory edges are initialised to 0, and ! prints an integer value, so we can get 0 and 1 with !@ and )!@, respectively, saving 3 bytes.

As for how the <letter><digit>;@ programs work: the hexagonal layout of a program of the form 1234 is always

 1 2
3 4 .
 . .

Since none of the programs contain any commands that redirect control flow, these are simply linear programs that are executed in order.

In every case, the letter at the beginning of the code sets the current memory edge to its character code. E.g. in the program P1;@, the P sets the value 80. Then the digit multiplies this value by 10 and adds itself (i.e. the digit is appended to the current value). That gives 801 in the example above. Finally, ; prints this value by taking it modulo 256 and using it as a byte value. In this case 801 % 256 = 33 and a ! is printed.

Haskell, 1874 1864 bytes, 7 DNP

    main=putChar$pred$'!'
!   main=putChar$pred '"'
"   main=putChar$pred '#'
#   main=putChar$pred '$'
$   main=putChar(pred '%')
%   main=putChar$pred '&'
&   main=putChar$succ '%'
'   main=putChar$pred$"("!!0
(   main=putChar$pred ')'
)   main=putChar$pred '*'
*   main=putChar$pred '+'
+   main=putChar$pred ','
,   main=putChar$pred '-'
-   main=putChar$pred '.'
.   main=putChar$pred '/'
/   main=putChar$pred '0'
0   main=putStr.show$1-1
1   main=putStr.show$3-2
2   main=putStr.show$1+1
...
9   main=putStr.show$1+8
:   main=putChar$pred ';'
;   main=putChar$pred '<'
<   main=putChar$pred '='
=   DNP
>   main=putChar$pred '?'
?   main=putChar$pred '@'
@   main=putChar$pred 'A'
A   main=putChar$pred 'B'
B   main=putChar$pred 'C'
C   main=putStr$pred 'D':""
D   main=putChar$pred 'E'
...
Z   main=putChar$pred '['
[   main=putChar$succ 'Z'
\   main=putChar$pred ']'
]   main=putChar$pred '^'
^   main=putChar$pred '_'
_   main=putChar$pred '`'
`   main=putChar$pred 'a'
a   DNP
b   main=putChar$pred 'c'
c   main=putChar$pred 'd'
d   main=putChar$succ 'c'
e   main=putChar$succ 'd'
f   main=putChar$pred 'g'
g   main=putChar$pred 'h'
h   main=putStr$pred 'i':""
i   DNP
j   main=putChar$pred 'k'
k   main=putChar$pred 'l'
l   main=putChar$pred 'm'
m   DNP
n   DNP
o   main=putChar$pred 'p'
p   main=interact(\_->succ 'o':"")
q   main=putChar$pred 'r'
r   DNP 
s   main=putChar$pred 't'
t   DNP 
u   main=interact(\_->pred 'v':"")
v   main=putChar$pred 'w'
w   main=putChar$pred 'x'
x   main=putChar$pred 'y'
y   main=putChar$pred 'z'
z   main=putChar$pred '{'
{   main=putChar$pred '|'
|   main=putChar$pred '}'
}   main=putChar$pred '~'
~   main=putChar$succ '}'

Each Haskell program needs to define a main (main=), so that's 5 DNPs. To print to stdOut, putChar, putStr or interact can be used, yielding t and r as further DNPs.
As Chars are an ordered datatype, the pred and succ functions are used. Haskell also has a chr function which returns the corresponding char given a number, however in order to use it import Data.Char is needed.

Edit: Digits are now one byte shorter.

Minkolang 0.15, 604 bytes

For most characters, "<char-1>"1+O. would be a valid program, perhaps one of the shortest. However, due to the fact that characters are stored as code points on the stack means that many of them can be produced by multiplication and addition, in five bytes or fewer. Also, note that l, $1, $2, $3, $4, $5, $6, $l are 10, 11, 12, 13, 14, 15, 16, 100 respectively.

Format: <character>: <program>

 : 48*O.
!: $13*O.
": 66*2-O.
#: 57*O.
$: 66*O.
%: 66*1+O.
&: 4l*2-O.
': 3$3*O.
(: 4l*O.
): 4l*1+O.
*: ")"1+O.
+: "*"1+O.
,: $14*O.
-: 59*O.
.: "-"1+d$10pO-
/: "."1+O.
0: 68*O.
1: 77*O.
2: 5l*O.
3: 5l*1+O.
4: lZIO.
5: lZdIO.
6: 239**O.
7: 5$1*O.
8: 4$4*O.
9: 6l*3-O.
:: 6l*2-O.
;: 6l*1-O.
<: 6l*O.
=: 6l*1+O.
>: 6l*2+O.
?: 79*O.
@: 88*O.
A: 5$3*O.
B: 6$1*O.
C: 7l*3-O.
D: 7l*2-O.
E: 7l*1-O.
F: 7l*O.
G: 7l*1+O.
H: 89*O.
I: 89*1+O.
J: 89*2+O.
K: 355**O.
L: 89*4+O.
M: 7$1*O.
N: 6$3*O.
O: "N"1+d90pN.
P: 8l*O.
Q: 99*O.
R: 8l*2+O.
S: 8l*3+O.
T: 347**O.
U: 8l*5+O.
V: 8l*6+O.
W: 8l*7+O.
X: 8$1*O.
Y: 8l*9+O.
Z: 9l*O.
[: $l9-O.
\: $l8-O.
]: $l7-O.
^: $l6-O.
_: $l5-O.
`: 8$2*O.
a: $l3-O.
b: $l2-O.
c: 9$1*O.
d: $lO.
e: $l1+O.
f: $l2+O.
g: $l3+O.
h: $l4+O.
i: $l5+O.
j: $l6+O.
k: $l7+O.
l: $l8+O.
m: $l9+O.
n: l$1*O.
o: $l$1+O.
p: $l$2+O.
q: $l$3+O.
r: $l$4+O.
s: $l$5+O.
t: $l$6+O.
u: "t"1+O.
v: "u"1+O.
w: 7dl+*O.
x: 358**O.
y: $1d*O.
z: 53;3-O.
{: 53;2-O.
|: 53;1-O.
}: 53;O.
~: 53;1+O.

Special mentions:

.: "-"1+d$10pO-

(Try it.) Minkolang has the ability to modify the characters in the code box, so what this program does is that it replaces that - at the end with ., which is necessary for stopping the program. "N"1+d90pN. for O works the same way.

4: lZIO.

(Try it.) lZ pushes the uppercase and lowercase alphabets to the stack, and I pushes the length of the stack, which is 52, precisely the code point of "4". The best part is that I was initially considering the solution of 4$3*O., which multiplies 4 and 13 to get 52, but couldn't because it had a 4 in it, so I ended up finding a golfier solution anyway!

y: $1d*O.

(Try it.) d duplicates the top of stack, so what this piece of code does is that it pushes 11, duplicates it, and then multiplies. An alternate way to write this would have been $12;O., which has the same byte count.

}: 53;O.

(Try it.) ; is exponentiation, so this does 5^3 to get 125.

Pip, 294 bytes

Most characters are computed using the Chr operator with their ASCII codes. Lowercase letters are (mostly) computed by indexing into z, the lowercase alphabet, since this is shorter for a few of them and breaks even for most of the rest. Here are the other exceptions:

• s is a builtin for space
• i is a builtin for 0
• o is a builtin for 1
• #t takes the length of the builtin for 10, giving 2
• #h takes the length of the builtin for 100, giving 3
• #m takes the length of the builtin for 1000, giving 4
• t/2 gives 5, avoiding using ASCII code 53
• AZ@2 indexes into the builtin uppercase alphabet for C, avoiding the Chr operator
• Ch is shorter for d than z@3
• z@t is shorter for k than z@10
• z@v, i.e. z@-1, is shorter for z than z@26

Here's the full list:

  s
! C33
" C34
# C35
$ C36
% C37
& C38
' C39
( C40
) C41
* C42
+ C43
, C44
- C45
. C46
/ C47
0 i
1 o
2 #t
3 #h
4 #m
5 t/2
6 C54
7 C55
8 C56
9 C57
: C58
; C59
< C60
= C61
> C62
? C63
@ C64
A C65
B C66
C AZ@2
D C68
E C69
F C70
G C71
H C72
I C73
J C74
K C75
L C76
M C77
N C78
O C79
P C80
Q C81
R C82
S C83
T C84
U C85
V C86
W C87
X C88
Y C89
Z C90
[ C91
\ C92
] C93
^ C94
_ C95
` C96
a z@0
b z@1
c z@2
d Ch
e z@4
f z@5
g z@6
h z@7
i z@8
j z@9
k z@t
l z@11
m z@12
n z@13
o z@14
p z@15
q z@16
r z@17
s z@18
t z@19
u z@20
v z@21
w z@22
x z@23
y z@24
z z@v
{ C123
| C124
} C125
~ C126

Groovy, 1019 bytes

I had a different Groovy solution written up (see below), but after I submitted it I did a bit more digging into character escapes, hoping to find a way of shortening the program more, and discovered that Groovy has an octal character escape that I did not know of. This significantly simplifies the code, to the point that it unfortunately removes the need for almost all of the quirky workarounds I had come up with.

It also looks almost identical to Copper's Python 2 solution, to the point where it basically looks like I plagiarized their work. Ugh.

Each program has the form print'\<octal value>', except:

• p, r, i, n, t → 'print''\<octal value>' (but with the matching letter of "print" also replaced with the octal value)
• 0 - 9 → print~-<next int>

Here is the full list of programs by character.

    print'\40'
!   print'\41'
"   print'\42'
#   print'\43'
$   print'\44'
%   print'\45'
&   print'\46'
'   print'\47'
(   print'\50'
)   print'\51'
*   print'\52'
+   print'\53'
,   print'\54'
-   print'\55'
.   print'\56'
/   print'\57'
0   print~-1
1   print~-2
2   print~-3
3   print~-4
4   print~-5
5   print~-6
6   print~-7
7   print~-8
8   print~-9
9   print~-10
:   print'\72'
;   print'\73'
<   print'\74'
=   print'\75'
>   print'\76'
?   print'\77'
@   print'\100'
A   print'\101'
B   print'\102'
C   print'\103'
D   print'\104'
E   print'\105'
F   print'\106'
G   print'\107'
H   print'\110'
I   print'\111'
J   print'\112'
K   print'\113'
L   print'\114'
M   print'\115'
N   print'\116'
O   print'\117'
P   print'\120'
Q   print'\121'
R   print'\122'
S   print'\123'
T   print'\124'
U   print'\125'
V   print'\126'
W   print'\127'
X   print'\130'
Y   print'\131'
Z   print'\132'
[   print'\133'
\   print'\134'
]   print'\135'
^   print'\136'
_   print'\137'
`   print'\140'
a   print'\141'
b   print'\142'
c   print'\143'
d   print'\144'
e   print'\145'
f   print'\146'
g   print'\147'
h   print'\150'
i   'pr\151nt''\151'
j   print'\152'
k   print'\153'
l   print'\154'
m   print'\155'
n   'pri\156t''\156'
o   print'\157'
p   '\160rint''\160'
q   print'\161'
r   'p\162int''\162'
s   print'\163'
t   'prin\164''\164'
u   print'\165'
v   print'\166'
w   print'\167'
x   print'\170'
y   print'\171'
z   print'\172'
{   print'\173'
|   print'\174'
}   print'\175'
~   print'\176'

Groovy, 1130 bytes

My previous program, before I discovered that octal escapes exist. Much more interesting, IMO.

Each program has the form print(--'<next char>'), except:

• -, [, ~ → print(++'<previous char>')
• & → print(--"'")
• p, r, i, n → System.out<<--'<next char>'
• t → 'prin\u0074'(--'u')
• ( → print'\u0028'
• ) → print'\u0029'
• 0 - 9 → print~-<next int>

Here is the full list of programs for each character:

    print(--'!')
!   print(--'"')
"   print(--'#')
#   print(--'$')
$   print(--'%')
%   print(--'&')
&   print(--"'")
'   print(--'(')
(   print'\u0028'
)   print'\u0029'
*   print(--'+')
+   print(--',')
,   print(--'-')
-   print(++',')
.   print(--'/')
/   print(--'0')
0   print~-1
1   print~-2
2   print~-3
3   print~-4
4   print~-5
5   print~-6
6   print~-7
7   print~-8
8   print~-9
9   print~-10
:   print(--';')
;   print(--'<')
<   print(--'=')
=   print(--'>')
>   print(--'?')
?   print(--'@')
@   print(--'A')
A   print(--'B')
B   print(--'C')
C   print(--'D')
D   print(--'E')
E   print(--'F')
F   print(--'G')
G   print(--'H')
H   print(--'I')
I   print(--'J')
J   print(--'K')
K   print(--'L')
L   print(--'M')
M   print(--'N')
N   print(--'O')
O   print(--'P')
P   print(--'Q')
Q   print(--'R')
R   print(--'S')
S   print(--'T')
T   print(--'U')
U   print(--'V')
V   print(--'W')
W   print(--'X')
X   print(--'Y')
Y   print(--'Z')
Z   print(--'[')
[   print(++'Z')
\   print(--']')
]   print(--'^')
^   print(--'_')
_   print(--'`')
`   print(--'a')
a   print(--'b')
b   print(--'c')
c   print(--'d')
d   print(--'e')
e   print(--'f')
f   print(--'g')
g   print(--'h')
h   print(--'i')
i   System.out<<--'j'
j   print(--'k')
k   print(--'l')
l   print(--'m')
m   print(--'n')
n   System.out<<--'o'
o   print(--'p')
p   System.out<<--'q'
q   print(--'r')
r   System.out<<--'s'
s   print(--'t')
t   'prin\u0074'(--'u')
u   print(--'v')
v   print(--'w')
w   print(--'x')
x   print(--'y')
y   print(--'z')
z   print(--'{')
{   print(--'|')
|   print(--'}')
}   print(--'~')
~   print(++'}')

Pyth

Calculating score soon.

General format:

C<char-code>

Exceptions:

<space> - d
" - N
0 - Z
1-9 - h<n-1>
a - hG
z - eG
d - @G<3-T>
y - ePG
{ - h`H
} - e`H