The only "scheme all the way down" implementation I know of is T. It's just too much of a pain to fully self-host the garbage collection code, and it's not exactly clear what the gain of doing so is.
The satisfaction of not depending on anything else other than some Assembly.
The moment another language gets used, like C, there is this misunderstanding among compiler design illiterates that without the use of that programming language, writing the compiler wouldn't be possible at all.
Well, that deleted comment was one of most respectable I've seen in a while. You were accurate about its features but maybe missed the justification: it was a replacement for C in terms of low-level use and performance (ideally). That made typical Scheme features impossible. Additionally, it was a critical part of VLISP project to mathematically verify a Scheme (Scheme48). They had to balance power and complexity carefully. So, it was efficient, gave you some Scheme power, and mathematically verified for correctness at the algorithm level for VLISP version.
So, not as nice as a full Scheme but great in other ways and used to write a Scheme.
I deleted it because I realized it was nonsensical. The T garbage collector was written in a subset of T, which is not a strict-subset of Scheme, as it uses system-level features.
It differs from T in that the VM is written in a different scheme dialect than the VM hosts, but it is still as much scheme-all-the-way-down as T was. It's also considerably safer than T as it will prevent you from doing some unsafe things and warn you about others (e.g. run-time closures).
Yeah that's about it. T was interesting too. I discovered it looking for PreScheme stuff actually. Jonathan Rees was involved in both with pg writing a T essay. So Google led me to it. The info on it looks to scattered for me to study easily like I did with PreScheme's all in one place stuff.
I though about a new incarnation of PreScheme. One would add memory safety like Rust's borrow checker. Carp LISP is already doing that. Another was to embed a version of C in it amenable to static analysis and KLEE-like tools with actual coding in Scheme with macros. Last was reviving VLISP using Magnus Myreen's LISP 1.5 or CakeML tools to verify it from LISP form to machine code. Then we'd have a semi-verified Scheme48 where you just trust the high-level code essentially.
