Programming Languages List

• x86 -
  • NASM - Netwide Assembler
• MIX - In the "Art of Computer Programming", Knuth described a "prototypical" computer and designed an assembly language to program it and work the examples in his book, rather than tie the books to a passing fad language of the week.
  • MIXAL - The GNU assembler and emulator for the assembly language for Knuth's MIX processor, utilizes Guile for extension, has Emacs support and GTK GUI emulator.

• Basic - an implementation of ANSI X3.113-1987 standard for Full Basic. This version was apparently described as "Shit with icing".
• Blassic - Supports line numbers(as a REAL Man's Basic should... ;>)
• Brandy Basic - Intepreter/Emulator for the BBC Micro Basic. Multiplatform.
• Bywater BASIC Interpreter - "The Bywater BASIC Interpreter (bwBASIC) implements a large superset of the ANSI Standard for Minimal BASIC (X3.60-1978) and a significant subset of the ANSI Standard for Full BASIC (X3.113-1987) in C." from the Sourceforge site.
• Dark Basic - Meant for creating games and other highly graphical applications. To be honest, I REALLY like the idea behind this, but it has two flaws. 1) It costs money, but more importantly 2) it really sucks hard core. From the install to your first test, it is an exercise in crap.
• Gambas - An object oriented, RAD version of Basic. This one is NOT a VB clone.
• gnbasic - Made to run a set of old programs that seems to originally be run on a ROM version of Basic. Might be useful if you need something old.
• Gnome Basic - VB work-alike that works with Gnome instead of Win32. Its also attempt to provide VB for Applications functionality to Gnome programs.
• GNU/Liberty Basic Compiler Collection - Uses GCC to compile Liberty Basic programs.
• K Basic - Like Gnome Basic, except for KDE, but they seem less concerned with being a VB work alike. Seems to be fairly inactive however, the last status report is dated October 2002.
• Microsoft QuickBASIC 4.5 - I really love this version of the language: user defined data structures, subs, functions, no line numbers. I mean its more like C without the hassle(and power somewhat...). Anyway, here is one good QB4.5 link - QuickBASIC to C Compiler
• Microsoft VisualBASIC - The eventual state of decay. For those who care, here's a VB to C converter, uses GTK, and another one, VB to Python.
• Microsoft VisualBASIC for DOS v1.0 - I mention this for history's sake. I actually HAVE a copy of this if anyone wants to see proof that it exists. This ended the QB line and began the long slow slide of the language…
• Rapid-Q - Cross-platform(Win32 included). Supports lots of stuff like networking, graphics, CGI, and databases.
• RealBASIC - Supposedly a VB killer. It has the added bonus of being available for Mac's.
• ScriptBasic - Another, typical basic implementation. Cross platform, supports networking and databases. Apparently can be used within its own web server engine to serve up dynamic pages.
• sdlBasic - Same idea as DarkBasic, except 2D. Seems to be keeping with the same general lameness of DarkBasic as well…
• Small Basic - Available for a lot of platforms including PalmOS, *nix, Windows, and DOS.
• WSBasic - An interpeter written in C++ with a hand written parser. Inspired by Jack Crenshaw's Let's Build a Compiler book.
• wxBasic - A RAD tool utilizing the wxWindows cross-platform GUI library. Apparently the syntax is more like QBasic than VB, and they don't seem particularly concerned with becoming a VB clone.
• X11 Basic - Basic for X Windows. Doesn't seem to have many RAD features though. Apparently a gimped version is available for Windows(incomplete support).
• XBasic - Multiplatform, includes a GUI designer.
• YaBasic(Yet Another Basic) - A basic implementation of the language. Does not mandate line numbers, and supports subroutines directly(instead of via Gosub :).

• C Scripting Language - An embeddeable C interpreter.
• Ch - An embeddable C/C++ interpreter.
• CINT - C/C++ Interpreter.
• DJGPP - DOS GCC port.
• GCC - The GNU Compiler Collection.
• LCC - LCC was meant to be an easily retartgetable and portable C compiler.
• LCC-Win32 - Win32 port of LCC
• MinGW - (Minimalist GNU for Win32). Win32 port of GCC. Those interested in an IDE for this might check out MinGW Developer Studio, a Visual Studio work-alike.
• SMALL - An embeddable scripting language with a C-like syntax. It is fast, and type-safe. It compiles to P-code which is then ran by a VM written in ANSI C. It has been ported to several platforms including microcontrollers.
• UnderC - A C++ interpreter with a REPL(Read-Eval-Print Loop).

