The Right Lang for the Job

Exploring the abbyss of non-mainstream programming languages

Programming languages list

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

  • another Smalltalk for JS
  • brings Morphic to the browser
  • implements Pharo-like IDE, with class browser, debugger, inspector
  • allows editing code of the page live, on runtime, without reloads
  • uses Pharo on the backend for state management, uses Pharo as reference for features



  • 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



  • 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




  • 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
  • note to self: written in Lua


  • 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
  • [2020-04-24 pią] looks kinda dead, last commit from 2018, some broken links on the page


  • larger example:
  • 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

  • many packages available via chicken-install
    • especially interesting: sxpath works (it didn't for Racket)
    • [2017-04-08 sob] SXPath still doesn't work for Racket! I guess I'll need to fix it myself…
    • [2020-04-24 pią] well, turns out I was wrong the whole time, and sxpath worked on Racket, with one quirk to the syntax
      • I had to reimplement the lib myself to understand the difference
  • at least twice as fast as Python for my purposes when compiled (via C to native)


  • another try on making Smalltalk on JS
  • [2020-04-25 sob] looks dead - the domain expired, search only returns some juice brand
  • see also: Amber


Clojure   Lisp

  • a Lisp-like langauge for JVM
  • immutability by default and nice support for concurrency
    • CSP-based channels from core.async
    • thread-local variables (Vars)
    • software transactional memory implementation with Refs
    • synchronized shared state with Atoms
    • message-passing actor-based concurrency with Agents
  • syntax improvements (over CL and Scheme), less parens than usual
  • syntactic support for maps and vectors (besides lists)
  • built-in simple pattern-matching for all core data structures
    • works in most forms (let, defn, etc.) by default

ClojureScript   JS Lisp

  • Clojure to JS compiler
    • last I checked it was dependent on Google Closure Compiler
    • NOTE: I used it briefly a few years ago and never revisited, so it might have changed in the meantime
  • there's a working self hosting implementation now
    • the compiler itself still JVM-based, though
  • [2020-04-25 sob] might be worth another look

TODO Cobol

  • old, business-oriented language

Cobra   dotNET

  • list of features:
  • supports contracts and unit tests in the language
    • pre- and post-condition support for methods
  • syntax is simple, Python-style (no : needed, though)
  • optional static typing, quite fast
  • OOP with closures
  • overall, looks similar to Boo
  • [2020-04-25 sob] doesn't seem to be maintained, latest news from 2013


CoffeeScript   JS

  • 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 itself
    • it also sparked a handful of other languages, like Coco or Imba
  • [2020-04-25 sob] it looks maintained, but I'm not sure about new developments

Common Lisp   Lisp Native

  • the most direct descendand of original LISP from the '50ies!
  • quite a large language, with formal specification
  • supports procedural, functional and object-oriented programming
    • OOP supports multiple inheritance and multi-methods (see CLOS)
  • has variety of implementations, both interpreted and compiled; some are compile-only
  • supports reflection, very late binding and redefinition of everything on runtime
    • very similar to Smalltalk (ie. Pharo) and (to a lesser degree) Erlang in this regard
  • supports optional type definitions, which may be used for optimizations by the compiler
  • I learned it because I use StumpWM, which is a great Window Manager for X, written in CL:


  • [2020-04-25 sob] surprisingly, it's still maintained and developed, latest commit from March 2020
  • 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.



  • not the command-line http client!
  • in 2019 dropped support for Linux and MacOS, new versions only work with MS Windows
    • on the other hand it means that it's still in development as of 2020
  • focused on bringing all the tech used for Web Apps programming under a single language
    • Opa was another try at this
  • supports both on- and off-line use (occasionaly/eventually connected paradigm)


Added on: [2015-02-25 śro]


  • very interesting mix of ideas: Scheme-like semantics with CLOS-like object system
  • has syntax similar to the Wirthian family of languages
    • has infix operators
    • end statements with semicolon
  • supports pattern-based (e.g. define-syntax-rule in Scheme) macros
  • uses a gradually typed type system along with multi-methods and multiple dispatch
  • has an official specification in the form of Dylan book:
  • supports modules and namespaces for modularity
  • the OpenDylan implementation compiles to native via C
    • supports easy C FFI


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


  • almost-purely functional, highly concurrent language based on actors and message passing
    • almost - the only possible side-effect is I/O
  • syntax sharing some similarities with Prolog
  • the main implementation, the BEAM from Erricson (open sourced in 1998)
    • supports SMP parallelism with M:N concurrency
    • has state of the art schedulers for all supported platforms
    • natively supports distribution over multiple nodes (computers/servers)
    • supports JIT and experimental AOT compilation
    • some other languages target the BEAM, most notably Elixir and LFE
  • built for fault-tolerance, correctness, and distribution
  • I wrote two micro-services in it
    • one for proxying requests to external services
    • one for proxying arbitrary requests while logging them (in conjunction with Lua and Nginx)

F#   dotNET

  • F# autocomplete parser
  • OCaml-based language running on .NET
  • it replaces OOP part of OCaml with the .NET model
  • introduces alternative lightweight, indentation based (guided?) syntax
  • adds some additional features, most notably list comprehensions and computational expressions
    • the latter are like Python generator expressions, but with swappable semantics


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.


Added on: [2017-05-17 śro]



F-Script   Smalltalk


Added on: [2020-04-24 pią]

  • statically typed langauge for the BEAM (Erlang's VM)
  • in the tradition of ML, uses tagged unions and (typed) tuples as data abstraction
  • may be worth another look in the future, right now it's very young
    • I'm not sure how much type inference there is


Added on: [2017-04-08 sob]


Added on: [2020-04-24 pią]

  • dynamic language for JVM
  • inspired by Ruby
  • a language that the Gradle - popular JVM build system - uses for config
  • it's also used by Jenkins CI for scripting
    • I wrote a few Jenkinsfiles, plus a library of convenience functions
    • NOTE: in Jenkins, Groovy is crippled to the point that 70% of the language is unavailable by default
      • that's because Jenkins' devs decided to reimplement Groovy with their own continuation-based interpreter
      • they say it's to sandbox the pipeline scripts and make them async by default
      • personally, I think they're nuts and should go home rethink their lives, but let's leave the rant for another day…


  • 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


Added on: [2016-06-02 czw]

  • 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


Added on: [2017-03-08 śro]

  • 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
    • [2020-04-25 sob] dead, no update since 2016

Hy   Lisp


  • 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 nie]

  • 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

  • inspired by Io, but running on JVM
  • homoiconic, fully dynamic, prototype oriented OOP
  • still experimental, not production ready



  • 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: [2019-05-16 czw]


Added on: [2015-11-16 pon]

  • 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

  • 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 śro]

  • 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


  • 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 śro]

  • integrated, reactive
  • looks interesting, need find some time to try it out

