I got all excited until I realized Harvey Mudd isn't Henry Mudd. This project would have had a lot more cred, in my book, if it were the latter.

This is only tangentially related but the best course that actually made real analysis click for me was from Harvey Mudd, seems like a solid university: https://www.youtube.com/playlist?list=PL04BA7A9EB907EDAF

Nice.

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