loxcraft VS rust-gc

There are many solutions for these problems. For an example, see this implementation: https://github.com/ajeetdsouza/loxcraft/blob/main/src/vm/object.rs and https://github.com/ajeetdsouza/loxcraft/blob/main/src/vm/gc.rs:

loxcraft started off as yet another implementation of Crafting Interpreters, but I decided to take it up a notch and implement:

rust-langdev has a lot of libraries for building compilers in Rust. Perhaps you could use these to make your implementation easier, and revisit it later if you want to build things from scratch. I'd suggest logos for lexing, LALRPOP / chumsky for parsing, and rust-gc for garbage collection.

There's nothing stopping you from doing that in Rust. See rust-gc for an example of a GC implemented in Rust. Another example is mozjs, which is Rust bindings to SpiderMonkey. The GC there is implemented in C++, but it shows how you'd structure wrapper types for GC'd pointers in Rust so that you can use them safely, even with all the "ugliness" of a browser-grade GC.

One can have a GC as a library, https://github.com/Manishearth/rust-gc

The ones I am aware of are gc and broom. None will be as simple to use as the one in old Rust as userland implementations don't have the benefit of first-class integrated compiler support.

Rust has rust-gc, which is an attempt to add opt-in GC over Rust's more traditional automatic memory management. It's a neat project, but I'm not sure where it's actually being used.

Inb4 "already exists": the question is about making it convenient, not just imlementing the behavior.

There is also a library implementation of garbage collection for Rust, made by someone from the Rust core team.

Yep! And I'd actually fully agree those are garbage collection, there's also a crate by Manish which does """real""" garbage collection—https://github.com/Manishearth/rust-gc

I don't know that I'd say it "works" - it's never a technique I've needed to use myself, but it's the approach taken by e.g. https://github.com/Manishearth/rust-gc

Anyway, I found something recent that implements "rc" but in terms of tracing: https://github.com/Manishearth/rust-gc/ . Maybe useful for projects involving graphs of objects.