So you want to learn scheme. You've found a website, maybe even a schemer or two, you've got some links, and now you want to start learning the language. 'Where do I download scheme?' you ask. You're expecting a website. You get a further question - 'which implementation do you want?'

The initial mild surprise is often followed by a sense of disorientation as it becomes evident that one has a choice of 25 different implementations on the 'very select' list at category-implementations alone. This disorientation often turns into frustration as one tries to write portable code, reasoning that interoperability is good.

The problem arises because, in a sense, Scheme isn't a language.

It's several languages.

To be more precise, to be accurately called Scheme, an implementation (an interpreter or a compiler) must implement a language conforming to one of the RnRS specifications, the latest one being R5RS. However, R5RS doesn't specify very much - there are a lot of things that a programmer of today would want or need which simply aren't there. There is no networking, for example, no module system, and even the facilities for manipulating strings are fairly limited.

The minimalist nature of RnRS scheme, plus other features of the language such as the simple syntax, mean that it is comparatively easy to implement scheme. As a result, there are many implementations. Many are really more toys than anything else, some are personal projects, a few are somewhat specialised. But a few of them are as fully-fledged general programming languages as anything else out there. Implementations that don't follow a RnRS or IEEE specification are refered to on #scheme-on-freenode as SINO? (Scheme in Name Only]].

A fully-fledged programming language is more than just the syntax and basic data-types - it's also the standard libraries. R5RS has less in the 'core language' than many other languages, and no standard libraries, so it often makes sense to think of the different implementations as being different languages, as they each have their own extensions to R5RS and their own standard libraries (there are also a set of standardized libraries independent of implementations and these are called SRFI's) . As they share the same minimalist core and often very much the same concepts and design methodologies, they are of course languages that are very similar to one another - much more similar than PHP is to Perl, or C++ is to Java, for example.

As someone starting to learn scheme, the best advice is to pick one of these implementations and stick with it.

A few 'don't worry's:

don't worry about writing code which conforms to R5RS alone. Unless you really want to implement your own string libraries.

don't worry about writing code that is portable between implementations. No seasoned schemer would try to write a stand-alone portable application, at most they might try to write portable libraries, but even this is quite difficult.

don't worry about being tied to a particular implementation. Once you get used to programming in Scheme, you'll find that your skills transfer to a new implementation very easily.

don't worry too much about your choice of implementation. It's not a decision for all time.

I dispute that "no seasoned schemer" would try to write a portable application. The conjure project is doing exactly that. Also, with projects like Spells and common-scheme, it is getting much easier to write portable code, be it libraries or applications.

Again, it often helps to think of the different implementations as different languages. You wouldn't expect to write 'portable scripting language code' that you could use in Python, Perl and PHP. So why would you expect to write code in Bigloo which will also run in Chicken? That it's possible (although difficult) to do this in some cases you should see as a bonus.

So, what should your first choice of implementation be, given that you are learning scheme?

Chicken is pretty feature rich, has a compiler and an interpreter and comprehensive libraries.

if you're using a Unix system, Gauche is a nice interpreted system with libraries that do a lot, including interfacing with the GTK GUI library.

Another implementation that plays well with Unix is scsh. This implementaion can be used with scripting and general unix programs.

SISC is an interpreter written in Java (but is surprisingly quick), and interfaces well with Java libraries.

PLT-Scheme has comprehensive libraries, and also includes the DrScheme GUI programming environment which has a focus on learners. If you're studying HtDP (quite a nice introduction for beginners) you'll want to use this one, as HtDP is intended for use with DrScheme.

Note that there are many other scheme implementations, and their omission here is in no way impugning their quality, or even their suitability for learners. The main purpose of the list is to give a short list of good recommendations to beginners.

Once you feel confident about programming in whichever Scheme you choose, you'll be in a much better position to tackle issues such as writing portable code and evaluating which implementation to use for a particular project, should you so desire.