First off, does the x86 solaris binary for SBCL work? You can bootstrap off that if it does.

>My understanding is that Scheme is not 100% LISP compatible, but even worse, that it runs as bytecode on a Java virtual machine. As soon as I see a language running on a virtual machine of any kind, I'm done. That won't enter my systems or my network. If I cannot compile it into straight machine code binary executable, that's it, it's out of the window, and never to return. Not on my watch! Is my finding correct, or is there a Scheme to ELF machine code binary executable compiler out there?

...ummm... wow. It's history time.

Lisp isn't a language or a standard. It's a family of languages. When you say Lisp, you're talking about Common Lisp, which is one of the two popular lisp standards today. The other is Scheme RnRS, with R5RS and R7RS being the most widely implemented. Scheme isn't Common Lisp compatible, as it is a totally different language, although still a Lisp. Some people believe that Scheme shouldn't be regarded as a lisp, but those people are crazy.

Scheme prides itself on minimalism, originating in academia, and designed for PL research and education, and so, much like POSIX, every implementation extends it in a different direction. Some Schemes are suitable for Real Work, others are not.

As scheme is a standard, it has been implemented for a variety of architectures. While it does run on the JVM, that implementation isn't very good. You're probably thinking of Clojure, which is JVM.

There are several schemes that compile to native code. Gambit and Chicken are the most popular. While Guile uses ELF, it uses it as its bytecode format, and while native compilation is planned, we probably won't get it for a good few years. Chibi is bytecode, and will probably stay that way, although it has a decent FFI. If you can live without native compilation, Guile, at least, is worth looking at.

As for Chicken vs Gambit, it's pretty evenly stacked. I know Chicken better than I know Gambit, but I'll try to give a good comparison:

FOR CHICKEN:
-Chicken uses Cheney-on-the-MTA compilation meaning that re-entrant continuations (think setcontext/setjmp but better) are no slower than any function call.
-Chicken has a really, really good library repository. For a scheme, anyway.
-Chicken has fairly good POSIX integration
-Previous versions of Chicken have definitely compiled on OpenSolaris.
-Chicken has an almost ungodly helpful maintainer and community, with active mailinglists and IRC.

AGAINST CHICKEN:
-Chicken isn't reentrant
-Chicken has no pthread support, only supporting fork(2) and pre-emptive coroutines.
-Chicken has a really good compiler. You'll see why this is a mark against it in a minute.

FOR GAMBIT:
-Gambit has compiler that generates really, really, really good native code.
-Gambit is, I think, reentrant
-Gambit has okay POSIX
-Gambit has Termite, which is erlang-style coroutines, in addition to a Chicken-like system. Guile is the only scheme I know that has pthread support, and it's not in this comparison.

AGAINST GAMBIT:
-Gambit's continuation implementation is slower and more limited than Chicken's.
-Even with BlackHole and SchemeSpheres, the two module sets it has, Gambit is behind Chicken in modules
-Gambit's FFI is harder to use than Chicken's.
-I don't know how well Gambit supports Solaris.