Gerbil (built on Gambit) has a really impressive-looking standard library (probably the biggest reason most Schemes don't get great adoption). It's got builtin JSON libraries, HTTP server and client libraries, protocol buffers, database drivers (builtin MySQL and PostgreSQL), etc.
Actually looking at the libraries on this page for Gauche and comparing it to Gerbil, Gerbil seems way more practical for the kind of web/data work I normally do.
The only big extensions this page lists on top of R7RS libraries (which are fine for programming but don't include much for typical development work on web/data/etc) seems to be for programming desktop apps.
So for me the most practical Schemes (because of built in libraries) I can think of are Gerbil or Racket. But it's been a while since I've looked into Schemes.
Most Schemes have a very large standard library, but you have to know that the standard library is referred to by SRFI -- a bunch of random numbers rather than names.
They don't list docs either. You have to know that you must go to the SRFI website and look up the API from the spec itself.
I believe this has single-handedly done more to hurt scheme than any other thing the language has done.
I'll have to give Gerbil a second look. I've written some small programs with Chicken Scheme (which honestly should be in any practical scheme list IMO) and while the standard library is not that big (my pet peeve as well with most languages) I really liked a scheme I could statically compile into a binary.
For my project I also wanted to have some untrusted user code execution sandbox, and found such libraries for both Chicken and Guile. While the later one had better/fine grained execution environment options, Chicken won because of the possibility to easily compile.
From my experience working on Schemepunk, Gerbil has a lot of interesting functionality but it's also very immature. Frequently modules will not quite match their documentation, or a simple mistake will cause a segfault. I wouldn't feel comfortable using it in production for something internet-facing.
iirc I wanted to port it to Guile originally but there was one major bug in Guile R7RS support that was stopping me. I think it was something about the way imports were named. I submitted an issue but it languished for at least half a year, I think because the dev in charge of that part of the code was busy with something else and not actively working on Guile. I haven't looked at the issue in a couple years, maybe it's fixed now.
Doing a little bit of digging into the Gauche manual would have led you to a listing of the various utility libraries that it offers: http://practical-scheme.net/gauche/man/gauche-refe/Library-m... As you can see it is pretty extensive, and could likely handle most of the needs you mentioned in your comment. I would call this pretty “practical”.
The idea was to make a standard library as widely compatible with existing Schemes as possible. If it worked, then I could write code (with this library) that was "just Scheme", not a particular implementation, and would run equally well on any Scheme. And it would make bootstrapping new Scheme implementations easy: all you'd need is a bare minimum of R7RS Small functionality, and Schemepunk could do the rest.
I haven't worked on it for a while, since I've moved on to other things. But I still think the idea has a lot of potential.
Most of the content on this page looks like it could be 20 years old with minor updates, which isn't so practical, IMHO.
If you want to start with practical Scheme, consider starting with one that has a community actively using it (and growing the open source libraries, and creating reason for the core to be maintained and maybe developed).
The most obvious one is Racket, and there's also Chicken, Gerbil, Guile, Gambit, and a bunch of others. Beware: there's also a ton of personal side projects (making your own Scheme is a rite of passage), and a lot of abandoned things (often great, but still abandoned).
The ecraven benchmarks though are a good test of completeness (can the implementation actually run all the tests?) and quality (what is the ranking of the implementation): http://ecraven.github.io/r7rs-benchmarks/.
I tried to get started with Guile a few months ago, to write a little command line app. I'll admit, I got pretty lost trying to figure out libraries/modules/how to use R7RS etc... This looks like a good getting started, though I'm not sure if Guile is still the right choice.
Gerbil seems to have about as much standard library features as Racket does. Or excels in different areas (web and data). Gerbil is also "faster" than Racket in the ecraven benchmarks.
So I think it gives Racket a reasonable run for the money.
Honest question as someone who came to Lisp via Racket seven years ago and has never touched Scheme: why is Scheme so great that any deviation from it is undesirable?
There are advantages to programming to a language specification and only writing a minimal amount of implementation-specific code. For one thing it makes the presuppositions of your program more explicit than if you’re writing in a language where the sole implementation is the specification. However, scheme has traditionally focused on a minimal standard (partly as a reaction to Common Lisp) and this has made “standard only” scheme less practical than the equivalent in Common Lisp or C/C++
Never used any Scheme, so I wanted to make sure I interpret that site correctly.
It provides packages written in any Scheme, which you can use from any other Scheme (which works because they follow the same specification (R6RS/R7RS))?
Basically, but there corner cases too, if a package uses SRFIs, not every implementation will support them properly. For the most part, it’s like you described but it’s worth running the tests on every new package you work with, in my experience.
https://cons.io/reference/
Actually looking at the libraries on this page for Gauche and comparing it to Gerbil, Gerbil seems way more practical for the kind of web/data work I normally do.
The only big extensions this page lists on top of R7RS libraries (which are fine for programming but don't include much for typical development work on web/data/etc) seems to be for programming desktop apps.
So for me the most practical Schemes (because of built in libraries) I can think of are Gerbil or Racket. But it's been a while since I've looked into Schemes.