I'm interested in compilers, interpreters and languages.

What is the most interesting, but forgotten or unknown, language you know about? And more importantly, why?

I'm interested both in compiled, interpreted and VM languages, but not esoteric languages like Whitespace or BF.
Open source would be a plus, of course, since I plan to study and hopefully learn from it.

+18  A: 

I guess a lot depends on what you mean by 'non-mainstream'.

Would lisp count as non-mainstream?

Well, the title might not have been the best. But read my description -- lisp is neither forgotten nor unknown, I think.
It may not be forgotten, but I think it is one of those languages that most programmers will have heard of, but know almost nothing about.
+7  A: 

Boo targets the .NET framework and is open source. Inspired by Python.


The following set should keep you busy:

FORTRAN - Simplistic language that was popular for far too many years in engineering circles
LISP - The classic AI language. Prolog was better in my view, but LISP was more popular
Ada - Gave the world packages and generics and strict data typing.
ALGOL - Created to fix many of the problems with FORTRAN. It is the grandfather of C,

All were hugely influential languages in their day.

David Arno
These may be old, but they were main stream in their day. FORTAN was "the" language for engineering, LISP for early AI work, ADA was required by the DOD.
Jim C
If you don't have a concrete need I would stay away from FORTRAN. Today it is interesting mostly as an example what you can do wrong when designing a programming language. Though at the time it was developed nobody knew better ...
@starblue - ... don't let the fact that it's the *de facto standard* in numerous engineering branches, actively developed and heavily commercially backed, stop you from writing misinformations ...
+27  A: 

I love compilers and VMs, and I love Lua.

Lua is not as well supported as many other scripting languages, but from a mindset like yours I'm sure you will fall in love with Lua too. I mean it's like lisp, (can do anything lisp can as far as I know), has lots of the main features from ADA, plus it's got meta programming built right in, with functional programming and object oriented programming loose enough to make any type of domain language you might want. Besides the VM's code is simple C which means you can easily dig right into it to appreciate even at that level.