Kernel (Klisp)

Khepri   JS

Ki   JS Lisp



Added on: [2015-09-19 sob]

  • 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 śro]


Added on: [2016-05-13 pią]


Added on: [2017-09-30 sob]

  • work in progress dead
  • from its front page:
    • Pleasing syntax and semantics
    • Robust safety
    • Easy build and integration
  • [2020-04-25 sob] dead, the author left it to rot in 2018:
    • because "there wasn't much technical challenge anymore" in the language design, or so he says

      TBH it sounds like he understood at some point that implementation of a language is the easier part, and that the design is both harder and more important, and that you can paint yourself into the corner very easily if you jump from one "interesting problem" to another "technical challenge". I might be reading too much into it, of course, just a personal impression.


Added on: [2017-04-08 sob]


Added on: [2016-05-13 pią]

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

LiveScript   JS

Added: [2013-11-14 czw]

  • 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:
  • I did a talk once on FP fundamentals and use-cases using LS
  • [2016-06-02 czw] 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
  • [2017-10-25 śro] it is still maintained, but not actively developed
  • [2020-04-25 sob] I have some code in LS, in the form of Tizen app, and also here on the blog
    • it still works, but I wouldn't use it for any new projects, as it's not actively developed anymore :(



  • 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: [2019-04-15 pon]

  • another (after Nemerle) language from Polish folks
  • it's a purely functional, data-flow driven language
  • which also has 1 to 1 complete visual representation
  • there are other flow-based visual languages, but they have no (or have impaired) textual representation


Added on: [2014-04-16 śro]



Updated on: [2017-03-08 śro]

  • 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




  • 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)
  • some features:
    • (from:
    • 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


  • 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 pon]

  • I encountered it a long time ago, along with Zimbu I think
  • compiles to C, static typing with inference
  • clean, minimal syntax


  • [2020-04-24 pią] dead, no longer maintained
    • I was expecting that much since the moment they decided to drop OCaml-based syntax and replace it with JS-based one…
  • a language and a framework for writing web apps
  • compiled to JS both on backend and frontend


