rust-gc VS ixy-languages

> Rust can not represent the vast majority of allocations

Do you mean cyclic types?

Rust being low-level, nobody prevents one from implementing garbage-collected types, and I've been looking into this myself: https://github.com/Manishearth/rust-gc

It's "Simple tracing (mark and sweep) garbage collector for Rust", which allows cyclic allocations with simple `Gc` objects. Can't vouch for that implementation, but something like this would be good for many cases.

Then use “tracing GC as a library” like [1] or [2]. I’m not saying there’s no use for tracing GC ever. I’m saying it shouldn’t be a language level feature and it’s perfectly fine as an opt-in library.

[1] https://github.com/Manishearth/rust-gc

[2] https://github.com/oilpan-gc/cppgc

I wonder if they explored using a Gc like https://github.com/Manishearth/rust-gc with Rust. I think that probably removes all the borrow checker / cycle impedance mismatch while providing a path to remove Gc from the critical path altogether. Of course the Rust Gc crates are probably more immature, maybe slower, than Go’s so if there’s no path to getting rid of cycles as part of down-the-road perf optimization, then Go makes more sense.

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.

> hardware

Sure x86 is an absolute mess, but I don't think it's a primary bottleneck. High end x86 cpus still beat high end ARM cpus by a significant margin on raw performance.

> Languages unlock performance for the masses. Javascript will never be truly fast because it doesn't represent the machine.

C# and Go are already really fast (https://github.com/ixy-languages/ixy-languages) and at this point you can compile most things to WASM.

Not really, here it is winning hands down over Swift's ARC implementation.

https://github.com/ixy-languages/ixy-languages

You laugh, but ... https://github.com/ixy-languages/ixy-languages

GC'd languages are designed to leverage GCs, meaning they usually allocate a lot. Some of the more recent ones (C#, Go) have ways around it or to limit it, but in your average GC'd language you have to really bend yourself out of shape to limit allocations (IIRC the Ixy effort / study / thing never managed to make the Java hotpath allocation-free).

It's kind of funny when you see things like this project: https://github.com/ixy-languages/ixy-languages

like not-even-in-the-same-ballpark faster. In this realworld example (userspace network drivers in managed languages) JS manages about 20-30% of native code performance, python iirc is below 1%

- Support for generic-aware value types (struct vs. class) and low-level features like stackalloc: very valuable for high-performance scenarios and native FFI. See for instance https://github.com/ixy-languages/ixy-languages. In comparison, Java doesn't even have unsigned integers. Yes, Project Valhalla is coming someday.

As well, debatable to some folks, but: properties (get/set); operator overloading; LINQ > Java streams; extension methods; default parameters; collection initializers; tuples; nullable reference types; a dozen smaller features