I have been creating a Smalltalk variant just for the it and that i question what will be a fellow stackoverflowers choice if this involves focusing on a back-finish. They were my current factors:

.Internet, JVM: Both of these VM's mostly are for statically typed languages and that i assume it might be quite tough to target this type of dynamic language like smalltalk.

Python (as source code): Appears to become the easiest way. Also it might be better basically could emit Python bytecode but it is not well recorded as other VM's AFAIK (Have to search Python's source code for particulars!).

Self made interpreter: Unthinkable as it is a real drag :-)

LLVM, NekoVM, Parrot are also options I am looking at. An amount become your undertake this?

Don't discount .Internet or even the JVM so rapidly. Dynamic languages are now being produced for both (e.g. Groovy, JRuby, Jython around the JVM IronRuby, IronPython on .Internet) and .Internet is attaining the "DLR" - Dynamic Language Runtime. (See Jim Hugunin's blog for additional particulars.)

I'd pick the JVM, but due to the fact I am acquainted with it.

Objective causes of JVM are: primary platforms are supported, many libraries and good performance (inside the options you've trained with might have the very best performance).

.Internet is most effective on Home windows. When you purchase it, you need to test on Mono to become more platform-neutral.

Python appears the ideal choice too. However I think for that JVM more libraries can be found.

Parrot is for me too fresh, it requires a while to mature. But a fascinating alternative for future years.

Another options are a new comer to me, I'll have a look their way.

Parrot is actually awesome, even when they haven't shipped any "real" code yet. Consider the project's for entertainment, that should not prevent you :D.

As you are attempting to implement Smalltalk, have you considered among smalltalk-inspired VMs for Ruby like YARV as well as rubinius. Both of them are smalltalk-inspired and goal to become high-performance. YARV would be the new standard Ruby VM.

One adavantage of utilizing Parrot is it ships with a lot of example languages, together with a Smalltalk variant known as ChitChat. To help you use that like a mention of the observe how another person has implemented an identical language on Parrot.

You might like to take a look at PyPy -- although this project is available to implement the Python language in (a subset of) Python, the approach they're taking enables multiple front-finishes and multiple back-finishes (including CLR, JVM, LLVM, C, as well as Smalltalk and JavaScript, I believe). For instance, focus on the JIT continues to be done using Prolog because the front-finish language and CLR because the back-finish. So you may join the party to implement Smalltalk and then uncover you've also assisted another person implement Prolog not understanding it... :-)

Factor (http://factorcode.org/) may offer some helpful features with this.

JVM as first choice. It might permit a large library support in the the first day. Observe how that achieved positive results Clojure.

Also, LLVM may be interesting choice, but I am unsure how "proven" it's, since i have can't possess a mature language implementation with LLVM after sales.

I'd avoid .Internet. It might allow it to be harder to collect community and support round the your brand-new language, and you will require it soon. Also, it's not mix-platform.

Whatever you decide, become familiar with a great deal in so doing.