Added on: [2015-02-25 śro]


Added on: [2016-10-27 czw]


<2019-06-10 pon 21:21>

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

  • 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:
    • 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…)


Added on [2022-05-17 wto]


  • 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 sob]

PogoScript   JS

    • [2020-04-25 sob] dead, unless it pivoted into selling electronic gadgets
  • 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 pon]

  • 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)


  • 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 śro]

  • 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 śro]

  • 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

  • I did a little writeup on Racket when working on Bezier curves forget it, I'm writing a new version [2017-04-03 pon]
  • 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


  • an alternative frontend compiler for OCaml
  • supported by Facebook
  • integrates with BuckleScript to target JavaScript
  • has JSX/XML-literals built in


Added: [2013-12-13 pią 22:56]

  • 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
    parse read [thru <title> copy text to </title> (print text)]
    send [email protected] mold read %.
    foreach row read/custom mysql://[email protected]/books [“SELECT * FROM authors”] [print row]

Redline Smalltalk   Smalltalk


  • 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 nie 00:22]

  • 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 nie 00:58]

  • 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


  • created: 2005
  • interpreted
  • high-level and extensible
  • interesting and so far overlooked (by me)

Shen   Lisp


Added on: [2017-03-08 śro]

  • 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 pon]


Added on: [2018-02-22 czw]

Spry (formerly Ni)

Added on: [2015-09-19 sob]

  • Smalltalk and REBOL influenced language
  • "homoiconic without parentheses"
  • with some influences from Nim - and implemented in it
  • somewhat-active repository


Updated on: [2017-03-08 śro]

  • 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


Added on: [2016-10-27 czw]

TaijiLang   JS



Added on: [2015-08-02 nie]

  • 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 sob]


  • 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



  • experimental language where all code is identified by its content
  • if you heard of a FreeNet - this is the same idea, specialized to source code

Ur and Ur/Web

Updated on: [2020-04-25 sob]

  • Ur is functional, pure, statically typed, and strict
  • Ur/Web is Ur plus a special standard library with support for construction of dynamic web applications
  • incredible that it didn't go the way of many academic projects, it's still being developed in 2020!
    • well, some other things remained academic, eg. reading through the manual will be a traumatic experience for most non-Haskellers, and …


  • apparently backed by some fin tech comapny:
  • similar to Go in design goals, but compiles to native
  • has a converter from C to V and also can compile via C to native
  • easy cross compilation - like in Zig
  • not sure about memory management scheme (they say "minimal allocations")
  • hot code reloading
  • REPL


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



  • like C, but much safer


Added on: [2015-11-16 pon]

  • I found it some three years ago
  • according to HN comments, similar to ooc
  • written by Bram Moolenaar, the author of Vim