salsa VS nanopass-framework-scheme

There are some excellent crates already in the Rust ecosystem (notably Salsa) for performing incremental computation, although they generally have different goals to Depends.

The content of that "Core Concepts" page sounds a lot like https://github.com/salsa-rs/salsa

I know of salsa, but I don't know if it can persist changes to disk (and my guess from looking at this issue is that it can't).

- the practical approach to this is to split workload into work units (aka tasks/queries/etc.) and then force information flow through centralized "request"/"query" APIs that automatically track dependencies - see https://github.com/salsa-rs/salsa for more information

This, and as pointed Salsa.

These guys might be of interest for you, they think a lot about incremental parsers. https://github.com/salsa-rs/salsa

salsa-rs authored by niko matsakis and other top rust devs

Some optimizations are not easy with Go. For example caching like in Rust Analyser Salsa Framework

How would this differ from salsa (https://github.com/salsa-rs/salsa) and the query-driven approach used by rustc?

Well, this compiler framework in scheme might be worth looking.

Some serious level Conway's Law. I mean multipass isn't bad. It composes well, it minimizes coupling, etc etc. It doesn't necessarily have to hit disk, any store could be used. I myself like multipass taken to an extreme in nanopass, but at the same time, I absolutely adore the single pass nature of Wirthian languages.

I am trying to use the nanopass framework with guile. I do not get that far :D I can't seem to figure out how guile's %load-path works.

I'd say Rust is the absolute best (by a considerable margin) for a production-ready implementation. For a compiler's course it should be a fine choice, but I'd also look at OCaml+Menhir or Scheme+nanopass as alternatives.