ribbit

Here is another tiny and highly portable Scheme that I submitted along with this: https://github.com/udem-dlteam/ribbit https://arxiv.org/abs/2310.13589 Ribbit: A portable, compact and extensible Scheme implementation to 25 targets. R4RS compliant. https://news.ycombinator.com/item?id=49733898

Compact language implementations are increasingly popular for use in resource constrained environments. For embedded applications such as robotics and home automation, it is useful to support a Read-Eval-Print-Loop (REPL) so that a basic level of interactive development is possible directly on the device. Due to its minimalistic design the Scheme language is particularly well suited for such applications and several implementations are available with different tradeoffs. In this paper we explain the design and implementation of a compact Scheme system that supports a REPL, is extensible and has a 4 KB executable code footprint. https://github.com/udem-dlteam/ribbit https://arxiv.org/abs/2310.13589 Abstract. The Ribbit system is a compact Scheme implementation running on the Ribbit Virtual Machine (RVM) that has been ported to a dozen host

I've been working on a similar (ish) project for a while: Ribbit (https://github.com/udem-dlteam/ribbit). Supports a full R4RS REPL (with tail-calls) in the same sizes as Lispy (8Kb for JavaScript and 6.5Kb for x86)!

Location: Montréal, Canada Remote: Yes Willing to relocate: For the right opportunity Technologies: Compilers, virtual machines, Scheme, LLVM, Python, language design, language runtime, garbage collection Résumé/CV: https://oestoleary.com/leonard_oest_oleary.pdf Email: See website (https://oestoleary.com) or résumé Previously a Production Engineer at Meta, I have spent the last ~5 years building compilers and computer languages. I recently submitted my Master’s in compiler design, with research on memory management, garbage collectors and virtual machines published at PLDI and ICFP workshops. I'm passionate about anything touching a compiler. Here are some projects I'm particularly proud of: - Lead maintainer of Ribbit, a highly portable and compact Scheme compiler supporting over 25 target languages (including C, x86, POSIX-Sh

> IIRC (might be wrong here) we had full support for JS, C, Python and Scheme from the start I'm pretty sure we had support for JS, C, Python from the beginning as well. Then Scheme, posix shell, assembly came along for the ride. > I'm unsure how support was kept throughout the versions but I know a much larger set of languages now support the runtime, at least for a subset of the features One thing that really helped is CI testing! All the RVMs (the 16 targets) are now fully tested at each PR (https://github.com/udem-dlteam/ribbit/actions)

I don't know about the specific motivations for this project, but if you're curious about why work like this might have serious real-world relevance beyond scratching an itch, idle exploration, or meeting a research paper quota, you can look to similar work and literature: GNU Mes: https://www.gnu.org/software/mes/ Stage0: https://bootstrapping.miraheze.org/wiki/Stage0 Ribbit (same authors): https://github.com/udem-dlteam/ribbit stage0-posix: https://github.com/oriansj/stage0-posix Bootstrappable Builds: https://bootstrappable.org/ See also this LWN article about bootstrappable and reproducible builds: https://lwn.net/Articles/841797/ It contains a plethora of interesting links.

And Ribbit: https://github.com/udem-dlteam/ribbit.

https://github.com/udem-dlteam/ribbit And https://piumarta.com/software/maru/ Are two good examples. Maru is interesting in that it can implement a full-fat language/os/vm/compiler in under 2kloc Bluebottle is another barbecues and up OS: https://github.com/btreut/a2

the code is very cryptic: for example the go source: https://github.com/udem-dlteam/ribbit/blob/main/src/host/go/... the C one has better comments, I imagine that's the reference implementation? https://github.com/udem-dlteam/ribbit/blob/main/src/host/c/r...

> No dynamic memory allocation = no garbage collector, no non-deterministic allocation/deallocation, no write barriers, no out-of-memory possibilities, no fragmentation. For a surprisingly large class of programs, this is a great situation! I know you know this already, but your statement is a little too broad. Those problems all still exist, but are greatly reduced. Data structures still need to be compacted, caches evicted, scratch space cleared, etc. It is just that one class of intractable issues gets removed when dynamic memory allocation goes away. On a side note, have you seen this? https://github.com/udem-dlteam/ribbit https://www.youtube.com/watch?v=A3r0cYRwrSs an extremely compact VM for a version of R4RS.

Ribbit is an R4RS implementation that is extremely compact. The video is only 15 minutes and worth a watch. https://github.com/udem-dlteam/ribbit https://www.iro.umontreal.ca/~feeley/papers/YvonFeeleyVMIL21... https://www.youtube.com/watch?v=A3r0cYRwrSs

Code looks very cool There's even a Python implementation with 1 space indentation :) https://github.com/udem-dlteam/ribbit/blob/main/src/host/py/...