Ruby, 9×8 (72)

  3 ;p  
 p|p =p 
p || p=p
 ;p|p|p;
;p=p ||0
 ;p   p;
2 ||p =p
  00; p 
     1  

A bit longer than the other solution, but at least this solution doesn't depend on any implicit printing or rule abuse. For all four rotations, the full code is parsed and other than some short-circuiting, all of it is executed. Surprisingly, there's absolutely no symmetry in the code

This solution relies on the fact that it's still possible to call the p function (which is used to print the numbers) even if a variable with the same name has already been defined. For example, something like p p calls the function p with the variable p as argument (thus, printing the value of p).

Explanation for some of the common expressions used in the code:

• p: As mentioned above, this is either a function call or a variable. When the variable is not defined, this calls the function p without arguments, which does nothing and returns nil.
• p p: Prints the variable p.
• p|x: When p is the function, this is identical to nil|x, which returns true/false depending on the value of x. If p is an integer, it's bitwise or. Either way, this statement has no side effect.
• p=p||x: Effectively the same as p||=x (conditional assignment) with the advantage of being syntactically valid and a no-op when reversed.

Symmetric version (9×10 = 90)

    p    

  0 * 0  
  00100  
  0||2* p
p *0||0  
  00300  
  0 * 0  

    p    

This is the shortest symmetric solution (C₂ when ignoring the numbers to print) I could come up with.

Test script

Here's a test script to verify the code above (the # at the line ends have been added so that the whitespace doesn't get stripped and are removed before execution):

rotate=->s{s.split($/).map{|i|i.chars.reverse}.transpose.map(&:join).join($/)}

s=<<EOD.gsub(?#,"")
  3 ;p  #
 p|p =p #
p || p=p#
 ;p|p|p;#
;p=p ||0#
 ;p   p;#
2 ||p =p#
  00; p #
     1  #
EOD


puts ">>> 0°"
eval s
puts ">>> 90°"
eval rotate[s]
puts ">>> 180°"
eval rotate[rotate[s]]
puts ">>> 270°"
eval rotate[rotate[rotate[s]]]

Pyth, 9 characters (3x3)

0 1

3 2

In pyth, everything is printed by default, unless it is preceded by a space. Lines after the first line are for user input, and are not evaluated in this program.

Another way to get 9 characters:

"0"
3 1
"2"

Pyth 1.0.5, 4 characters

While recent changes to pyth have made 2 digit numbers harder to generate (A change that I am considering reverting), older versions of Pyth have easy two digit number generation, which, combined with the implicit printing and the fact that all lines but the first are ignored, gives the following solution:

32
41

Prints 32,21,14,43.

GolfScript, 4 (2x2)

43
12

Prints 4312 which is 0 (mod 4). The rotations print 3241 (1 mod 4), 2134 (2 mod 4), and 1423 (3 mod 4).

Prompted by:

If you wish you may output other legal "mod 90°" values instead of 0 1 2 3. So 8 is fine instead of 0, and -1 is fine instead of 3, etc.

There are actually many sets of numbers for which this works. I found these with this Python program:

def f(a,b,c,d):
    return int("%i%i%i%i"%(a,b,c,d))
for a in range(10):
    for b in range(10):
        for c in range(10):
            for d in range(10):
                candidate = f(a,b,c,d) % 4 == 0
                candidate &= f(b,d,a,c) % 4 == 1
                candidate &= f(d,c,b,a) % 4 == 2
                candidate &= f(c,a,d,b) % 4 == 3
                if candidate:
                    print("%i, %i, %i, %i"%(a,b,c,d))

GolfScript, 9 (3x3)

0}1
} }
3}2

Sort of abusing the rules. The } happens to end the program if there is no matching {, and the contents of the stack are printed at program end.

BASIC, 64

Won't win, but here it is anyway. (Tested in Chipmunk Basic)

?0:END:?
:::::::1
D:::::::
N::::::E
E::::::N
:::::::D
3:::::::
?:DNE:2?

Note: ? is shorthand for PRINT in various dialects of BASIC. Although there are lots of syntax errors in the code, the END statement in the first line prevents them from being seen by the interpreter.

Befunge, 16

0.@1
@@@.
.@@@
[email protected]

Explanation: Digits from 0 to 9 push the corresponding number onto the stack, . pops a value from the stack and prints it as an integer, and @ ends the program.

(tested here)

Aheui, 8

바몽희뷸
뷷희몽반

Since Aheui does not have a letter that pushes 1 onto the stack, I decided to print 0, 5, 2, and 3.

Explanation: 바 and 반 push 0 and 2, respectively, onto the stack and moves the cursor right by one character. 뷸 and 뷷 push 5 and 3, respectively, onto the stack and moves the cursor down by two characters. 몽 pops and prints the number in the stack and moves the cursor up by one character. 희 terminates the program.

JavaScript, 4

03
12

When you execute this program (or a rotation of this program) in a javaScript console, only the last line is evaluated and echoed in the console.

So:

12 modulo 4 == 0
01 modulo 4 == 1
30 modulo 4 == 2
23 modulo 4 == 3

Here are all the similar 2x2 programs that work too:

03
12

03
16

03
52

03
56

03
92

03
96

07
12

07
16

07
52

07
56

07
92

07
96

43
12

43
16

43
52

43
56

43
92

43
96

47
12

47
16

47
52

47
56

47
92

47
96

83
12

83
16

83
52

83
56

83
92

83
96

87
12

87
16

87
52

87
56

87
92

87
96

In other terms,

ab
cd

where a is in [0,4,8], b is in [3,7], c is in [1,5,9], and d is in [2,6]