Here's one from (the younger) me:

  =======================
  Description
  =======================
  
  24-bit words (no bytes, so no endianness)
  
  <op> 5 <dir/ind> 1 <r1/cond> 3 <r2> 3 <val> 12
  r2 = 0 means zero value
  
  dir/ind:
  
  0 dir
  1 ind
  
  cond:
  
  001 eq
  010 lt 
  1000 gt
  
  8 regs
  
  r0 = PC
  
  op:
  
  00x xx0 - type independent
  01x xx0 - bitwise
  10x xx0 - integer
  11x xx0 - floating-point
  
  ST 00 ; store (ignores ind/dir)
  LD 02 ; load/move
  BR 04 ; branch (rel/abs)
  
  SL 20 ; shift left
  SR 22 ; shift right
  SA 24 ; shift right arithmetical
  OR 26 ; or
  AN 30 ; and
  OX 32 ; or exclusive (xor)
  NO 34 ; not
  
  AD 40 ; add
  SB 42 ; subtract
  MU 44 ; multiply
  DV 46 ; divide
  CP 50 ; compare
  
  FA 60 ; add
  FS 62 ; subtract
  FM 64 ; multiply
  FD 66 ; divide
  FC 70 ; compare
  
  example:
  
  LD r1, [4096] ; |03121000|
  AD r1, 1      ; |40100001|
  LD r2, r1     ; |02210000|
  SB r2, 33     ; |42200033|
  BR le, exit   ; |04300001|
  ST r1, [4096] ; |01201000|
  exit: .
  
  floating-point format - normalized:
  
  <sign> 1 <exp> 7 <mantissa> 16 + 1 implicit
  
  literals:
  
  decimal: -8,388,608 ... 8,388,607 (can use commas)
  binary (in octal): |42200033|
  floating-point: 1.23e-45
  character sequence 'abc' (3 characters per word)
  
  r0 can be used as a temporary
  
  =======================
  Implementation
  =======================
  
  #include <stdio.h>
  #include <ctype.h>
  
  #define n 1024
  #define trace(op) fprintf(stderr, "%04o %s\n", r0, #op)
  
  enum {
         ST = 000, /* store (ignores ind/dir) */
         LD = 002, /* load/move */
         BR = 004, /* branch (ignores ind/dir) */
  
         SL = 020, /* shift left */
         SR = 022, /* shift right */
         SA = 024, /* shift right arithmetical */
         OR = 026, /* or */
         AN = 030, /* and */
         OX = 032, /* or exclusive (xor) */
         NO = 034, /* not */
  
         AD = 040, /* add */
         SB = 042, /* subtract */
         MU = 044, /* multiply */
         DV = 046, /* divide */
         CP = 050, /* compare */
  
         FA = 060, /* add */
         FS = 062, /* subtract */
         FM = 064, /* multiply */
         FD = 066, /* divide */
         FC = 070 /* compare */
  };
  
  int main() {
         static int b[n];
         /* load image */
         int c, *p, s, z;
         static int r[8];
         for (s = 21, p = b; p < b + n && (c = getchar()) > 0;)
                 if (isdigit(c) && c <= '7') {
                         *p |= (~0x30 & c) << s;
                         if (s)
                                 s -=3;
                         else
                                 s = 21, ++p;
                 }
         /* run image */
         c = 7;
         while (r[0] >= 0 && r[0] < n) {
                 int i, o, d, x, y, v, r0;
                 i = b[r0 = r[0]++]; /* inc PC */
                 o = (i >> 19 & 31) << 1;
                 d = !(i >> 18 & 1);
                 x = i >> 15 & 7;
                 y = i >> 12 & 7;
                 v = ((i << 20) >> 20) + (y ? r[y] : 0); /* assuming 32-bit ints */
                 switch(o) {
                         case ST: b[v] = r[x]; trace(ST); break;
                         case LD: r[x] = d ? v : b[v]; trace(LD); break;
                         case BR: if (x & c) r[0] += v; trace(BR); break;
                         case SL: r[x] <<= v; c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(SL); break;
                         case SR: r[x] >> v; c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(SR); break;
                         case SA: r[x] >> (unsigned) v; c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(SA); break;
                         case OR: r[x] |= (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(OR); break;
                         case AN: r[x] &= (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(AN); break;
                         case OX: r[x] ^= (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(OX); break;
                         case NO: r[x] = ~r[x]; c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(NO); break;
                         case AD: r[x] += (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(AD); break; 
                         case SB: r[x] -= (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(SB); break;
                         case MU: r[x] *= (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(MU); break;
                         case DV: r[x + 1] = r[x] % (d ? v : b[v]); r[x] /= (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(DV); break;
                         case CP: c = r[x] == (d ? v : b[v]) ? 1 : r[x] < (d ? v : b[v]) ? 2 : 4; trace(CP); break;
                         case FA: trace(FA); break; /* TODO */
                         case FS: trace(FS); break; /* TODO */
                         case FM: trace(FM); break; /* TODO */
                         case FD: trace(FD); break; /* TODO */
                         case FC: trace(FC); break; /* TODO */
                 }
         }
         /* print image */
         for (z = 0, p = b; p < b + n; ++p) 
                 if (*p) {
                         int m;
                         if (z) {
                                 puts("00000000");
                                 if (z > 3)
                                         puts("........");
                                 else if (z > 1)
                                         puts("00000000");
                                 if (z > 2)                      
                                         puts("00000000");
                                 z = 0;
                         }
                         for (s = 21, m = 7 << s; m; m >>= 3, s -= 3)
                                 putchar(0x30 | (*p & m) >> s);
                         putchar('\n');
                 }
                 else
                         ++z;
         return 0;
  }
  
  =======================
  Example: Bubble Sort
  =======================
  
  0000 LD r1, 10              ; n = 8        02100010
  
  repeat:
  0001 SB r1, 1               ; n = n - 1    42100001
  0002 LD r2, 0               ; i = 0        02200000
  0003 LD r3, 0               ; f = false    02300000
  
  compare:
  0004 LD r4, [r2 + data]     ;              03420021
  0005 CP r4, [r2 + data + 1] ;              51420022
  0006 BR le, next            ;              04300004
  
  0007 LD r5, [r2 + data + 1] ; swap         03520022
  0010 ST r5, [r2 + data]     ;              00520021
  0011 ST r4, [r2 + data + 1] ;              00420022
  0012 LD r3, 1               ; f = true     02300001
  
  next:
  0013 AD r2, 1               ; i = i + 1    40200001
  0014 CP r2, r1              ; i < n ?      50210000
  0015 BR lt, compare         ;              04207766
  
  0016 CP r3, 0               ; f = false ?  50300000
  0017 BR eq, 2000            ; exit         04102000
  0020 BR   , repeat          ;              04707760
  
  data:
  0021 9                      ;              00000011
  0022 8                      ;              00000010
  0023 5                      ;              00000005
  0024 6                      ;              00000006
  0025 3                      ;              00000003
  0026 7                      ;              00000007
  0027 2                      ;              00000002
  0030 1                      ;              00000001