Programming Languages


  • C++
  • C#
  • Java
  • JavaScript is a high-level, interpreted or just-in-time compiled programming language. It has curly-bracket syntax, dynamic typing, prototype-based object-orientation and first-class functions.
  • Python
  • TypeScript
  • PHP
  • Go


  • Clojure
  • ClojureScript
  • Common Lisp
  • Dart
  • Elixir (GitHub) is a dynamic, functional language designed for building scalable and maintainable applications. It leverages the Erlang VM, known for running low-latency, distributed and fault-tolerant systems, while also being successfully used in web development and the embedded software domain.
  • F#
  • Haskell
  • Julia (Website, GitHub) is a high-level, dynamic programming language focused on high-performance numerical analysis and computational science. It has a type system with parametric polymorphism, a fully dynamic programming language, and multiple dispatch as its core programming paradigm. It allows concurrent, parallel and distributed computing, and direct calling of C and Fortran libraries without glue code.
  • Ruby
  • Rust


  • Alore is a Python-like programming lanugage created by Jukka Lehtosalo that explores optional typing.
  • Alpaca is a statically typed, strict/eagerly evaluated, functional programming language for BEAM (the Erlang VM) inspired by ML and formerly known as ML-flavoured Erlang (MLFE).
  • Astro (repository) is a programming language designed for safe high-performance applications. It is a statically-typed systems language that facilitates rapid prototyping, features high-level abstractions with zero overhead, ensures memory safety without a (tracing) Garbage Collector, and supports data-race-free concurrency.
  • ATS is a statically typed programming language that unifies implementation with formal specification. It is equipped with an expressive type system rooted in the framework Applied Type System, which gives the language its name. In particular, both dependent types and linear types are available.
  • Ballerina (repository) is a programming language that introduces abstractions of client objects, services, resource functions, and listeners to bring networking into the language. It has statically-typed, structural type system.
  • Boomerang is a programming language for writing lenses—well-behaved bidirectional transformations—that operate on ad-hoc, textual data formats.
  • C2 (repository) is a programming language strongly based on C. It is based on LLVM 7.0 and some parts of Clang 7.0
  • Cell is a high-level, domain-specific, embeddable programming language designed to implement general classes of software systems that are difficult to implement using conventional languages.
  • Chapel (repository) is a modern programming language designed for productive parallel computing at scale. Chapel's design and implementation have been undertaken with portability in mind, permitting Chapel to run on multicore desktops and laptops, commodity clusters, and the cloud, in addition to the high-end supercomputers for which it was originally undertaken. + Elm
  • Ciao (repository) is a programming language that builds up from a logic-based simple kernel, and is designed to be extensible and modular.
  • Carp (Source) is a statically typed Lisp , without a garbage collector and virtual machine. It provides inferred types.
  • Cloe (Webiste, Source) is a Lisp-like, functional programming language. It provides immutable data, lazy evaluation along with implicit parallelism, concurrency, and reactiveness.
  • Crystal (GitHub) is a Ruby-like, object-oriented, statically type-checked programming language.
  • Dafny (GitHub) is a programming language with a program verifier. As you type in your program, the verifier constantly looks over your shoulders and flags any errors.
  • Dark Lang (Website) aims to provide the quick prototyping of Python using their built-in editor along with a language that comes with static types (similar to OCaml).
  • Eff (GitHub) is a functional programming language based on algebraic effect handlers. This means that Eff provides handlers of not only exceptions, but of any computational effect, allowing you to redirect output, wrap state modifications in transactions, schedule asynchronous threads, and much much more.
  • Fennel (GitHub) is a programming language that brings together the speed, simplicity, and reach of Lua with the flexibility of a Lisp syntax and macro system.
  • Flix (GitHub) is a functional programming language that takes inspiration from F#, Go, OCaml, Haskell, Rust, and Scala. It visually resembles Scala, but its type system is closer to that of OCaml and Haskell. Its concurrency model is inspired by Go-style processes and channels. Flix compiles to JVM bytecode and runs on the Java Virtual Machine. Flix supports full tail call elimination which means that tail calls (even to other functions) never overflow the stack.
  • Guile (Website, Source) is an implementation of the Scheme programming language. It is well suited for writing Domain Specific Languages. Guile is homoiconic. It has a powerful object-oriented programming framework and it is optimised for immutability.
  • Idris (Website, GitHub) is a general purpose pure functional programming language with dependent types. Dependent types allow types to be predicated on values, meaning that some aspects of a program’s behaviour can be specified precisely in the type. It is compiled, with eager evaluation. Its features are influenced by Haskell and ML, and include:
  • Imba (Webiste, GitHub) is a programming language for the web that compiles to JavaScript. It is inspired by Ruby and Python. Imba treats DOM elements as a first-class citizens. These elements are compiled to an inline DOM, which is an order of magnitude faster than todays virtual dom implementations.
  • Inko (Website, GitLab) is a gradually-typed, safe, object-oriented programming language for writing concurrent programs. By using lightweight isolated processes, data race conditions can not occur.
  • Janet (Website, Source) is a functional and imperative programming language. The entire language (core library, interpreter, compiler, assembler, PEG) is about 300-500 kB and should run on many constrained systems.
  • Joy is a purely functional programming language devised by Manfred Von Thun. Whereas all other functional programming languages are based on the application of functions to arguments, Joy is based on the composition of functions. Every Joy function is unary, taking a stack as argument and producing a stack as value.
  • Lisp
  • Nim (Website, Source) is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula.
  • Pony (Website, Source) is an open-source, object-oriented, actor-model, capabilities-secure, high-performance programming language.
  • Pyret (Website, Source) is a programming language designed to serve as an outstanding choice for programming education while exploring the confluence of scripting and functional programming.
  • Racket (Website, Source) is a general-purpose, Lisp programming language as well as the world’s first ecosystem for language-oriented programming.
  • Reason is a syntax extension and toolchain for OCaml. It provides a syntax familiar to JavaScript and transpiles to OCaml.
  • Self (Website) is a prototype-based dynamic object-oriented programming language, environment, and virtual machine centered around the principles of simplicity, uniformity, concreteness, and liveness.
  • Shen (Website) is a Lisp flavour with the type system. It is a functional programming language that comes with pattern matching, static type checking and optional lazy evaluation. It also provides a Prolog.
  • Wren (Website, Source) is a small, fast, class-based concurrent scripting language. Think Smalltalk in a Lua-sized package with a dash of Erlang and wrapped up in a familiar, modern syntax.
  • Yeti (Website, Source) is ML style functional programming language, that runs on the JVM.

Applicative Programming Languages

In applicative programming languages, the central construct is a function invocation. This function is applied to a set of parameters.

Stack Programming Languages

In stack programming languages, any function invocation is done by using just the name of that function. Its parameters are implicit, they must on the stack when a particular function is invoked. The result of the function invocation is placed on the stack as well.

Concatenative Programming Languages

In concatenative programming languages, computations are done by composing functions that operate on data being passed from one function to another one.

Concatenative programming languages are not necessarily stack languages.

Examples of Concatenative Programming Languages

  • Kitten
  • Forth
  • Joy
  • Lviv