Better poly than sorry!

Programming languages list

A list of languages I either looked at or am going to look at at some point.

There are links to official sites, tutorials and other learning resources for each one.

Some languages are tagged with a platform they compile to (JVM, dotNET, JS, Native). There are also 2 additional tags - Lisp and Smalltalk - which I use to mark Lisp- and Smalltalk-like languages (there's simply quite a lot of them).



Amber   JS Smalltalk



  • small, interpreted language for data extraction
  • and shell-related stuff (especially with gawk extensions)
  • jq and possibly Txr took inspiration from AWK

BiwaScheme   Lisp JS

Boo   dotNET


  • http://www.seas.upenn.edu/~harmony/manual.pdf
  • experimental, research langauge built around the concept of lenses
  • focused on text transformation
  • provides a core of lens combinators
  • and a full-blown functional language with many conveniences on top


  • low-level, compiled language with lots of undefined behaviour
  • has rock solid ABI and memory layout rules
  • I was writing some C in the '90
  • there's also a Ch language - it's a C interpreter, working on Windows, well suited for lightweight scripting


  • low to high level, compiled multiparadigm language
  • with support for template metaprogramming and generic programming
  • not too big stdlib, but a workable one
  • multiple-inheritance, no interfaces (use pure abstract classes for this)
  • very complex syntax and semantics, lots of undefined behaviour
  • many useful patterns in community like RAII, but without explicit support in the language
  • I was writing C++ for several yearsat the end of the '90 and '00 beginnings



  • interesting, it says that:

    Ceylon's powerful flow-sensitive static type system catches many bugs while letting you express more, more easily: union and intersection types, tuples, function types, mixin inheritance, enumerated types, and reified generics.

  • and has rather flexible syntax
  • http://ceylon-lang.org/


  • http://www.ceu-lang.org/index.html
  • in short:
    • Structured event handling
    • Synchronous and discrete execution
    • Deterministic shared-memory concurrency
    • Small memory footprint
    • Seamless integration with C and Lua
    • Support for asynchronous threads
  • so mostly imperative, concurrent language. I need to investigate.


  • http://learnxinyminutes.com/docs/chapel/
  • A quick impression of the language:

    After skimming the page it looks rather similar to Nim. Chapel looks like it wants to be a systems programming language with special focus on concurrency and parallel computation. It's statically typed with local type inference. It supports product types with tuples, but I don't see sum types or (G)ADTs in general. It has numeric types with explicit range, like Ada or Nim (that is without dependent types). It supports generics, with a very lightweight syntax (ie. lack of any syntax). Supports in/out/inout parameters like C#. Supports operator overloading. Has iterators. Supports class-based OO with destructors (so probably is not GCed?). Has coroutines as a main concurrency construct. It has "sync" keyword, but I don't have the time to look at it in depth to know how it works.

    It looks like it's somewhere between C and Java, like Nim, Rust and a couple other languages. From a quick glance I can't tell if the language is garbage collected and I don't really know how the concurrency and parallelism really work in the language. Still, it looks rather nice and I suspect you'd use it any time you otherwise use C with pthreads.

Chicken Scheme   Lisp

  • http://www.call-cc.org/
  • many packages available via chicken-install
    • especially interesting: sxpath works (it didn't for Racket)
    • [2017-04-08 Sat] SXPath still doesn't work for Racket! I guess I'll need to fix it myself…
  • at least twice as fast as Python for my purposes when compiled (via C)

Clamato   JS Smalltalk


Clojure   Lisp

  • http://clojure.org/
  • a Lisp for JVM
  • it's irritating because of JVM…
  • …it's also very powerful because of JVM…
  • immutability by default and nice support for concurrency
  • syntax improvements, less parens than usual
  • syntactic support for maps and vectors (besides lists)
  • simple pattern-matching

ClojureScript   JS Lisp

Cobra   dotNET

TODO Coconut

CoffeeScript   JS

  • http://coffeescript.org/
  • the first compile-to-JS-but-leave-the-semantics-untouched language that gained traction
  • I used it for a bit when it came out
  • I then went for LiveScript, so I don't have much to say on Coffee
  • But there are interesting languages forked from Coffee, like mentioned LS and now Imba

Common Lisp   Lisp Native

  • the most direct descendand of original LISP from the '50ies
  • quite a large language, defined in its specification and documented in http://www.lispworks.com/documentation/HyperSpec/Front/index.htm
  • supports procedural, functional and object-oriented programming
  • has variety of implementations; some may compile to native code
  • supports reflection, very late binding and redefinition of everything on runtime
  • supports optional type definitions, which may be used for optimizations
  • I learned it because I use StumpWM, which is a great Window Manager for X, written in CL: http://stumpwm.github.io


  • http://www.mindhog.net/~mmuller/projects/crack/Manual-0.9.html
  • Major Influences: C, C++, Java, Python
  • Syntax: C-style, curly-brace
  • Typing: Static, strong (with some implicit conversion)
  • Compiler: native compiled, either JIT (at runtime) or AOT (native binary)
  • Paradigms: Object oriented, procedural
  • Garbage Collection: Reference counted objects, programmer controlled
  • OO Features: Virtual functions, overloaded functions, multiple inheritance, generics.



Added on: [2015-02-25 Wed]



Earl Grey   JS



Elm   JS

Emacs Lisp   Lisp

  • a Lisp-2 used for scripting Emacs
  • recently it got lexical scoping
  • it also has a 'cl-lib - a library of Common Lisp-style macros


  • I have quite some code written in it

F#   dotNET


Added on: 2015-09-19

  • summarized rather well in its introduction

    F* (pronounced F star) is an ML-like functional programming language aimed at program verification. Its type system is based on a core that resembles System Fω (hence the name), but is extended with (full) dependent types, monadic effects, refinement types, and a weakest precondition calculus. Together, these features allow expressing precise and compact specifications for programs, including functional correctness properties. The F* type-checker aims to prove that programs meet their specifications using a combination of SMT solving and manual proofs. Programs written in F* can be translated to OCaml or F# for execution.

  • https://www.fstar-lang.org/

F-Script   Smalltalk





Added on: [2017-04-08 Sat]


  • http://haxe.org/
  • a language and toolchain optimized for compiling to many targets
  • supports PHP, Flash, JS, C++ and Java backends, among others
  • static typing, ADT, generics, extending existing classes
  • macros, class-based OO


[2016-06-02 Thu]

  • https://urbit.org/docs/hoon/
  • a language used by Urbit
  • purely functional, but with imperative-like features
  • very terse syntax, rivalling J and APL I think
  • compiles down to "low level funtional assembly"
  • has a formally verified interpreter?

Hot Cocoa Lisp   JS

TODO Hotel

Added on: [2017-03-08 Wed]

  • https://github.com/onnlucky/hotel
  • High-level, dynamic language
  • focused on creating high level abstractions
  • claims to disallow any global effects other than I/O (isn't it the same as Erlang?)
  • may be interesting in a couple of years

Hy   Lisp


  • http://www.idris-lang.org/
  • full-dependently typed, pure, eager functional language
  • better than Agda and Coq by a large margin
  • described in "Seven More Languages in Seven Weeks"

Imba   JS

Added on: [2015-08-16 Sun]

  • https://github.com/somebee/imba
  • forked from CoffeeScript in 2012
  • made more JS-like in syntax
  • currently (2015-08-20) it lacks documention, so I will need to find the time to read the sources
  • it supposedly contains a virtual DOM implementation and supports XML literals (for the ignorant masses known as 'JSX'…)

Inform 7


Ioke   JVM

  • https://ioke.org/
  • inspired by Io, but running on JVM
  • homoiconic, fully dynamic, prototype oriented OOP
  • still experimental, not production ready



  • http://code.jsoftware.com/
  • designed by Ken Iverson, one of the Ancient Programming Gods
  • it uses freakishly alien computation model, with absolutely nothing in common with any other language
  • except for APL of course
  • good for simulations, number crunching, dealing with tables of any kind
  • takes long to learn: on par with C++ (including learning some more advanced features)
  • takes being Iverson to master?


Added on: [2015-11-16 Mon]

  • well, for now I see JS mostly as a compilation target…
  • but it does evolve and acquires interesting features
  • may be worth looking into (again) in the future

Jisp   JS Lisp

  • http://jisp.io/
  • Clojure-inspired JS sexpr syntax
  • partly or completely abandoned, this is what the author has to say about that:

    There's been a hiatus in updates. Mostly it's because I'm busy with other projects. Another part of the reason is that my views on JS have underwent a complete 180°. (Please mentally apply a vintage filter to everything else you read in this documentation.) JS doesn't need lispy features or macros because of its polymorphism and flexibility. Problems solved with macros are usually better solved with apt program architecture and using the language to its fullest. Preprocessors tend to be detrimental to the latter part.

  • of course, I disagree completely - JS syntax is a major PITA…


Added on: [2017-03-08 Wed]

  • https://github.com/calroc/joypy
  • a functional, stack-based language
  • I couldn't get original implementation to work
  • but fortunately someone made a Python-based implementation
  • may be a good way to finally learn what is it all about


  • https://stedolan.github.io/jq/
  • a DSL for JSON data manipulation
  • which happens to be a full blown functional language
  • (I assume this happened by accident, like with C++ templates)
  • written in C and command-line use optimized

TODO Kayia

Added on: [2017-03-08 Wed]

  • http://kayia.org/
  • integrated, reactive
  • looks interesting, need find some time to try it out

Kernel (Klisp)

Khepri   JS

Ki   JS Lisp



Added on: [2015-09-19 Sat]

  • http://www.rise4fun.com/koka/tutorial
  • JavaScript-like language with strong typing
  • also tracks kinds of effects in the type system
  • (that dreaded word which starts with "M" would fit here)
  • very interesting language!

    Of course its dead now, no longer maintained and so on, but the idea seems very intriguing. I see this as a next step after F# with its workflows. The only conceptual difference now is that all the code runs in some workflow; this means that you have to add one additional workflow, called something like Normal. All the code that's not run in explicit workflows runs in the Normal workflow.


Added on: [2017-10-25 Wed]


Added on: [2016-05-13 Fri]


Added on: [2017-09-30 Sat]

  • http://leaflang.org/
  • work in progress
  • from its front page:
    • Pleasing syntax and semantics
    • Robust safety
    • Easy build and integration


Added on: [2017-04-08 Sat]


Added on: [2016-05-13 Fri]

LispyScript   JS Lisp

LittleSmallScript   JS Smalltalk



  • A JS-based, in browser environment and implementation of Morphic
  • it allows interactive editing of all elements on page
  • creates Single Page Applications (implemented and scripted in JavaScript)
  • created by Dan Ingalls, one of original Smalltalk implementers/creators
  • https://lively-web.org/welcome.html

LiveScript   JS

Added: [2013-11-14 Thu 23:49]

  • http://livescript.net/
  • it's really sweet little language which makes functional programming in JS really awesome
  • current version is stable and solid
  • I got a little fix into it: https://github.com/gkz/LiveScript/pull/541
  • I did a talk once on FP fundamentals and use-cases using LS
  • [2017-10-25 Wed] it is still maintained, but not actively developed
  • [2016-06-02 Thu] personal note:

    It seems that the frontend developer community decided to ditch most of compile-to-JS languages in favor of compile-JS-to-JS solutions. CoffeeScript fell out of favor and it became harder to smuggle any non-JS language into projects. I still use it in some of my private projects, and here's why.

    • The good.
      • LS supports nearly all of ES2017, so it's not like you lose some features by choosing it
      • While "modern JS" supports a lot of Coffee features, it has almost none of the features of LS
      • LS gives a syntactic support to a lot of functional programming techniques, which are awkward to use otherwise
      • LS is PERL-level terse if you want, but still retains clear and well defined semantics
    • The bad.
      • LS comes with a custom, optional library of functional utils. Great idea in its time, but now Ramda.js would be better
      • Semantics of some constructs, like const and let, are slightly different from JS, which may be confusing
      • It's way too easy to kill performance with a lot of higher-order functions and lambdas - they're cheap syntactically, not in terms of performance
      • No built-in type inference or checking (the same is true for JS), although it probably could be integrated with Flow


  • http://www.lua.org/
  • mostly known as an embeddable scripting language
  • Baldur's Gate, MUSHClient, Redis, Nginx and much more use Lua for scripting
  • Lua is a simple language with very few primitives.
  • It sports a prototype-based OO programming for those so inclined
  • Lua is fast, and LuaJIT is blazingly fast and made by an alien robot from the future ;-)
  • MoonScript is to Lua what CoffeeScript is to JavaScript
  • Lua has a very simple syntax without much syntactic sugar, Moonscript fixes this


Added on: [2014-04-16 Wed]



Updated on: [2017-03-08 Wed]

  • http://eigenstate.org/myrddin/
  • described as "C with Generics"
  • statically typed and AOT compiled to native
  • ADT, pattern matching, type inference, package system
  • low level control, like in C


Nemerle   dotNET

NewLISP   Lisp

Newspeak   Smalltalk




  • http://nim-lang.org/
  • nice: clean, expressive, compiled and fast
  • on the other hand, it's an alpha-grade software: there are bugs
  • (but that's normal and will improve with time)
  • https://nim-by-example.github.io/oop_macro/
  • some features:
    • (from: http://hookrace.net/blog/what-is-special-about-nim/)
    • Run regular code at compile time
    • Extend the language (AST templates and macros);
      • this can be used to add a form of list comprehensions to the language
      • also, you can add your own optimizations to the compiler
    • Bind (easily) to your favorite C functions and libraries
    • Control when and for how long the garbage collector runs
    • Type safe sets and arrays of enums
    • Unified Call Syntax, so mystr.len() is equivalent to len(mystr)
    • Good performance - C level in micro-benchmarks
    • Compile to JavaScript
  • it has a package manager, called Nimble
    • it mostly works out of the box, comparable to pip, npm, lein, etc.
    • it works only for packages, not for Nim installations (like virtualenv or opam)
    • has ~270 packages in the repository, which is quite nice for a language this young


Nu   Lisp

TODO Oberon


  • http://ocaml.org/
  • oo&functional, impure, eager, static typing with global type inference (HM style)
  • and ofc with module system, both bytecode and native compiler, nice async
  • compile-to-js and many more interesting features
  • has OPAM, native package manager and utop, IPython-like top-level (REPL)
  • my first real functional language


Added on: [2015-11-16 Mon]

  • https://ooc-lang.org/
  • I encountered it a long time ago, along with Zimbu I think
  • compiles to C, static typing with inference
  • clean, minimal syntax


  • http://opalang.org/
  • a language and a framework for writing web apps
  • compiled to JS both on backend and frontend


Added on: [2015-02-25 Wed]


Added on: [2016-10-27 Thu]

ParenScript   JS Lisp


  • procedural language with static typing
  • its implementation Turbo Pascal was very popular when I started programming
  • its extension called Object Pascal provides an IDE and RAD capabilities
  • Delphi is one such tool for rapid development

Pharo   Smalltalk

  • http://pharo.org/
  • PBE2 (aka. Deep into Pharo)
  • I have a couple of simple projects done in it
    • package management is not the easiest, but it gets better
    • Pharo has its own versioning system (Monticello) and pkg management tool (Metacello)
    • Gofer is another package which helps with installing packages
    • there are many repositories with packages, no central repo like in Node, Python, Ruby…
    • one such repository is: http://smalltalkhub.com/
    • there is a problem, however: Smalltalk people like to use strange names for packages, like Pomodoro, Magritte, Ephestos, Epicea…
    • …but they apparently HATE writing descriptions for packages explaining what they do
    • in effect, you need to Google every second package name to learn what the heck it is
    • (the rest - installing the package - is easy…)


  • I worked with PHP a bit, I think it was 5.4 edition of the language
  • I don't remember much, but a couple of things that I can't forget:


PicoLisp   Lisp



[2017-09-30 Sat]

PogoScript   JS

  • http://pogoscript.org/
  • very flexible function definition syntax

    Allows for both defining and calling functions with arguments inserted between parts of a function name. This is similar to Avail.

  • adds primitives for async operations, transforms to CPS under the hood


Added on: [2015-11-16 Mon]

  • http://www.ponylang.org/
  • https://github.com/CausalityLtd/ponyc
  • statically typed, with type system guaranteeing sharing/aliasing semantics
  • actor-based concurrency, built into method calls via behaviours
  • both nominal (traits) and structural (interface`) typing
  • classes, extending classes, no inheritance for classes (composition over inheritance)


  • http://powershell.com/cs/
  • Windows specific shell language
  • procedural, giving access to all of .NET
  • makes shell "pipes" (with | operator) into streams of objects


PureScript   JS

TODO Pyret

Added on: [2017-03-08 Wed]

  • https://www.pyret.org/
  • scripting language with functional capabilities
  • some more advanced features like pattern matching, built-in tests and type annotation
  • algebraic data types
  • syntactically resembles Lua, Python and possibly Ruby


Added (for completeness) on: [2017-03-08 Wed]

  • my main language at work and for some of my hobby projects
  • it manages to be quite a good, hybrid (imperative/OO/FP) language

Racket   Lisp

  • http://racket-lang.org
  • I did a little writeup on Racket when working on Bezier curves forget it, I'm writing a new version [2017-04-03 Mon]
  • in general, my first Lisp; still very impressive
  • includes TONS of features, some of which are unique to Racket
    • strong contracts support
    • typed and lazy dialects
    • interesting object system with classes and mixins


Added: [2013-12-13 Fri 22:56]

  • http://www.red-lang.org/
  • REBOL-inspired open source language
  • simple and extensible syntax, very small footprint (500Kb runtime + tools )
  • both compiled and interpreted, with cross-compiling capabilities (planned)
  • there's an interesting interview with Red author
  • it reminds me of Lisp and TCL (by the words of its author "it's in the Lisp family") in that it's:
    • homoiconic (but the syntax is more similar to TCL or Smalltalk than Lisp)
    • supports syntactic abstraction so you can implement your own loops etc.
    • basically every command can parse the remainder symbols however it wants
    • it has blocks, which are transparent and open for interpretation (unlike lambdas)
  • some interesting one-liners (largely the same as in REBOL IIRC):
    view layout [button “Click Me” [print “Hello”]]
    print read http://rebol.com
    parse read http://rebol.com [thru <title> copy text to </title> (print text)]
    send user@domain.com mold read %.
    foreach row read/custom mysql://root@localhost/books [“SELECT * FROM authors”] [print row]

Redline Smalltalk   Smalltalk


  • https://www.ruby-lang.org/en/
  • I had a bit of a plugin for Emacs written in Ruby, so I had to learn a bit
  • it's familiar to me because of its Smalltalk roots


Added on: [2014-01-26 Sun 00:22]

  • http://doc.rust-lang.org/
  • Systems-programming language from Mozilla
  • focused on type- and memory-safety by default
  • focused on concurrency
  • incorporates the notion of ownership into type system



Added: [2013-12-08 Sun 00:58]

  • http://www.scala-lang.org/
  • FP/OO language for JVM, with seamless interop
  • "flexible" syntax (that is, full of special cases)
  • powerful static type system with local type inference
  • you can choose immutability or mutability (vars, collections)
  • supports dynamic, duck-typing-style structural subtyping too

Shen   Lisp


Added on: [2017-03-08 Wed]

  • http://shill.seas.harvard.edu/
  • A shell-scripting language, which focuses on controlling privilages of running scripts
  • written in Racket and apparently only working on FreeBSD for now



Added on: [2015-11-16 Mon]


Added on: [2018-02-22 Thu]

Spry (formerly Ni)

Added on: [2015-09-19 Sat]

  • https://github.com/gokr/ni
  • Smalltalk and REBOL influenced language
  • "homoiconic without parentheses"
  • with some influences from Nim, apparently
  • somewhat-active repository

TODO Squirrel

Updated on: [2017-03-08 Wed]

  • https://github.com/albertodemichelis/squirrel
  • the features:
    • Open Source MIT licence
    • dynamic typing
    • delegation
    • classes & inheritance
    • higher order functions
    • lexical scoping
    • generators
    • cooperative threads(coroutines)
    • tail recursion
    • exception handling
    • automatic memory management (CPU bursts free; mixed approach ref counting/GC)
    • both compiler and virtual machine fit together in about 7k lines of C++ code and add only around 100kb-150kb the executable size.
    • optional 16bits characters strings
    • powerful embedding api
      • eg. function/classes can be defined by scripts or in C
      • eg. objects can fully exist in the VM or be bound to native code
      • eg. classes created in C can be extended by scripts or vice-versa
      • and more
  • fast, embeddable language with full OOP support


  • successor to Obj-C
  • some functional features on top of otherwise OO system
  • from Apple for Appleites, forever

TODO szl

Added on: [2016-10-27 Thu]

TaijiLang   JS



Added on: [2015-08-02 Sun]

  • http://terralang.org/
  • a new low-level language designed for interoperability with Lua
  • it extends Lua with a couple of keywords and constructs related to static typing and such
  • looks somewhat like Cython, but not quite


Added on: [2015-07-04 Sat]


  • http://www.nongnu.org/txr/
  • practical language for text manipulation and data extraction
  • sounds like PERL, but isn't
  • includes a full-blown Lisp-2 implementation
  • is focused on matching patterns in incoming data


wisp   JS Lisp



  • language for transforming XML documents
  • it's a pure functional, dynamically typed language with XML syntax
  • based on pattern matching and recursion
  • most implementations allow for extension
  • http://en.wikipedia.org/wiki/XSLT



Added on: [2015-11-16 Mon]

  • http://www.zimbu.org/
  • I found it some three years ago
  • according to HN comments, similar to ooc
  • written by Bram Moolenaar, the author of Vim