• ASML(Abstract State Machine Language) - For specifying formal systems.
• Bison - A LALR parser generator for C.
• C-- - C isn't portable assembly language, but C-- IS :). Really, the point of this is a portable "language" that has native compilers on all platforms. Except, its not got the "cruft" of C. The idea is this can function as a portable assembly language for high level languages to compile to. Interesting idea. Certainly something I would look at using if(when) I design a programming language.
• D Parser - A scannerless, generalized LR parser.
• Flex - A lexical analyser. Generates C source code.
• FSMC: Finite State Machine Compiler - A tool to take descriptions of Finite State Machines and turn them into C code.
• Glammar - "A pattern transformation language for text-to-text translation. Used for compiler writing and linguistics."
• LLVM Compiler Infrastructure Project - Low Level Virtual Machine. Not sure entirely sure what this is :), but if you're mucking about with compilers, optimizers, seems like an interesting tool.
• MetaEnvironment - For "describ(ing) the syntax and semantics of (programming) languages and to describe analysis and transformation of programs written in such programming languages."
• Stratego - A term rewriting language intended to be used for program transformations.
• TXL - A language for expressing transformations of trees(usually program syntax). It is a functional language with unification and makes use of term rewriting.
• VDM(The Vienna Development Method) - "VDM is a notation and set of techniques for modelling computing systems analysing those models and progressing to detailed design and coding."
• Xactium - Seems to be some kind of MDA(Model Driven Architecture) with features for "lightweight language engineering". Seems worth checking out.

• QUEL - A pre-SQL relational DB language, was quashed pretty much totally by SQL.
• SQL - Structured Query Language. One of the dominant database languages. Many people consider it relational, but these guys don't. Personally, I consider it an impure implementation of a relational DBMS, but I think their anal insistence on making dicks of themselves really turns people off to their ideas, which are really good. Oh well, you catch more flies with honey.
• Tutorial D - A DB language proposed in the book, The Third Manifesto, one attempt at implementation is going at with Dataphor. The book of the The Third Manifesto has a lot of stuff in it, but an early version of the paper, without the extra commentary of the book can be found here.

• ElastiC - A C like language with garbage collection, namespaces, functional programming features, and dynamic typing.
• GameMonkey Script - A free scripting language, designed to be embedded in games and such. Don't know much about it.
• Lua - based on tables. Designed to be embedded in C programs. Is totally ANSI compliant, so it achieves that oh-so-wonderful goal of being source portable among all known C platforms. First heard of it being used in games, but its a very interesting language theoretically as well.
• Scriptix - a simple, threadable, high level language, thats supposed to fast and embeddable. Created for a MUD, but included here(rather than games) since its meant to be a general purpose embedded language.
• Sh - A metaprogramming language for writing shaders to be executed on the GPU's of newer graphics cards, is embedded as a library inside of a C++ program.
• Simkin - An embeddeable language for Java and C++, meant to be use for application scripting(like VBA I suppose). Open source.
• SMALL - An embeddable scripting language with a C-like syntax. It is fast, and type-safe. It compiles to P-code which is then ran by a VM written in ANSI C. It has been ported to several platforms including microcontrollers.
• TCL - Tool Command LLanguage. Pronounced 'tickle'. Neat language. Easily integrated into C. Has a cross platform GUI toolkit(TK). So simple it seems to find its way into everything.

