Egison is a programming language that features extensible efficient non-linear pattern matching with backtracking for non-free data types.

Joy is a functional programming language based on the composition of functions taking one stack as argument and yielding one stack as value. Stacks can contain values of simple types such as truth values, characters and integers, and values of aggregate types such as sets, character strings and quoted programs with lists as a special case. The stack functions include the usual operations such as addition, comparison and list manipulation, but also many new kinds of functions which dequote quoted programs in various ways. These new functions behave like higher order functions, such as conditionals, various forms of recursion, and for aggregates the map, fold and filter functions. This paper gives an overview of the basic programs from which others are built by composition and quotation.

Read More

Cat is a statically typed stack-based pure functional language inspired by Joy. Cat has no variables, only instructions which manipulate a stack (e.g. dup, pop, swap), and a special expression form called a quotation (e.g. [1 add]) which pushes an expression onto the stack which can be executed at a later time (e.g. using apply or dip).

For example: 6 7 dup mul sub results in a stack with the value 43 on top.

Feb 21

Whiley is a hybrid object-oriented and functional programming language. Whiley employs extended static checking to eliminate errors at compile time, including divide-by-zero, array out-of-bounds and null dereference errors. Extended static checking is made possible through the use of an automated theorem prover. Whiley compiles to the Java Virtual Machine and is fully inter-operable with existing Java applications.

Little is a statically typed, C-like scripting language.


  • Familiar C-like Syntax

  • Structs, lists, arrays, hashes

  • Perl regexp: buf =~ /.*foo/, I/O: while (buf = <>)

  • No memory management (reference counted)

  • Compiles to Tcl byte codes, Little can call Tcl, Tcl can call Little

  • Full access to Tcl runtime and libraries

  • Full access to Tk graphical toolkits

Mint has all the tools you need to write error free, easily readable and maintainable applications in record time.

ThinScript is an experimental programming language that compiles to JavaScript, WebAssembly, and C. It’s meant to be a thin layer on top of WebAssembly that makes it easier to work with: no dependencies and fast compile times. The syntax is inspired by TypeScript and the compiler is open source and bootstrapped (it can compile itself).

This is still an experiment and isn’t intended for real use yet. The biggest issue is that the generated code currently doesn’t delete anything (garbage collection is planned but not yet implemented). Also the WebAssembly specification is still being developed and the current binary format will stop working when WebAssembly is officially released.

Read More

min is a functional, concatenative programming language with a minimalist syntax, a small but practical standard library, and an advanced REPL. All packed in a single file*.

Forth is, among other things, a programming language whose ideals are freedom and simplicity. Freedom requires knowledge and responsibility, and simplicity is yet more demanding. But “simple” can also mean rudimentary. Simple Forth attempts to teach the rudiments of Forth.

Welcome to Ripen, a stack-based scripting engine with highly readable syntax, that can be implemented with little code and effort in a language like C++ or D. It’s informed by RetroForth and PostScript, but diverges from either in important ways, not least due to its string-threaded nature. Surprisingly, Ripen only seems to be about 6 times slower than the host language on a quick test — much better than for other language families.

Ripen is based on the principles explained in this interpreter construction tutorial. The point is having a tiny engine, easily copy-pasted into any application, even hidden inside a bigger module. For this reason, the default vocabulary is kept small.

Read More

Newspeak is a new programming language in the tradition of Self and Smalltalk. Newspeak is highly dynamic and reflective - but designed to support modularity and security. It supports both object-oriented and functional programming.

Like Self, Newspeak is message-based; all names are dynamically bound. However, like Smalltalk, Newspeak uses classes rather than prototypes. As in Beta, classes may nest. Because class names are late bound, all classes are virtual, every class can act as a mixin, and class hierarchy inheritance falls out automatically. Top level classes are essentially self contained parametric namespaces, and serve to define component style modules, which naturally define sandboxes in an object-capability style. Newspeak was deliberately designed as a principled dynamically typed language. We plan to evolve the language to support pluggable types.

Read More

#Script is designed as a small, expressive and wrist-friendly dynamic scripting language that for maximum familiarity is modelled after the world’s most popular and ubiquitous scripting Language, JavaScript. Its minimal syntax was inspired by other small but powerful languages which heavily utilizes functions instead of adopting a larger language grammar defining different bespoke syntax for language constructs.

In making Janet, I was inspired by the REBOL Parse module and LPeg to include a versatile library for parsing text and any sequence of bytes based on Parsing Expression Grammars, or PEGs. I was also willing to exclude other forms of parsing tools such as regular expressions from the core library, as PEGs are more general than regular expression, or easier to read, and can capture error locations when matching text. The development of PEGs in Janet went particularly smoothly, made possible by the simple PEG formalism, Janet’s basic data structures, and a very straight-forward subroutine threaded interpreter. While much of Janet’s PEG module could be implemented in any language, Janet’s C API and rich set of core data structures made it easy to implement PEGs in Janet.

This post is about how the Janet PEG engine is implemented; it is not a guide on using pegs. Although the code is written in Janet, It can be translated directly to most programming languages as we make no special use of any data structures besides arrays and hashtables. For information about using Janet’s PEG module, see the Janet PEG documentation.

Read More

Welcome back. This is the second post in my Terrible Compiler for a Useless Language series, in which I write about my attempt to implement a native Brainfuck compiler for x64 Linux. In this post, I’ll be covering a basic parser for Brainfuck.

Goby is an object-oriented interpreter language deeply inspired by Ruby as well as its core implementation by 100% pure Go. Moreover, it has standard libraries to provide several features such as the Plugin system. Note that we do not intend to reproduce whole of the honorable works of Ruby syntax/implementation/libraries.

The expected use case for Goby would be backend development. With this goal, it equips (but not limited to) the following features:

  • thread/channel mechanism powered by Go’s goroutine

  • Builtin database library (currently only support PostgreSQL adapter)

  • JSON support

  • Plugin system that can load existing Go packages dynamically (Only for Linux and MacOS right now)

  • Accessing Go objects from Goby directly

Read More

A tiny, embeddable language implemented in ANSI C

(= reverse (fn (lst)
  (let res nil)
  (while lst
    (= res (cons (car lst) res))
    (= lst (cdr lst))

(= animals ‘(“cat” “dog” “fox”))

(print (reverse animals)) ; => (“fox” “dog” “cat”)

SOUL is short for SOUnd Language.

It’s a platform for writing and running audio code, consisting of two elements: a language and a runtime.

  • The SOUL language is a small, carefully crafted DSL for writing real-time DSP code. Its design goals are to be fast, secure, safe, and simple for even beginners to learn.

  • The SOUL runtime is a collection of tools and technologies for running SOUL code with very high efficiency, on heterogeneous CPUs and DSPs, both locally and remotely.

This package provides a lisp-to-julia syntax translator with convenience macros that let you do this:

lisp”(defn fib a a (+ (fib (- a 1)) (fib (- a 2)))))”
@test lisp”(fib 30)” == 832040
@test fib(30)        == 832040

LispSyntax.jl is implemented as an expression translator between lisp/clojure-like syntax and julia’s AST. Julia’s compiler, JIT and multiple-dispatch infrastructure is used for code generation and execution. Because of this, LispSyntax.jl is not really clojure or lisp in most meaningful ways. The semantics are entirely julia-based (which are very similar to scheme/lisp in many ways). The net result is that LispSyntax.jl is really an alternative S-expression-like syntax for julia, not an implemention of clojure or lisp.

Read More
Programming Languages

Discuss interesting/experimental programming languages.

Created on Nov 12, 2020
By @root