(And it's open-source MIT license)

Robert Gould
"can do anything lisp can as far as I know" -- can it treat programs as data, like Lisp can? I doubt it but I don't know.
of course, that's old hat for lua. It was originally designed with that specific purpose and later it became a true language.(Was a data language for a Brazilian petrochemical company). But now a days it can also be used as a great way to store data in a Json/Lisp way.
Robert Gould
Lua doesn't quite measure up to lisp macros.
True no they (macros) don't, but I wasn't completely aware of the Lisp macro system when I wrote this.
Robert Gould
Hmm... The number of upvotes would indicate this is a little too well known to be non-mainstream, yet everywhere else i go it's like "what's lua?"...
Lua is fairly well known in certain niches (e.g. popular as a game scripting language, and in general in C/C++), less so in others (a lot of .NET and Java devs have no idea about it. For my own take on it, I'd say that Lua is JavaScript done right - most of the same concepts, but cleaned up, and much cleaner syntax as well. The language is a pleasure to read, write and parse, and the implementation is a pleasure to use.
Pavel Minaev
Indeed, I also consider Lua to be Javascript done well. I like Javascript, but I keep wishing it was as simple and powerful as Lua.
Robert Gould
Also regarding "can do anything lisp can do", does it have call/cc? Does it have a MOP? If not could one be written in the language itself? Can it compile to machine code? Can you redefine read syntax within the language itself? Does the object system support before and after methods? Hygeinic macros?
Justin Smith
I think comparing Lua to Ada (for similarities, not diverging points) is quite a nonsense...
Yeah ADA was probably a bad choice
Robert Gould
LISP is a bad comparison too. Lua is more like Javascript then anything else. I'd say I prefer Lua over Javascript just as it doesn't have some of the weirdness, but lua has the annoying practice of using keywords where I'm used to using brackets.
Frank Schwieterman
+3  A: 

I recently learned of the existence of Icon from this question. I have since used it in answers to several questions. (1, 2, 3, 4)

It's interesting because of its evaluation strategy - it is the only imperative language I know that supports backtracking. It allows some nice succinct code for many things :)

Hugh Allen
+10  A: 

Smalltalk (see discussion linked here). Sort of the grand-daddy of the dynamic languages (with the possible exception of Lisp and SNOBOL). Very nice to work with and sadly trampled by Java and now the newer languages like Python and Ruby.

grand-daddy of OOP, not dynamic languages. yes, it's more dynamic than C++ or Java, but far from scripting languages. More like Objective C level of dynamism.
Disagree - Smalltalk is duck typed (you can even override #notImplemented to frig the behaviour of a missed method invocation). Ruby is quite heavily derived from Smalltalk and I don't see Python as being significantly more dynamic either.
It is a great language to learn OOP (in my opinion).
Jakub Narębski
The original designer of Smalltalk - Alan Kay actually said that he was very impressed by Lisp and borrowed some of the ideas from it. (In particular collection processing in Smalltalk is a little bit Lisp-like.)
Smalltalk is also a great place to learn agile methods. Both the extreme programming movement and the Scrum people came from the Smalltalk community. If you do Smalltalk be sure to try using SUnit to do TDD - just to find out what the Java and C# guys don't know they're missing.
@Javier it's not really surprising that Smalltalk and ObjC have similar dynamic object models, as ObjC was designed to add Smalltalk-style messaging to C :)
Graham Lee
+9  A: 

FORTH was a language designed for low level code on early CPU's. Its most notable feature was RPN stack based math operations. The same type of math used on early HP calculators. For example 1+2+3+4= would be written as 1, 2, 3, 4, + , +, +

Jim C
FORTH is a highly interesting language to implement - most of what looks like syntax in the language is actually convention. I implemented a subroutine threaded version on my own in a semester as an undergrad - totally worth it.
I am date myself here but my first exposure to FORTH was with a Commodore VIC20. It came on a cartridge!
Jim C
Strictly speaking, wouldn't the equivalent FORTH be: 4, 3, 2, 1, +, +, + Your version comes to the same result because addition is commutative, but it isn't *semantically* the same in terms of order of evaluation.
Daniel Spiewak
the correct FORTH is 1 2 + 3 + 4 +
In terms of the operations that are performed, 1 2 + 3 + 4 + is equivalent to 3 1 2 + 4 + + and 4 3 1 2 + + +
@Daniel an @TokenMacGuy That assumes that the order of evaluation of the infix expression is from left to right. In _the_ mainstream language (say C) that order is undefined, so no postfix expression is truly more correct than other.
+14  A: 

I would suggest having a look at Erlang - it's been getting a bit of press recently, so some of the learning resources are excellent. If you've used OO and/or procedural languages, Erlang will definitely bend your mind in new and exciting ways.

Erlang is a pure functional language, with ground-up support for concurrent, distributed and fault-tolerant programs. It has a number of interesting features, including the fact that variables aren't really variables at all - they cannot be changed once declared, and are in fact better understood as a form of pattern.

There is some talk around the blogosphere about building on top of the Erlang platform (OTP) and machine support for other languages like Ruby - Erlang would then become a kind of virtual machine for running concurrent apps, which would be a pretty exciting possibility.

Toby Hede
+5  A: 

Haskell and REBOL are both fascinating languages, for very different reasons.

Haskell can really open your eyes as a developer, with concepts like monads, partial application, pattern matching, algebraic types, etc. It's a smorgasbord for the curious programmer.

REBOL is no slouch either. It's deceptively simple at first, but when you begin to delve into concepts like contexts, PARSE dialects, and Bindology, you realize there's much more than meets the eye. The nice thing about REBOL is that it's much easier to get started with it than with Haskell.

I can't decide which I like better.

Gregory Higley
The coolest thing about Haskell is that the things you mentioned are only the tip of the iceberg! It gets better from there.
Jared Updike
Sadly, though, Haskell has a ridiculously steep learning curve. Better to wrap you head around something like ML or F# and then pick up Haskell.
+3  A: 
None of these are obscure, or forgotten. Most of them aren't even non-mainstream.
Justin Smith
+8  A: 

I've recently fallen in love with Ocaml and functional languages in general.

Ocaml, for instance, offers the best of all possible worlds. You get code that compiles to executable native machine language as fast as C, or universally portable byte code. You get an interpreter to bring REPL-speed to development. You get all the power of functional programming to produce perfectly orthogonal structures, deep recursion, and true polymorphism. Atop all of this is support for Object-Orientation, which in the context of a functional language that already provides everything OOP promises (encapsulation, modularization, orthogonal functions, and polymorphic recyclability), means OOP that is forced to actually prove itself.

I am looking forward to the time when more code is forced to prove itself.
The only thing I miss from OCaml are type classes. Otherwise it's awesome, particularly its structurally typed object model.
Pavel Minaev
Give F# a try, it's Ocaml with the full .NET library behind it.
+4  A: 

Modula-2 is the non-mainstream language that I've found most interesting. Looks mainstream, but doesn't quite work like what we're used to. Inherits a lot from Pascal, and yet is different enough to provide interesting learning possibilities.

Brian Knoblauch
What about Modula-3? Or Oberon?
Jonathan Leffler
Haven't had the pleasure of working with either of them yet. :)
Brian Knoblauch
Oberon was more of scholarly interest and not useful for practical applications.
Modula-2 was Wirth's peak, in my opinion.
Modula-2 was what should've been _the_ system programming language instead of C, IMO.
Pavel Minaev
Modula-2 is just Pascal improved. It's a decent enough pre-OO language, but hardly interesting.
+7  A: 

Try colorForth.

nice. totally counter-current, mind-numbingly simple and blazingly fast.
definitely production quality... although i'm not sure what to produce with it.
+6  A: 

PROLOG is a rule-based language with back-track functionality. You can produce very human-readable (as in prosa) code.

Peter Miehle
readable indeed. I once wrote a short fictional story in Prolog. it was somewhat boring, but not worse of what i used to write those days.
+23  A: 

I am a fan of the D programming language. Here is a wikipedia article and and intro from the official site.

Some snippets from the wikipedia article:

The D programming language, also known simply as D, is an object-oriented, imperative, multiparadigm system programming language by Walter Bright of Digital Mars. It originated as a re-engineering of C++, but even though it is predominantly influenced by that language, it is not a variant of C++. D has redesigned some C++ features and has been influenced by concepts used in other programming languages, such as Java, C# and Eiffel. A stable version, 1.0, was released on January 2, 2007. An experimental version, 2.0, was released on June 17, 2007.

on features:

D is being designed with lessons learned from practical C++ usage rather than from a theoretical perspective. Even though it uses many C/C++ concepts it also discards some, and as such is not strictly backward compatible with C/C++ source code. It adds to the functionality of C++ by also implementing design by contract, unit testing, true modules, garbage collection, first class arrays, associative arrays, dynamic arrays, array slicing, nested functions, inner classes, closures[2], anonymous functions, compile time function execution, lazy evaluation and has a reengineered template syntax. D retains C++'s ability to do low-level coding, and adds to it with support for an integrated inline assembler. C++ multiple inheritance is replaced by Java style single inheritance with interfaces and mixins. D's declaration, statement and expression syntax closely matches that of C++.

James Fassett
I've always wanted to get around to D, it should be a good language, but haven't made myself the time to.
Robert Gould
+1 Same as Robert Gould

Lava is a very interesting experimental language. It tries to incorporate some new concepts very useful for RAD. No practical use for it currently, but interesting none the less on the long term.

More practical but equally interesting is the (choose section, link too long to paste) language. It is a low level language like assembly, but much easier to learn, also claims to be cross/platform (not tested personally). Some very nice programs are developed in this language tough (look on website).

And of course some more common languages are useful to learn too and provide some interesting points:

  • ADA: nice concept, easy to learn to code well, also used in military projects, by NASA and by Boing.
  • Ruby: super easy to learn oo script language, a must for GUI testing and web development.
  • ERLANG: Mainly used by Ericsson for concurrent programming, also a functional language.
  • Logo: THE language for teaching primary school children (aka. Lisp for beginners).

Finally I recommend Context Free which is a language to create complex pieces of computer generated art.

+6  A: 

I find constraint languages interesting, but it is hard to know what constitutes forgotten or unknown. Here are some languages I know about (this is certainly not an exhaustive list of any kind):

  • Ciao, YAP, SWI-Prolog, and GNU Prolog are all Prolog implementations. I think they are all open source. Ciao, gnu prolog, and probably the others also, as is common in Prolog implementations, support other constraint types. Integer programming for example.
  • Mozart and Mercury are both, as I understand it, alternative logic programming languages.
  • Alice is more in the ML family, but supports constraint programming using the GECODE C++ library.

Drifting a little bit off topic....

  • Maude is an interesting term rewrite language.
  • HOL and COQ are both mechanized proof systems which are commonly used in the languages community.

Lambda-the-Ultimate is a good place to talk about and learn more about programming languages.

+4  A: 

I would have to say Scheme, especially in it's R6RS incarnation.

+1  A: 

Scheme immediately comes to mind, a nicer Lisp.

Also, I know that your question disqualifies esoteric languages, but consider INTERCAL. It has the facetious COME FROM operator (like GOTO, but placed at the jump destination, not the jump point). This operator seems strange, but can we say that its influence is seen in Aspect Oriented Programming? In AOP, advice is often specified at some external location, simply looking at the advised code does not always make control flow clear. Looking at the advice however informs the reader where control comes from.

Greg Mattes
+2  A: 

Well once it was called MUMPS but now its called InterSystems Caché

+1  A: 

Mathematica because it is a uniquely successful term-rewrite language (a completely different method of evaluating code!).

Cheers, Jon Harrop.

Jon Harrop
+1  A: 


It's Erlang made sense, it's beutifull and I'm in love. It's so unknown that it doesn't even have a wikipedia page!

Kit Sunde
+1  A: 

First answer - Scheme. It's not too widely used, but definitely seems like a solid language to use, especially considering the robustness of DrScheme (which in fact compiles Scheme programs to native binary code).

After that - Haskell is incredibly interesting. It's a language which does lazy evaluation right, and the consequences are incredible (including such things as a one-line definition of the fibonnaci sequence).

Going more mainstream, Python is still not really widely accepted in the business circles, but it definitely should be, by now...

+4  A: 

Have a look at Io at or Lisaac at: or Self at: or Sather (now absolutly forgotten) or Eiffel

Why here are a few reasons. Io is absolutly minimalistic and does not even have "control flow elements" as syntacit entities. Lisaad is a follow-up to Eiffel with many simplifications AFAIKT. Self is a followup to Smalltalk and Io has taken quite alot from Self also. The base thing is that the distinction between Class and Object has been given up. Sather is a anwer to Eiffel with a few other rules and better support for functional programming (right from the start).

And Eiffel is definitly a hallmark for statically typed OO-languages. Eiffel was the first langauge whith support for Design by contract, generics (aka templates) and one of the best ways to handle inheritance. It was and is one of the simpler languages still. I for my part found the best libraries for Eiffel.....

It's creator just has one problem, he did not accept other contributions to the OO field.....


+2  A: 

Ken Kahn's ToonTalk, a cartoon language with hard-core theoretic underpinnings:

Prograph: ... seems Prograph lives on as Marten:

Self's IDE was/is a thing of beauty, talk about Flow (in the Csíkszentmihályi sense)...

Overall, though, I'd have to say Haskell is the most interesting, for the potential adavances in computing that it represents.


I'll second the motion for Digital Mars D language. It has many of the productivity features of C# or Python, but the low level power of C. It's a nice language to learn some C concepts and also offers inline-assembler (for learning that) and support for many programming paradigms through contracts, delegates, and some reflection. It also has really nice array handling and full Unicode support.

Also if OCamL looks interesting to you, maybe check out F#, which is inspired by OCamL. It's a new .NET language that has only been release in "community previews" so far, but it looks pretty cool.

First, you should up-vote instead of posting a duplicate answer. Second, the question is not about good languages to learn, but good compilers/intepreters to learn _from_.
Sorry, still learning things here. My rep isn't high enough to upvote yet, so I'm writing more to get it high enough. I also think D and F# are good languages to learn from. F# and OCaml teach similar things about functional programming (but F# is .NET as well) and D is an interesting answer to "How can we do C++ better?"

The first major (non-BASIC) language that I learned was Dream Maker, from It's somewhat similar to C++ or Java, but it's largely pre-built for designing multiplayer online games. It's very much based on inheritance. It's an intersting language especially as a starting language, it gets gratifying results quicker, and lets be honest, most people who are first learning to program are interested in one thing... games.

+1  A: 

I find Factor, Oz and OCaml quite interesting. In fact, I have started using Factor for personal projects.

+1  A: 

Rebol of course ! It's so simple but so powerfull learn it at

Yeah, it's cool. Done by Carl Sassenrath, who wrote Amiga's great multitasking kernel then went on to Apple for awhile.

Have you heard of the O.H.R.RPG.C.E. game engine?

How about the compiled (!) language used to "script" games in?

Just for starters, spaces are stripped by the compiler. Not consecutive spaces, all spaces. Writing "walk hero north" is the same as "walkheronorth" and "wa lkhe ron rt h".

I haven't used it in a long time, and many of the things I've complained about before (such as defining parameters at the very top of your source code for every function, then putting the functions themselves) have been fixed.

Also, I just wanted to mention it again, yes, you have to compile scripts before you can import them into your game, despite the fact that there's no reason for the game editor itself to not contain a compiler.

+3  A: 

I can't believe Logo is so forgotten. Ok, it's Logo. Sort of like lisp, but with slightly uglier syntax. Although working with lists in Logo, one encounters the delightfully named 'butfirst' and 'butlast' operations. =P

My girlfriend is currently doing game-theory simulations in NetLogo, with very little prior programming experience. I haven't used it myself since making turtles roll around the floor in my primary school classes.
Graham Lee

I've recently looked up a lot about Windows PowerShell.

While not necessarily just a language. It's an awesome shell that has a built-in scripting language. It's basically a super-beefed up command line shell.

Unlike Unix shells, where everything is string text (which definitely has it's benefits), PowerShell commands (cmdlets) use objects. It's based on the .Net framework so you guys who are familiar with that will have probably already figured out that anything PowerShell returns can be piped and the properties and methods of that object can be used. It's fun to say "everything is an object!" again just like when OOP was getting big.

Very neat stuff. For the first time, Windows is implementing some of the Unix command-line interface tools similar to grep and the whole bunch.

T Pops
+1  A: 

If you're interested in VMs, you should look at Parrot...There's a bunch of languages supported and that's pretty neat....

O'caml is a good language if you want to learn how to implement a compiler...

+3  A: 

ML. Learning it and using it forces you think differently about programming problems differently. It also grants one patience, in most cases. Most.

Dean J
+1 Nice to see ML getting a mention! Often overlooked, seldom bettered :)
OCaml gets plenty of mentions as a more practical derivative of ML.

AMS-Script from Autoplay Media Studio. It's a superset of Lua.


Lolcode is one of the most interesting and amusing programming languages I have come across.

Isn't lolcode kinda esoteric?
+1  A: 

Eiffel for static type.

+2  A: 

Harbour for dynamic type. Great opition to business apps.

+3  A: 

How about go? It's brand new, so it's unknown and not mainstream (yet).

It's interesting because the syntax looks like what happens after you put C and pascal into a jar and make 'em fight.

Also, the **go** operator is just genius!
Actually it's interesting because of how it does concurrency.

For me that would be the Joy programming language which is an elegant functional stack-based language. If you are interested in the implementation of this kind of languages, you can look at the Cat programming language which is similar, but has a static type system. There are implementations available in C#, and other languages.

Note: I should disclose that I am actually the author of Cat.



Its powerfull statically-typed programming language for the .NET platform. It support functional programming paradigm as well as object-oriented paradigm. Nemerle macroses make this language very powerfull and extensible. For more information about macroses see


It one of the most powerfull and truly object-oriented language ever designed. We can use this language to compile in C code or for .Net platform. It is very first language with Design by Contract, and Void Safety that can significally reduce bugs in you app.

For more information about Void Safety and C.A.R. Hoare's "billion-dollar mistake" :

B.Meyer "Void Safety: Putting an End To the Plague of Null Dereferencing", Dr. Dobb's Journal 01, 2009, or

Sergey Teplyakov
+1  A: 

I heartily recommend Tcl. I think it fits your mindset of playing with languages nicely.

To be honest, it's not that unknown. Most programmers would encounter it sooner or later due to the popularity of Tk. But it is shunned and avoided by most programmers like a plague so most programmers don't fully know the language. Unfairly so in my opinion - they just don't understand the beauty and power that can be extracted out of it's simple semantics.

Tcl is a very playful language. Take OO in tcl for example. Designing OO systems in tcl for tcl is almost a hobby. Every year someone will think up a new one. Of course for production code most will use established libraries -- that's right, in tcl OO is just a library!

Another game the tcl community keeps playing is trying to make the tcl interpreter understand other language's syntax and/or semantics. As illustrated by the following:

There are many more games you can play with like deleting all conditional constructs from the interpreter and see if you can build a usable programming language from it. That led to discussions about pure functional programming which led to combinator logic, currying and church numerals.

Seriously fun stuff.


Poplog is awesome. IIRC it's a mash of Prolog, lisp, and a few other languages. Just think if all the 70's programming languages had a orgy and accidently a baby.

It was first introduced to me in an Artificial Intelligence course, and with it, you can make a chat-bot in under 100 lines, not including dictionaries.

It's awesome.

More info can be found on wikipedia.