• Arc - Paul Graham's new Lisp Dialect
• C-- - C isn't portable assembly language, but C-- IS :). Really, the point of this is a portable "language" that has native compilers on all platforms. Except, its not got the "cruft" of C. The idea is this can function as a portable assembly language for high level languages to compile to. Interesting idea. Certainly something I would look at using if(when) I design a programming language.
• Cayenne - A simple functional language utilizing dependent types. Heavily influenced by Haskell.
• Centum - An interpreted hybrid OO/Functional programming language.
• Chicken - A Scheme-to-C compiler. Supports most of R5RS.
• Confluence - Looks promising. Seem to realize that a declarative language is a much better core for HDL than trying to be imperative with the attempts a C variants.
• Dylan - Dylan is a language from the Lisp family, but it doesn't really extensively on parenthesis, but it has all the rest of what makes a good Lisp dialect.
• Erlang - Erlang is a fairly modern language used extensively in telecommunications. It provides internal support for a massively parallel(and distributed) computing model that is passed on message passing rather than shared memory. It has lots of support for reliability(including the ability to "upgrade" running programs by replacing code without ever bringing down the application). Its a pretty cool language.
• Glasgow Haskell Compiler(GHC)
• Hugs
• Joy - A pure functional language based on function composition rather than application. Seems similar to ordinary postfix notation, and stacks are used extensively.
• LabView - A visual "data-flow" language. Used to drive data acquisition boards, particularly from National Instruments. I dunno, I don't like it, and what little I had to use it, the cute "visual" stuff that was supposed to make it easy was more of an impediment to doing anything useful.
• LispMe - A Scheme interpreter for PalmOS.
• Maude - Mostly based on string rewriting.
• Maxima - A symbolic Computer Algebra System.
• Mercury - A very recent logic language(released in 2002).
• Mozart - A multi-paradigm language, but its listed here because it specifically supports constraint based programming and logic programming.
• Objective Caml - An object oriented extension to ML. Very different from Standard ML in some features(not just OO).
• PLT Scheme - A cool version of Scheme. Its what I use on my box. Very cool IDE/Environment as well.
• Scheme 48 - Uses several interesting implementation techniques.
• Scheme Shell - Forget lesser shell scripting language of things like Bash, do your shell scripting in a real man's language.
• SIOD(Scheme In One Defun) - A kinda gimpy scheme(um, used ironically as the GIMP scripting language...). Really, its okay, but I found it to be a little random in its support of stuff and never got really far with it.
• Slisp - A simple, portable Lisp intepreter written in C.
• Standard ML of New Jersey
• Unlambda - Minimalist implementation of the "Combinator Calculus" unadorned by such niceties as syntax.
• Warren's Abstract Machine - Not really a language, but more a "virtual machine" that was attempted for logic languages. Very insightful to study.
• XSLT - XML Stylesheets. A functional language for transforming XML documents.
• Z Machine - A language designed by Infocom for writing "Interactive Fiction"(Text Adventure) games. At a time when no two companies computers were the same, the Z-machine provided a way to write games that would be portable across all the platforms of the era. This Virtual Machine would be early 1980's for all Java afficiandos. The use of the virtual machine was inspired by USCD Pascal and the language itself has a Lisp heritage.
• ZINC(Z-Machine Including Network Capabilities) - A networkable, multiplayer Z-Machine and TADS interpreter.

• AGI(Adventure Game Interpreter) - AGI did for graphical adventures what the Z-machine did for text adventures. Designed by Sierra On-line for writing such games as King's Quest and Space Quest.
  • Linux AGI Studio - has Windows support.
  • New AGI
  • Sarien - has Quake console style interactive debugger.
• Inform - A design system for Z-machine games.
• JACL - A text adventure programming language, except it comes with a web server, and makes all its games playable via the web.
• Quake C - This language cemented the existence of the mod community(already strong from experience with Doom). If Z-machine is the father of Text games, and AGI the father of 2D graphical adventures, Quake-C is the father language of all 3D FPS's(First Person Shooters). Used in Quake of course.
• SCI - Variously known as SCript Interpreter or Sierra Creative Interpreter. This is the successor to AGI.
• SCUMM - A point-and-click adventure engine used by LucasArts and a couple of other companies.
• Z Machine - A language designed by Infocom for writing "Interactive Fiction"(Text Adventure) games. At a time when no two companies computers were the same, the Z-machine provided a way to write games that would be portable across all the platforms of the era. This Virtual Machine would be early 1980's for all Java afficiandos. The use of the virtual machine was inspired by USCD Pascal and the language itself has a Lisp heritage.
• ZINC(Z-Machine Including Network Capabilities) - A networkable, multiplayer Z-Machine and TADS interpreter.

