Use the Gambit interpreter to compile the minimal REPL to Python
and execute with python3:

  $ ./rsc -t py -l min repl-min.scm
  $ echo "(define f (lambda (n) (if (< n 2) n (+ (f (- n 1)) (f (- n 2))))))(f 25)" | python3 repl-min.scm.py
  > 0
  > 75025
  >

Alternatively one of the prebuilt versions can be used to achieve the
same result:

  $ ./rsc -t py -l min -c "node prebuilt/rsc.js"       repl-min.scm
  $ ./rsc -t py -l min -c "python3 prebuilt/rsc.py"    repl-min.scm
  $ ./rsc -t py -l min -c "runhaskell prebuilt/rsc.hs" repl-min.scm
  $ ./rsc -t py -l min -c "lua prebuilt/rsc.lua"       repl-min.scm
  $ ./rsc -t py -l min -c "scala prebuilt/rsc.scala"   repl-min.scm
  $ ./rsc -t py -l min -c "ksh prebuilt/rsc.sh"        repl-min.scm
  $ gcc -o rsc.exe prebuilt/rsc.c
  $ ./rsc -t py -l min -c ./rsc.exe                    repl-min.scm

Do the same but generating a JavaScript program:

  $ ./rsc -t js -l min repl-min.scm

Use Guile instead of Gambit to compile the REPL with type checking to C
and then compile RVM with gcc:

  $ RSC_SCHEME_INTERPRETER=guile ./rsc -t c -l max-tc repl-max.scm
  $ gcc repl-max.scm.c
  $ echo "(+ 1 (* 2 3))(car 0)" | ./a.out
  > 7
  > *** type error ()
  >

You can also use RSC_SCHEME_INTERPRETER=kawa to use Kawa Scheme or
RSC_SCHEME_INTERPRETER="csi -s" to use Chicken Scheme.

Use the Gambit compiler to compile the AOT compiler and then use it:

  $ gsc -exe -o rsc-gambit.exe rsc.scm
  $ ./rsc -t c -c ./rsc-gambit.exe repl-max.scm

Use the Chicken compiler to compile the AOT compiler and then use it:

  $ csc -o rsc-chicken.exe -O2 rsc.scm
  $ ./rsc -t c -c ./rsc-chicken.exe repl-max.scm

Use Ribbit as a pipeline compiler to compile the trivial program
`(putchar 65) (putchar 10)` to the corresponding compacted RVM code
(only 23 bytes of code):

  $ echo "(putchar 65) (putchar 10)" | gsi rsc.scm
  );'u?>vR6!(:lkm!':lkv6y

Use Ribbit as a pipeline compiler to compile the trivial program
`(putchar 65) (putchar 10)` to compacted RVM code and combine
it with the Python implementation of the RVM and execute it with python3:

  $ echo "(putchar 65) (putchar 10)" | ./rsc -l empty -t py | python3
  A

Compile the Ribbit AOT compiler using itself to get a JavaScript
version of the compiler and use it to compile a program:

  $ ./rsc -t js -l max rsc.scm   # compile rsc.scm to rsc.scm.js
  $ echo '(display "hello!\n")' > h.scm
  $ ./rsc -t py -l max -c "node rsc.scm.js" h.scm # use bootstrapped compiler
  $ python3 h.scm.py
  hello!

Bootstrap the Ribbit AOT compiler using a POSIX shell (note
that with ksh this takes over 5 hours on a fast computer and it
can take substantially more with other POSIX shells):

  $ ./rsc -t sh -l max -o rsc-bootstrap1.sh rsc.scm
  $ ./rsc -t sh -l max -c "ksh rsc-bootstrap1.sh" -o rsc-bootstrap2.sh rsc.scm
  $ echo '(display "hello!\n")' > h.scm
  $ ./rsc -t sh -l max -m -c "ksh rsc-bootstrap2.sh" h.scm
  $ ksh h.scm.sh
  hello!

  $ make check                     # check proper operation for all hosts

  $ HOST=c make check              # check proper operation for specific host

  $ HOST=py PY_HOST_INTERPRETER=pypy make check  # check proper operation for specific host and interpreter

  $ make check-bootstrap           # check that rsc bootstraps

  $ HOST=py make check-bootstrap   # check that rsc bootstraps with specific host

  $ HOST=sh SH_HOST_INTERPRETER=ksh make check-bootstrap # check that rsc bootstraps with specific host and interpreter

  $ make prebuilt                  # creates prebuilt artifacts for all hosts