• Beta - Apparently a language directly descended from Simula(one of the first OO languages, and the prototype of a school of thought about how OOP should work).
• Charity - A categorical programming language.
• Clean - A pure functional language. It has a very interesting type system called "Uniqueness typing", which allows support for destructive assignment. I suppose this is a competitor to Monads, which supposedly do the same thing. Regardless of which one is better, "Uniqueness Typing" while a boring name, is less weird than "monad", take your pick whether this is a good thing. Also, uniquess typing is an extension of Hindley Milner type inferenceing/checking.
• CWEB - The original Literate Programming language as designed by Knuth. Basically documentation and source code are written together. One program converts it source code to be compiled the other to TeX for printing and reading. This is NOT just documentation tool like Doxygen - CWEB can do rather powerful transformations to source code(e.g. functions can be broken into sections, but sections can declare their own variables and be reused... CWEB appropriately places all the variables of the sections at the beginning of the function). Literate Programming is a pretty good idea, and something I would like to see in future languages, but I'm not quite sure how I feel about using it in C. If you're writing C code which is heavily mathematical or for theoretical purposes this would be EXTREMELY useful, as you could potentially make the documentation the journal article/report on it, and for mathematical code, TeX's math typesetting capabilities would be indispensable for clearly explaining what the code is doing.
• D - A programming language meant to be a successor to C and C++, feature wise it certainly seems to be okay, having some functional, OOP, generic programming, and reliability constructs, along with support for C API's.
• Erlang - Erlang is a fairly modern language used extensively in telecommunications. It provides internal support for a massively parallel(and distributed) computing model that is passed on message passing rather than shared memory. It has lots of support for reliability(including the ability to "upgrade" running programs by replacing code without ever bringing down the application). Its a pretty cool language.
• Forth - Forth really should be a category, but I'll just list the main pointer for now.
• Gamma - dynamically typed, object oriented, interpreted language. Meant to run "mission critical systems".
• GBeta - An evolution of the programming language Beta.
• Java - If you don't know, I'm not telling.
• Joule - A language for distributed systems. Not sure where to get compilers or tools for it. Just found this ref to it. Seemed to fit the eclectic nature of this list.
• LibQuantum - A quantum computer simulation tool, basically, a programming language for quantum computers. Kinda weird. Have fun.
• Occam - A parallel programming language based around Hoare's Communicating Sequential Processes.
• Onyx - A stack based language(Postscript and Forth are stack based as well). Regular expressions, stacks are first class objects, POSIX calls, etc. Seems pretty cool.
• Perl - Practical Extraction and Reporting Language. Also Pathologically Eclectic Rubbish Lister. Take you're pick. Larry Wall is both cool and insane.
• Python - Object Oriented language, uses whitespace for scoping. Easy for beginners. Started as a teaching language(like both Pascal and BASIC).
• Rebol - A programming language for internet applications.
• Rexx - Regina Interpreter, see also Rexx Language Association.
• Ruby
• Simula - A descendent of Algol, and considered one of the progenitors of the Object Oriented Programming.
• Slate - prototype-based object oriented language inspired by Self, CLOS, and Smalltalk. Syntax is intended to resemble Smalltalk.
• Tiger - A language designed by Andrew Appel for his book Modern Compiler Implementation(in C, Java, and ML). You might also want to check out this language spec.

• Alice - A different kind of programming language. Maybe a "3D" Smalltalk. In their own words, they want to provide the "best possible first exposure to programming for students...". Looks neat and pretty.
• BrookGPU - A general purpose language designed to be ran in parallel on Graphics Processing Units(GPU's) and a normal computer system. Apparently similiar to C in some respects.
• CeXL - A general purpose language for 3D graphics. A dialect of Standard ML.
• Metafont - A language for creating fonts. Can be used for creating general graphics and illustrations. Has extensive support to make sure code renders the same picture on any platform. Its vector based, so all images and outputs are scalable.
• Sh - A metaprogramming language for writing shaders to be executed on the GPU's of newer graphics cards, is embedded as a library inside of a C++ program.
• VRML(Virtual Reality Modeling Language) - A standard destined to languish in obscurity. I'm pretty sure I remember in 1997 when it came out and promptly went... nowhere. Oh its implemented and supported by dozens of tools, but if you ask J. Random Netuser, he will have no clue what VRML is. The language that was supposed to put the "space" in cyberspace.

• ABEL - An arbitrary link. Not much to say about it. Its proprietary.
• AHDL - I picked an arbitrary link, google for more info. This is an Altera proprietary language.
• BlueSpec - Don't know a lot about it, I think its going commercial, maybe used to be freeware, oh well.
• Confluence - Looks promising. Seem to realize that a declarative language is a much better core for HDL than trying to be imperative with the attempts a C variants.
• CUPL - Finally found a link. Still not a lot of information though. Can't find a link. Its a proprietary language to boot.
• HAWK - high level specification/abstraction language.
• Lava - A hardware description language based on Haskell. Sounds interesting, but I haven't had a chance to play with it. Here's another link about Lava.
• Verilog - I haven't used it, probably better than VHDL, but it still feels wrong(trying to be Imperative feels wrong in this domain if you ask me though...)
• VHDL - VHSIC Hardware Description Language. (VHSIC = Very High Scale Integrated Circuit). Its based on Ada(that should be enough to convince you of the pain...). Anyway, yeah, I've had some bad experiences with VHDL. I would use it for a base for future work because I know it, but still, I consider it to be full of flaws. Its too low-level most of the time, and doesn't provide sufficient abstraction mechanisms(especially synthesizable ones). VHDL '93 Syntax, VHDL '87 Syntax, IEEE 1164 standard library.

• Cayenne - A simple functional language utilizing dependent types. Heavily influenced by Haskell.
• Glasgow Haskell Compiler(GHC)
• Haskore - A Haskell based composition system.
• Helium - A teaching version of Haskell. Goal is provide better error messages and such.
• Hugs

• Argh! - Another Brainf*** inspired language. Seems to be the usual perversities, 2d flow control, mixing of code and data, and total lack of useful functions. The home page is in German, so here's the Freshmeat page for the project.
• Befunge - They tried to outdo Intercal. They have "multi-dimensional" control flow.
• BLoop, FLoop, and GLoop - "Toy" languages used in Gödel, Escher, Bach by Douglas Hofstadter to explore Computability Theory and what Turing Completeness means. These are EASY languages(perhaps as easy as Intercal is hard). Here's a BLoop interpreter in Perl.
• BrainF*** - Those aren't asterisks. Its a Turing complete assembly language with only 8 instructions.
• INTERCAL - A language written to further drive home that "Beware of the Turing tar-pit in which everything is possible but nothing of interest is easy." and "What is the difference between a Turing machine and the modern computer? It's the same as that between Hillary's ascent of Everest and the establishment of a Hilton hotel on its peak."(both by Alan Perlis). Writing about intercal can be bad for your grades too, see Abstraction and Modularity in INTERCAL, by D. Alexander Garrett.
• Malbolge - One of several language determined to outdo Intercal. Based on the idea that programming should be Hard.
• MIXAL - The GNU assembler and emulator for the assembly language for Knuth's MIX processor, utilizes Guile for extension, has Emacs support and GTK GUI emulator.
• Path - Inspired by BrainF***. They claim to be unconventional, but really, it seems to fit quite nicely into this category.
• Tiger - A language designed by Andrew Appel for his book Modern Compiler Implementation(in C, Java, and ML). You might also want to check out this language spec.
• Unlambda - Minimalist implementation of the "Combinator Calculus" unadorned by such niceties as syntax.

• Scheme Dialects - one of the cooler languages I think in the world today. Anyway, lots of variants of Scheme out there.
  • Chicken - A Scheme-to-C compiler. Supports most of R5RS.
  • Guile - The GNU extension language. Designed to be integrated into C applications.
  • LispMe - A Scheme interpreter for PalmOS.
  • PLT Scheme - A cool version of Scheme. Its what I use on my box. Very cool IDE/Environment as well.
  • Scheme 48 - Uses several interesting implementation techniques.
  • Scheme Shell - Forget lesser shell scripting language of things like Bash, do your shell scripting in a real man's language.
  • SIOD(Scheme In One Defun) - A kinda gimpy scheme(um, used ironically as the GIMP scripting language...). Really, its okay, but I found it to be a little random in its support of stuff and never got really far with it.
  • There Is No Scheme Underground - What more can you say? I mean, it just simply doesn't exist.(I have finally lost my mind).
  • TinyScheme
• Logo - A Lisp without the parentheses, designed as a teaching language. Very famous for its "turtle" graphics.
  • Berkeley Logo(ucblogo) - A *nix version.
  • MSW Logo - A win32 version.
  • StarLogo - A Java implementation of Logo.
• Arc - Paul Graham's new Lisp Dialect
• Dylan - Dylan is a language from the Lisp family, but it doesn't really extensively on parenthesis, but it has all the rest of what makes a good Lisp dialect.
• Slisp - A simple, portable Lisp intepreter written in C.

• DELORES - "forward-chaining reasoning engine for defeasible logic".
• LPFML - XML Language for linear programming.
• Maude - Mostly based on string rewriting.
• Mercury - A very recent logic language(released in 2002).
• Mozart - A multi-paradigm language, but its listed here because it specifically supports constraint based programming and logic programming.
• Prolog - The original logic programming language.
• StarLog - A pure-logic programming language. It uses a bottom-up evaluation order(as opposed to Prolog, and most others, top-down evaluation). Its supposed to be lots more efficient, and simpler than others to program in.
• Stratego - A term rewriting language intended to be used for program transformations.
• TXL - A language for expressing transformations of trees(usually program syntax). It is a functional language with unification and makes use of term rewriting.
• Warren's Abstract Machine - Not really a language, but more a "virtual machine" that was attempted for logic languages. Very insightful to study.

• XML - eXtensible Markup Language. Basically the successor to SGML. A tutorial.
  • BPML(Business Processes Markup Language)
  • DocBook
  • LPFML - XML Language for linear programming.
  • MathML
  • SVG(Scalable Vector Graphics)
  • TEI(Text Encoding Initiative)
  • XForms - Next generation of HTML forms.
  • XHTML - XML'ized version of HTML
  • XML for End Users - A site devoted to tools and schema's for making XML accessible to end users. Very interesting.
  • XSLT - XML Stylesheets. A functional language for transforming XML documents.
  • XUL(XML User interface Language) - Part of Mozilla's for getting User Interfaces right across platforms.
• Latte - Used to generate HTML.
• LilyPond - A program inspired by TeX for setting scores, and it produces TeX as its output format, as well as allowing TeX macros for some extension use.
• SGML - Standard Generalized Markup Language. The granddaddy to many markup languages.
• TeX - TeX, created by Knuth, is perhaps one of the most fascinating markup languages you could find. Its Turing Complete, and works by macro expansion. Mostly used for typesetting mathematical and scientific books and articles, its really widely used by a lot of people.
• YAML Ain't Markup Language - Perhaps "Yet Another Markup Language" would be more appropriate. Actually, tries to minimize typing required to make a general tree structure markup.

• Cayenne - A simple functional language utilizing dependent types. Heavily influenced by Haskell.
• Objective Caml - An object oriented extension to ML. Very different from Standard ML in some features(not just OO).
• Standard ML of New Jersey

• Choon - This language produces music(as a .wav file). It has no variables or mutable store and is Turing Complete.
• Common Lisp Music - Not sure if this counts as a language or not. Considering the strength of Common Lisp macros, I wager that most Lisp libraries more closely resemble what others would call a "language", so I'll count it.
• Common Music - An object oriented enviroment for composing music, similar to Common Lisp Music, this is built on Scheme.
• Haskore - A Haskell based composition system.
• LilyPond - A program inspired by TeX for setting scores, and it produces TeX as its output format, as well as allowing TeX macros for some extension use.
• SuperCollider - "A real time audio synthesis programming language". It sounds interesting, but its MacOS only, so I can't mess with it.

• HyperCard - Hypercard was a scripting language from Apple, which apparently made lots of people happy. Several Replacements are available, but its mostly a fading thing. Wired has good things to say though. And there's always the mailing list.
• Suneido - Apparently a RAD tool that focuses heavily on database integration and technologies.

• Frink - Seems to chiefly be a very smart calculator that keeps tracks of units during calculations(and ensuring that the results have the correct units), but it does seem to have programming constructs as well.
• ISETL(Interactive SET Language) - A language for teaching mathematics. It has libraries for several areas of mathematics including Abstract Algebra, Linear Algebra, Calculus, Precalculus, and Discrete Mathematics.
• LabView - A visual "data-flow" language. Used to drive data acquisition boards, particularly from National Instruments. I dunno, I don't like it, and what little I had to use it, the cute "visual" stuff that was supposed to make it easy was more of an impediment to doing anything useful.
• LPFML - XML Language for linear programming.
• Maple - a popular, commercial symbolic computer algebra system.
• Matlab - I really can't stand MatLab. I think people like it because of the toolboxes that come with it. Sure its easy to use, and has support of lots of cool stuff, but the language itself is pretty nasty, and I don't really know anyone who truly knows the language, everyone in my engineering classes coded by cut-n-paste. The worst farce, is that our teachers probably claim we know Matlab when we graduate.
• Maxima - A symbolic Computer Algebra System.
• Mizar - A theorem CHECKING language. It doesn't write proofs, but it will tell you if, given an axiomatic formal system, if your "theorem" is entailed by the "logic steps" of the proof. A very interesting project.
• Octave - A numerical(not symbolic) computation tool. Similiar in nature to Matlab.
• R - an open source language based on the S Language from Bell Laboratories. R is used heavily for doing work with statistics.

• #Smalltalk - A Smalltalk compiler for .Net.
• Animorphic(or Strongtalk) Smalltalk - An obscure, but extremely fast version of Smalltalk that apparently did some hardcore magic to make dynamic typing have all the advantages of static typing, and still be Smalltalk, by many accounts they succeeded(and Sun bought them out before they released, so they could do magic in the JavaVM).
• Dolphin Smalltalk - a proprietary version of Smalltalk(I'm not sure why it is I'm linking to non-free stuff. Oh well).
• GNU Smalltalk - There's a GNU version of everything, whether its any good or not, who can say. I would probably go with Squeak if I were just getting into Smalltalk.
• MicroSeeker - I don't know a lot about this, but basically the guy is building a robot and using Smalltalk as the language of choice. If I understand him correctly, he has a Smalltalk compiler that works for PIC's(see Hardware Hacking for more info on PIC's).
• Pocket Smalltalk - Smalltalk for your Palm Pilot.
• SmallScript - Actually they call the language S#, its a superset of Smalltalk-98 and runs on .Net or its own virtual machine.
• Squeak - one of the more popular, open source, smalltalk systems available. Lots of platforms.

• ABC123 - Håkan Ahlberg's personal language. Its more in the style of a macro assembler from my initial glance. Its more-or-less a straight conversion of commands into x86 assembly.
• Aleph - multi-threaded, functional, object oriented.
• Cayenne - A simple functional language utilizing dependent types. Heavily influenced by Haskell.
• Centum - An interpreted hybrid OO/Functional programming language.
• Elle - An extension language for Java, not sure if this ever went anywhere…
• Felix - Seems to be directed to C++ fans(looking to be fans of something else... but then again, what C++ programmer ISN'T looking for an out :)
• Groovy - A dynamic language that runs on the Java Virtual Machine.
• Io - A prototype based language by Steve DeKorte
• Jind - An educational, toy language. Apparently game like.
• Needle - OO, Multiple dispatch, garbage collection, tail recursion, first class functions and continuations, ML like static typing, something neat about optional function arguments, parameterized modules, and macros. Sounds neat.
• Nice - Its object oriented, the guy seemed to like Java, talked about adding functional features, and apparently other nifty things too.
• Nickle - A C-like scripting language with arbitrary precision numerics and multithreading.
• Qu - Object oriented, lexical closures, eval, try-finally, and other features.
• Squirrel - high-level(aren't they all), imperative, object-oriented, language. Has delegation, higher order functions, generators, tail-recursion, exception handling, garbage collection, and integrates into C++. Actually looks really interesting to me. Borrows some ideas from Lua as well.
• Tiger - A language designed by Andrew Appel for his book Modern Compiler Implementation(in C, Java, and ML). You might also want to check out this language spec.

• Bento - A web scripting language based around a declarative language.
• BRL - Beautiful Report Language. Another web scripting tool, this one built on top of Scheme.
• Curl - A web scripting language.

• Pascal - Lots of interesting Pascal stuff around. Ironically, the Demo Scene used a lot of Pascal to code demos. Of course, it was all Turbo Pascal with its easy support for inline assembly, with a reliance on that later fact, that caused this usage. Also, Pascal is one of the older, popular languages to make use of a byte-code VM system. Of course, I'm sure everyone thought Java was the first major language to do this, but oh well. Oh yeah, Pascal is probably best known as an example of everything you can do WRONG with strong typing…
  • Delphi - Borland's RAD(Rapid Application Development) tool that apparently blew(blows?) the pants off of VB. Delphi is an object-oriented Pascal
  • Free Pascal
  • G Pascal - A scripting language version of Pascal.
  • GNU Pascal
  • Kylix - Same Borland goodness as Delphi, except for Linux.
  • UCSD P-System - The byte-code/VM version of Pascal for the historical record.
• Euler - Just a link to the paper. Even worse, requires membership in the ACM Digital Library(find a friend at university with decent library and it should be easy enough to get though...).
• Modula-2 -
• Modula-3 -
• Oberon -