Uncategorized

• Uncategorized

  • Felix - An advanced, statically typed, high performance scripting language with native C++ embedding.
  • Fennel - Fennel is a lisp that compiles to Lua. It aims to be easy to use, expressive, and has almost zero overhead compared to writing Lua directly.
  • Feral - Feral is a dynamically typed, imperative, interpreted language which revolves (to most extent) around the idea of minimalism.
  • Figaro - Figaro is a probabilistic programming language that supports development of very rich probabilistic models and provides reasoning algorithms that can be applied to models to draw useful conclusions from evidence. Both model representation and reasoning algorithm development can be challenging tasks. Figaro makes it possible to express probabilistic models using the power of programming languages, giving the modeler the expressive tools to create a wide variety of models. Figaro comes with a number of built-in reasoning algorithms that can be applied automatically to new models. In addition, Figaro models are data structures in the Scala programming language, which is interoperable with Java, and can be constructed, manipulated, and used directly within any Scala or Java program.
  • Finch - Finch is a simple bytecode interpreted, purely object-oriented, prototype-based, dynamically-typed programming language. It's mostly inspired by Smalltalk, Self, and Javascript.
  • Flix - Next-generation reliable, safe, concise, and functional-first programming language. Flix is a principled functional, imperative, and logic programming language developed at Aarhus University, at the University of Waterloo, and by a community of open source contributors. Flix is inspired by OCaml and Haskell with ideas from Rust and Scala. Flix looks like Scala, but its type system is based on Hindley-Milner. Two unique features of Flix are its polymorphic effect system and its support for first-class Datalog constraints. Flix compiles JVM bytecode, runs on the Java Virtual Machine, and supports full tail call elimination. A VSCode plugin for Flix is available.
  • Flow - a safe, functional strongly-typed programming language.
  • Floyd - Floyd is a general-purpose programming language designed for making very large and robust programs that run really fast, while ducking many of the problems of older languages. Floyd wants to become a better choice than C++, Rust, C#, Python and Javascript for any project.
  • Forscape - Scientific computing language. Forscape solves engineering problems with an unprecedented level of abstraction so you get reliable results quickly. This high-level approach starts with intuitive syntax. Program with the same notation you use to write equations thanks to our innovative math rendering with semantic formatting. Matrices, fractions, symbols- write code using the same notation you use to think through problems on the whiteboard.
  • frawk - an efficient awk-like language
  • FreeBASIC - FreeBASIC is a completely free, open-source, multi-platform BASIC compiler, with syntax similar to MS-QuickBASIC, that adds new features such as pointers, object orientation, unsigned data types, inline assembly, and many others.
  • FreeOberon - Cross-platform IDE for development in Oberon programming language made in the classical FreePascal-like pseudo-graphic style.
  • FreePascal - Free Pascal is a mature, versatile, open source Pascal compiler. It can target many processor architectures: Intel x86 (16 and 32 bit), AMD64/x86-64, PowerPC, PowerPC64, SPARC, SPARC64, ARM, AArch64, MIPS, Motorola 68k, AVR, and the JVM. Supported operating systems include Windows (16/32/64 bit, CE, and native NT), Linux, Mac OS X/iOS/iPhoneSimulator/Darwin, FreeBSD and other BSD flavors, DOS (16 bit, or 32 bit DPMI), OS/2, AIX, Android, Haiku, Nintendo GBA/DS/Wii, AmigaOS, MorphOS, AROS, Atari TOS, and various embedded platforms. Additionally, support for RISC-V (32/64), Xtensa, and Z80 architectures, and for the LLVM compiler infrastructure is available in the development version. Additionally, the Free Pascal team maintains a transpiler for pascal to Javascript called pas2js.
  • Frege - Frege is a Haskell for the JVM. It brings purely functional programing to the Java platform. Like any Haskell, it is purely functional, enjoys a strong static type system with global type inference and non-strict - also known as lazy - evaluation. Frege compiles to Java, runs on the JVM, and uses any Java library you want. It can be used inside any Java project.
  • Fusion - Fusion is a programming language which can be translated automatically to C, C++, C#, D, Java, JavaScript, Python, Swift, TypeScript and OpenCL C. Instead of writing code in all these languages, you can write it once in Fusion. [Transpiler]
  • Futhark - High-performance purely functional data-parallel array programming on the GPU. Futhark is a small programming language designed to be compiled to efficient parallel code. It is a statically typed, data-parallel, and purely functional array language in the ML family, and comes with a heavily optimising ahead-of-time compiler that presently generates GPU code via CUDA and OpenCL, although the language itself is hardware-agnostic and can also run on multicore CPUs.
  • Fux - Flawless Unambiguous Programming - A Modern, Flexible Programming Language for All. Fux is a modern and flexible programming language, perfect for use in a variety of domains by both novice and expert developers. With its efficient use of LLVM, it provides performance similar to C++, while being portable and running on a wide range of platforms.
  • Fuzion - A language with a focus on safety and performance. It unifies concepts found in other programming languages to improve productivity and shall provide tools for performance and correctness.
  • GameMonkey Script - Embedded scripting language for C++ apps, tools and games.
  • Genesis - Genesis is an interpreted, procedural, and Turing-complete Paleo-Hebrew programming language. Diacritical signs are forgone for simplification, though maybe Nikud can be used in prospect as a means for more reserved keywords.
  • Giml - A functional programming language with emphasis on structural typing.
  • Gleam - Gleam is a type safe functional programming language for building scalable concurrent systems. It compiles to Erlang and has straightforward interop with other BEAM languages such as Erlang, Elixir and LFE.
  • Glide - Glide is a statically (and dynamically) typed language designed to make reading and writing data transformations easier. [refinement types]
  • GLMS - A scripting language focused on linear algebra, heavily inspired by GLSL and JavaScript. [algebra, shaders]
  • Gluon - Gluon is a static, type inferred and embeddabble language written in Rust.
  • Go+ - The Go+ programming language is designed for engineering, STEM education, and data science.
  • Goal - Goal is an embeddable array programming language with a bytecode interpreter, written in Go. It provides both a command line intepreter (that can be used in the REPL), and a library interface. The core features are mostly there and tested, so Goal is usable both for writing useful short scripts and playing with the REPL. User testing and bug reports are welcome! Like in most array programming languages, Goal's builtins vectorize operations on immutable arrays, and encourage a functional style for control and data transformations, supported by a simple dynamic type system with little abstraction, and mutable variables (but no mutable values).
  • Goby - 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.
  • Gosu - Gosu is a pragmatic programming language for the JVM. It has been designed with Java developers in mind by providing a set of features that allow them to be more productive without sacrificing the benefits of Java's simple syntax and type-safety. Gosu is an object oriented language with a sprinkle of functional programming features.
  • Gravity - Gravity is a powerful, dynamically typed, lightweight, embeddable programming language written in C without any external dependencies (except for stdlib). It is a class-based concurrent scripting language with modern Swift-like syntax.
  • Gren - Gren is a pure functional programming language that is easy to learn, but powerful in use.
  • Groovy - Groovy is a powerful, optionally typed and dynamic language, with static-typing and static compilation capabilities, for the Java platform aimed at improving developer productivity thanks to a concise, familiar and easy to learn syntax. It integrates smoothly with any Java program, and immediately delivers to your application powerful features, including scripting capabilities, Domain-Specific Language authoring, runtime and compile-time meta-programming and functional programming.
  • Gwion - A strongly-timed programming language aimed at music creation. Heavily inspired by ChucK.
  • Halide - Halide is a language for fast, portable data-parallel computation. Also Halide designed to make it easier to write high-performance image and array processing code on modern machines. Rather than being a standalone programming language, Halide is embedded in C++. This means you write C++ code that builds an in-memory representation of a Halide pipeline using Halide's C++ API. You can then compile this representation to an object file, or JIT-compile it and run it in the same process. Halide also provides a Python binding that provides full support for writing Halide embedded in Python without C++.
  • Hamler - Haskell-style functional programming language running on Erlang VM.
  • Harbour - Harbour is the free software implementation of a multi-platform, multi-threading, object-oriented, scriptable programming language, backward compatible with Clipper/xBase. Harbour consists of a compiler and runtime libraries with multiple UI and database backends, its own make system and a large collection of libraries and interfaces to many popular APIs.
  • Hascal - Hascal is a general purpose and open source programming language designed to build optimal, maintainable, reliable and efficient software.
  • Haskell - A general-purpose, statically-typed, purely functional programming language with type inference and lazy evaluation. Designed for teaching, research and industrial application, Haskell has pioneered a number of programming language features such as type classes, which enable type-safe operator overloading. Haskell's main implementation is the Glasgow Haskell Compiler (GHC).
  • Haxe - High-level and strictly-typed programming language, cross-compiles to many different targets.
  • Hazel - Hazel, a live functional programming environment with typed holes
  • Hazure - A ML-Inspired programming language that transpiles to Typescript.
  • Hedy - Hedy is a gradual programming language to teach children programming. Gradual languages use different language levels, where each level adds new concepts and syntactic complexity. At the end of the Hedy level sequence, kids master a subset of syntactically valid Python. [children]
  • Heron - Heron is a small cross-platform language that was designed for ease of use, performance, and safety with a JavaScript like syntax. Heron emphasizes pure functional programming code, but looks like a traditional imperative or object-oriented code.
  • HGSL - A shading language that can be compiled into GLSL ES 3.0.
  • Hilvi - Hilvl is a programming language that is versatile but with a very small syntax. All code in hilvl are single-argument invocations of actions that belong to services. Services are the fundamental building blocks of a hilvl program. And the name hilvl reflects how this is a higher level of abstraction than objects and functions.
  • Hobbes - Hobbes is built for high performance integration with C/C++ applications.
  • Hook - Hook is an imperative, cross-platform, dynamically typed scripting language that utilizes a mutable value semantics approach.
  • Hope - Hope is a lazily evaluated functional programming language developed in 1970's by Ross Paterson. It influenced the design of other lazy languages such as Miranda and Haskell.
  • Hush - Hush is a unix shell based on the Lua programming language. Hush is written in Rust.
  • Hy - A dialect of Lisp that's embedded in Python.
  • Húngaro - A syntax based programming language.
  • Idris - Idris is a programming language designed to encourage Type-Driven Development. In Idris, types are first-class constructs in the langauge. This means types can be passed as arguments to functions, and returned from functions just like any other value, such as numbers, strings, or lists.
  • Imba - Imba is a friendly full-stack programming language for the web that compiles to performant JavaScript. It has language-level support for defining, extending, subclassing, instantiating and rendering DOM nodes.
  • Imp - Various experiments in relational programming
  • Inform 6 - The latest version of the Inform 6 compiler, used for generating interactive fiction games.
  • Inform 7 - Inform is a programming language for creating interactive fiction, using natural language syntax. Using natural language and drawing on ideas from linguistics and from literate programming, Inform is widely used as a medium for literary writing, as a prototyping tool in the games industry, and in education, both at school and university level (where Inform is often assigned material for courses on digital narrative). It has several times ranked in the top 100 most influential programming languages according to the TIOBE index. Created in April 2006, it was open-sourced in April 2022.
  • Ink - Ink is a minimal programming language inspired by modern JavaScript and Go, with functional style. Ink can be embedded in Go applications with a simple interpreter API.
  • Inko - Inko is a statically-typed, safe, object-oriented programming language for writing concurrent programs.
  • Io - Io is a pure object-oriented (relying on prototype-based paradigm) programming language focused on expressiveness through simplicity.
  • ISPC - Intel Implicit SPMD Program Compiler is a compiler for a variant of the C programming language, with extensions for single program, multiple data programming. Under the SPMD model, the programmer writes a program that generally appears to be a regular serial program, though the execution model is actually that a number of program instances execute in parallel on the hardware. [C dialect]
  • ivy - Ivy is an interpreter for an APL-like language. It is a plaything and a work in progress.
  • Ivy - Ivy is an extensible, dynamically typed, late binding language intended to be used as an embedded command language. It can also be used stand-alone: it can execute script files from the command line or presents a read-eval-print loop (REPL) to the user if no files are given. Ivy's extensibility is based on the fact that statements are syntactically identical to function calls. Also blocks (surrounded by braces) may be used as function arguments. Thus, new user-defined statements can be added just by defining functions. Function arguments are packaged up as thunks and may have their evaluation delayed and execution environment modified. This allows user defined functions to do many of the things that traditional language statements can do.
  • J - J is a high-level, general-purpose programming language that is particularly suited to the mathematical, statistical, and logical analysis of data. It is a powerful tool for developing algorithms and exploring problems that are not already well understood.
  • J* - J* is a dynamic embeddable scripting language designed to be as easy as possible to embed into another program. It arises from the need of having a modern scripting language with built-in support for OOP whilst mantaning simplicity of use and a low memory footprint. It can be viewed as a middle ground between Python, a more complete scripting language with lots of features and libraries, and Lua, a small and compact language that is simple to embed but doesn't provide OOP functionalities out of the box. J* tries to take the best of both worlds, implementing a fully featured class system while maintaining a small standard library and employing the use of a stack based API for communication among the language and host program, rendering embedding simple.
  • Jakt - Jakt is a memory-safe systems programming language. It currently transpiles to C++.
  • Janet - Janet is a functional and imperative programming language and bytecode interpreter. It is a lisp-like language, but lists are replaced by other data structures (arrays, tables (hash table), struct (immutable hash table), tuples). The language also supports bridging to native code written in C, meta-programming with macros, and bytecode assembly.
  • Jank - Jank is a Clojure dialect which aims to offer the best of both worlds: dynamic and static. For both of these worlds, jank uses a single runtime, so the transition from one to the other is not only seamless, it can be gradual.
  • Jasm - A JVM assembler for the modern age.
  • Jinx - Embeddable scripting language for real-time applications.
  • Juka - Juka Programming Language - Rapid Prototyping Language built to run on Azure Microsoft Server. Juka's goal is to be a universal programming language that can run on any platform. Juka is being built on top of .NET network and runs on any platform that supports .NET. Juka can also compile programs into executables.
  • Julia - Julia is a high-level, high-performance, dynamic programming language. While it is a general-purpose language and can be used to write any application, many of its features are well suited for numerical analysis and computational science.
  • KAGSA - KAGSA is a new Interpreted programming language based on Python, the language will be practical and reliable in your projects.
  • Kalaam - Kalaam is the first-ever programming language in Hindi and has all the basic functionalities of a modern programming language. From for loops to while loops and from functions to conditional statements.
  • Kalyn - Self-hosting compiler from a Haskell-like Lisp directly to x86-64, developed fully from scratch.
  • KataScript - KataScript is a simple scripting language with familiar syntax, designed to be easily embedded in C++ applications ([In-Browser Demo](https://brwhale.github.io/KataScript/)).
  • Kawa - Kawa is a general-purpose programming language that runs on the Java platform. It aims to combine:
  • KCL - KCL is an open-source, constraint-based record and functional language that enhances the writing of complex configurations, including those for cloud-native scenarios. With its advanced programming language technology and practices, KCL is dedicated to promoting better modularity, scalability, and stability for configurations. It enables simpler logic writing and offers ease of automation APIs and integration with homegrown systems. [Configuration]
  • Kempe - Kempe is a stack-based language and toy compiler for x86_64 and aarch64. It requires the nasm assembler when targeting x86_64.
  • Kin - Kin is a straightforward programming language created with the purpose of aiding Kinyarwanda speakers in easily learning programming.
  • Kind - Kind is a pure functional programming language and proof assistant.
  • Kitten - A statically typed concatenative systems programming language. Kitten is a statically typed, stack-based functional programming language designed for simplicity, speed, and safety. This is an in-progress implementation of that language, including:
  • Klaxon - Minimalist RPN language that compiles to x86-64 assembly
  • Koka - Koka: a functional language with effects. Koka is a strongly typed functional-style language with effect types and handlers.
  • L.in.oleum - L.in.oleum is an unstructured, untyped, procedural programming language. And more specifically, it's a form of cross-platform assembly language. It is oriented to the developement of general-purpose applications, especially when 100% portability, execution speed and module compactness is requested. This language has an almost 1:1 source-to-CPU instruction ratio, allows direct access to five general-purpose registers (performing basic operations from a theoretical 2 up to a pratical of even 10 times faster than memory-held variables), and if used well, is averagely twice as fast as C in pure computational power.
  • Lark - Lark is an experiment in designing a homoiconic language with a syntax inspired by SmallTalk. It's very early, so there isn't much to see yet, but you can play with it.
  • ldpl - Compiled programming language for Unix systems, inspired by COBOL and designed to be expressive, fast, readable and easy to learn.
  • Leafscript - Leafscript is a lightweight programming language created as a proof of concept by someone with no idea how to write a language. It's written entirely in Golang, and was inspired by the speed and simplicity of Lua.
  • Lean - Lean is an open source theorem prover and programming language being developed at Microsoft Research. Lean aims to bridge the gap between interactive and automated theorem proving, by situating automated tools and methods in a framework that supports user interaction and the construction of fully specified axiomatic proofs.
  • Letlang - Functional language with a powerful type system.
  • Libra - Libra is a basic stack-based programming language simulated through Haskell. Heavily inspired by Porth and Forth
  • Libra - Libra - Lazy Interpreter of Binary Relational Algebra
  • LispE - A _Lisp_ implementation with _Data Structure_, _Arithmetic Type_, _Array Instructions_, _Pattern Matching_ and many many different instructions and libraries. _LispE_ is a mix of functional and array languages.
  • Lizard - Lizard is a domain-specific language to define and control hardware behaviour. It is intended to run on embedded systems which are connected to motor controllers, sensors etc. Most of the time it is used in combination with a higher level engine like ROS or RoSys. You can think of the microcontroller as the machine's lizard brain which ensures basic safety and performs all time-critical actions.
  • LMQL - LMQL is a programming language for large language models (LLMs) based on a superset of Python. LMQL offers a novel way of interweaving traditional programming with the ability to call LLMs in your code. It goes beyond traditional templating languages by integrating LLM interaction natively at the level of your program code.
  • Lobster - Lobster is a statically typed programming language with a Python-esque syntax that combines the advantages of an expressive type system and compile-time memory management with a very lightweight, friendly and terse syntax, by doing most of the heavy lifting for you.
  • Lox - jlox & clox implementations of educational Lox language from great book "Crafting Interpreters".
  • LSTS - LSTS is a proof assistant and maybe a programming language. Proofs in LSTS are built by connecting terms, type definitions, and quantified statements. Terms can be evaluated to obtain Values. Types describe properties of Terms. Statements describe relations between Terms and Types.
  • Lua - Lua is a powerful, efficient, lightweight, embeddable scripting language. It supports procedural programming, object-oriented programming, functional programming, data-driven programming, and data description. Lua combines simple procedural syntax with powerful data description constructs based on associative arrays and extensible semantics. Lua is dynamically typed, runs by interpreting bytecode with a register-based virtual machine, and has automatic memory management with incremental garbage collection, making it ideal for configuration, scripting, and rapid prototyping.
  • Lux - Lux is a new programming language in the making. It's meant to be a functional, statically-typed Lisp that will run on several platforms, such as the Java Virtual Machine and JavaScript, Python, Lua, or Ruby interpreters.
  • Macro Lambda Calculus - lambda calculus using interaction nets, providing CLI and API. Its browserified version is available as [an online demo](https://codedot.github.io/lambda/).
  • Magmide - A dependently-typed language intended to make provably correct code possible for working software engineers.
  • Magnet - Magnet is an object-oriented programming language, that is prototype-based to the point of real types being absent in favor of duck types. E.g. every object providing a read method that returns a readable, is considered "readable" (meaning it can represent a string). Since this causes a recursion, there must be some "primal" readable to end that: Such primal readable is also known as a String Object in Magnet. Furthermore, Magnet is syntax driven. This means: Everything that can be done to reduce code, retain simplicity and to amaze the developer, IS done!
  • Magpie - Magpie is a small dynamically-typed programming language built around patterns, classes, and multimethods. It has a prototype interpreter that runs on the JVM and an in-progress bytecode VM written in C++.
  • MANOOL - MANOOL is a programming language designed with an idea to maximize the expressive power / implementation complexity ratio.
  • MarkovJunior - MarkovJunior is a probabilistic programming language where programs are combinations of rewrite rules and inference is performed via constraint propagation. MarkovJunior is named after mathematician Andrey Andreyevich Markov, who defined and studied what is now called Markov algorithms.
  • Mash - Untyped, lightweight, crossplatform OOP language.
  • CASL - CASL (Compact Application Solution Language) is an easy to use Windows Integrated Development Environment (IDE) that allows you to build applications for the PalmOS®, PocketPC / Windows Mobile and Windows using a single set of code. You can easily create applications that target multiple operating systems using a high-level programming language (similar to BASIC) that will only take a small investment of your time to learn. Even if you have never created software before, CASL can help make your idea a reality.
  • Cat - Cat is a functional stack-based programming language inspired by the Joy programming language. The primary differences is that Cat provides a static type system with type inferencing (like ML or Haskell), and a term rewriting macro language extension language called MetaCat. Cat is a high-level intermediate language translation that can also be used as a stand alone language for simple application development. In this way it occupies a similar niche to PostScript. Cat is also an appropriate language for teaching of basic programming concepts.
  • Chalice - Chalice is an experimental language that explores specification and verification of concurrency in programs. The language supports dynamic object creation, dynamic thread creation (fork and join), mutual-exclusion and readers-writers locks, monitor invariants, thread pre- and postconditions. The language allows fine-grained locking via specifications that track fractional permissions for memory locations. The research project also includes an automatic static program verifier for Chalice.
  • Circom - Circom is a circuit programming language and a compiler that allows programmers to design and create their own arithmetic circuits for ZK proofs.
  • CLIPS - Developed at NASA’s Johnson Space Center from 1985 to 1996, the C Language Integrated Production System (CLIPS) is a rule‑based programming language useful for creating expert systems and other programs where a heuristic solution is easier to implement and maintain than an algorithmic solution. Written in C for portability, CLIPS can be installed and used on a wide variety of platforms. Since 1996, CLIPS has been available as public domain software.
  • ABCL - ABCL: An Object-Oriented Concurrent System. The tenet of our ABCL research project is to exploit both paralle. lism and object orientation. Parallelism is ubiquitous in our problem domains; parallelism is not only the source of computational power, but also promotes structural simplicity/naturalness in design and algorithm. Object-orientation accompanying parallelism, enhances system modularity, flexibility, and safety.
  • Adept3x - A language designed to help maximize developer productivity and safety
  • Aria - Aria is a modern, dynamic scripting language. It is meant to be a "sweet spot" language, easy to pick-up and enjoyable to use. It comes with a familiar C-style syntax, a feature set inspired by well-beloved languages such as Python and Rust and a focus on getting stuff done. The standard library, while simple, has enough basic features to get you started on interesting problems.
  • ASPL - ASPL is a modern programming language featuring beautiful simplicity, seamless cross-compilation, advanced mobile support, powerful C-interoperability, and so much more. It has been designed to be practical for both beginners and experienced programmers and to help you build better software, quicker.
  • atto - self-hosted functional programming language
  • AutoIt v3 - is a freeware BASIC-like scripting language designed for automating the Windows GUI and general scripting. It uses a combination of simulated keystrokes, mouse movement and window/control manipulation in order to automate tasks in a way not possible or reliable with other languages (e.g. VBScript and SendKeys). AutoIt is also very small, self-contained and will run on all versions of Windows out-of-the-box with no annoying "runtimes" required! AutoIt was initially designed for PC "roll out" situations to reliably automate and configure thousands of PCs. Over time it has become a powerful language that supports complex expressions, user functions, loops and everything else that veteran scripters would expect.
  • BabyCobol - BabyCobol is a project in language design aimed at creating a language that is, on one hand, small enough to be quickly implementable (fully or partially) within any framework that can support its features, and, on the other hand, complex enough to cover typical problems of legacy language processing. If you learn how to compile MiniJava, you stand a good chance of implementing a reasonably good compiler for any contemporary programming language. If you show how your language extension works on Featherweight Java, it has a good chance of being applicable to any reasonable modern object-oriented programming language. If you can handle BabyCobol with your tool and with your skills, you are ready to face the challenges of software modernisation, codebase migration and legacy language processing in general. At this day and age, being future proof means being able to handle software of the past.
  • Bau - Bau is a simple, concise, safe, powerful and fast programming language. Features: Easy to learn; Concise syntax; Memory-safe; Statically typed; Fast compilation and execution (transpiles to C).
  • Blacklight - blacklight is a general-pupose multithreading concatenative stack-based programming language with first-class queues and objects with delegation.
  • Bleach - Bleach: a programming language aimed for teaching introductory 'Compilers' courses.
  • Bracmat - Programming language for symbolic computation with unusual combination of pattern matching features: Tree patterns, associative patterns and expressions embedded in patterns.
  • Cat - Cat is a functional stack-based programming language inspired by the Joy programming language. The primary differences is that Cat provides a static type system with type inferencing (like ML or Haskell), and a term rewriting macro language extension language called MetaCat. Cat is a high-level intermediate language translation that can also be used as a stand alone language for simple application development. In this way it occupies a similar niche to PostScript. Cat is also an appropriate language for teaching of basic programming concepts.
  • Cecil - Cecil is a purely object-oriented, type-safe, garbage-collected language intended to support rapid construction of high-quality, extensible software.
  • Charm - Charm is a data-oriented scripting language.
  • Citrine - The inspiration for the Citrine Programming Language comes from Smalltalk (message-based, pure object oriented programming), JavaScript (prototypal inheritance), and BASIC (dynamic scope). The name Citrine refers to the yellow coloured gem and honours the short lived tradition to name programming languages after shiny minerals like Pe(a)rl and Ruby.
  • CMOC - CMOC is a 6809-generating cross-compiler for a large subset of the C language. It generates assembly language code for the Motorola 6809 processor and targets the Tandy Color Computer, the Dragon computer, the Vectrex video game console, the Thomson MO and TO computers, and the OS-9 and FLEX operating systems. It runs under GNU/Linux and other Unix-like environments like Darwin and Cygwin. It requires the LWTOOLS assembler (lwasm) and linker, by William Astle.
  • Core - A modern, minimal programming language. In a world in which languages add features until they collapse under their own weight, build a language that is content with itself.
  • CSL - The C Scripting Language (CSL) is a programming language available for Windows, OS/2 and UNIX systems. CSL follows the C syntax very closely. It is used like an interpreter: a program written with an editor can be run directly like any shell script. The CSL scripting engine can be integrated into own applications as a macro language. CSL offers two programming interfaces: A "C" API for 32-bit C compilers, and C++ class interface for selected compilers.
  • Cxy - Cxy is a statically typed programming language that is transpiled to C. Some of the feature supported by Cxy
  • Cyclone - Cyclone is like C: it has pointers and pointer arithmetic, structs, arrays, goto, manual memory management, and C’s preprocessor and syntax. It adds features such as pattern matching, algebraic datatypes, exceptions, region-based memory management, and optional garbage collection.
  • cypher - Cypher is Neo4j’s declarative query language, allowing users to unlock the full potential of property graph databases.
  • Dream Maker - The DM (Dream Maker) language uses a syntax similar to C/C++ to build networked multi-user worlds. This reference and the accompanying guide discuss the structure and function of DM.
  • E - E is an object-capability programming language and platform for writing distributed, secure, and robust software.
  • EEL - EEL is a scripting and programming language, designed specifically for hard real time applications. The primary target areas of application are control engineering and audio synthesis, but EEL should also be suitable for game scripting and for adding scripting capabilities to real time multimedia applications. The syntax is C-like, but the language is higher level than C, and "safe" in the sense that EEL programs should not be able to crash the virtual machine or the host application. EEL has dynamic typing, automatic memory management, exception handling and built-in high level data types such as vectors, arrays and tables. New such data types can be added at run time by host applications. EEL compiles into byte-code that runs on a virtual machine, which means that no explicit support for specific architectures is needed for portability. The implementation is deliberately very self contained and has few dependencies, so that it can be easily integrated into "strange" environments, such as embedded devices running real time operating systems.
  • elastiC - elastiC is a portable high-level object-oriented interpreted language with a C like syntax.
  • Enchilada - Enchilada is optimized to efficiently and consistently share huge amounts of data (and code) in a distributed environment. Possible use cases:
  • ErgoAI - Flora-2 (now ErgoAI) is an advanced object-oriented knowledge representation and reasoning system. It is a dialect of F-logic with numerous extensions, including meta-programming in the style of HiLog, logical updates in the style of Transaction Logic, and defeasible reasoning. Applications include intelligent agents, Semantic Web, knowledge-based networking, ontology management, integration of information, security policy analysis, and more.
  • execline - execline is a (non-interactive) scripting language, like sh - but its syntax is quite different from a traditional shell syntax. The execlineb program is meant to be used as an interpreter for a text file; the other commands are essentially useful inside an execlineb script. execline is as powerful as a shell: it features conditional loops, getopt-style option handling, filename globbing, and more. Meanwhile, its syntax is far more logical and predictable than the shell's syntax, and has no security issues.
  • F - F is a pure functional concatenative language originally designed as an extension of False. F contains the list-operations of K3 and the dip combinator of Joy. Floating-point and symbolic datatypes are supported. One-time assignment is enforced in syntax. A theory of function-valence and -charge is outlined. F also contains a general continuation primitive $, and the pattern sublanguage of XY. G is a variant of F in which the K3 adverbs are implemented as primitives.
  • Fabric - Fabric is a high-level programming language for building open distributed applications with strong security. Fabric enables securely computing and storing information, and sharing code and data across trust boundaries. It is being developed by the Applied Programming Languages Group at Cornell University.
  • FAST - FAST: A Transducer-Based Language for Tree Manipulation
  • Fay - A proper subset of Haskell that compiles to JavaScript.
  • FermaT - The FermaT Transformation System is a powerful industrial-strength program transformation system based on the WSL language. FermaT has been used sucessfully in several major assembler to C and assembler to COBOL migration projects involving the conversion of millions of lines of hand-written assembler code to efficient and maintainable C or COBOL code.
  • Fermat - Fermat is a computer algebra system for Macintosh, Windows, Linux, and Unix by me, Robert H. Lewis of Fordham University, that does arithmetic of arbitrarily long integers and fractions, multivariate polynomials, symbolic calculations, matrices over polynomial rings, graphics, and other numerical calculations. It is extremely fast and extremely economical of space.
  • Finitio - Finitio is a data language. For now, it is limited to a data definition language (DDL). Think "JSON/XML schema", but a slightly different way, that puts the emphasis on precision. Finitio comes with a dedicated type system for defining data and a theory, called information contracts, for interoperability with programming and data exchange languages.
  • Fleng - This software is an implementation of "FLENG", a low level concurrent logic programming language descended from Prolog. A compiler is provided to translate programs written in FLENG into assembly language which can subsequently be compiled and linked into a binary executable.
  • Florid - FLORID (F-LOgic Reasoning In Databases) is a deductive object-oriented database system employing F-Logic as data definition and query language. The development was supported by the Deutsche Forschungsgemeinschaft (project La 598/3-2). With the increasing interest in semistructured data, Florid has been extended for handling semistructured data in the context of Information Integration from the Semantic Web.
  • Flux - Flux is a lightweight scripting language for querying databases (like InfluxDB) and working with data. It's part of InfluxDB 1.7 and 2.0, but can be run independently of those.
  • Foma - Foma is a compiler, programming language, and C library for constructing finite-state automata and transducers for various uses. It has specific support for many natural language processing applications such as producing morphological analyzers. Although NLP applications are probably the main use of foma, it is sufficiently generic to use for a large number of purposes.
  • Forest - Forest is a domain-specific language for describing filestores.
  • Formula 2.0 - FORMULA 2.0 is framework for formally specifying domain-specific languages (DSLs) and model transformations. FORMULA specifications are succinct descriptions of DSLs, and specifications can be immediately connected to state-of-the-art analysis engines without additional expertise. FORMULA provides: (1) succinct specifications of DSLs and compilers, (2) efficient compilation and execution of input programs, (3) program synthesis and compiler verification.
  • Frenetic - Frenetic is an open-source Software Defined Network (SDN) controller platform designed to make SDN programming easy, modular, and semantically correct
  • friend - 1)Compiler/interpreter for a simple OO language. The language allows to use networking very easily, including such protocols as TCP, UDP, Raw Sockets 2) Library for reading/manipulating Java bytecode
  • FUN - FUN is a simple, structured, imperative, dynamic, object-oriented, functional and high-level programming language. FUN was developed by Wisdom ZHANG in 2010 as a scripting language to reuse resources of Pascal. FUN's syntax is simple and clear, it comes from Ada and was changed for easy to use and input. FUN's exception handling syntax is similar to Delphi. FUN is dynamic typing and supports type conversions automatically when needed. FUN supports class-based object-oriented programming. FUN supports first-class functions functional programming, looks like Lisp and Javascript. FUN implements a simple and lightweight reference counting garbage collector. FUN's regular expressions handling is Perl-Compatible. FUN provides simple and powerful list process, it looks like arrays, associative arrays, hash tables, dictionaries or mappings too.
  • Fuzuli - JFuzuli is the JVM implementation of our programming language Fuzuli which is based on LISP syntax and Algol family programming logic. Fuzuli is a modern collaboration of these two separate family of languages.
  • GALATEA - Glider with Autonomous, Logic-based Agents, TEmporal reasoning and Abduction. GALATEA is software to model and simulate multi-agent systems. It is the product of two lines of research: simulation languages based on Zeigler's theory of simulation and logic-based agents. There is, in GALATEA, a proposal to integrate, in the same simulation platform, conceptual and concrete tools for multi-agent, distributed, interactive, continuous and discrete event simulation.
  • Gecho - Simple stack language in C. Has a few basic commands; working to implement a `while` loop and user-defined functions. If statement would be nice.
  • Gene - Gene is a common purpose programming language. It is inspired by languages such as object pascal, C++, sql and EBNF languages such as Coco/R, lex and yacc and is a pure object oriented language. It is therefor ideally suited for applications that process a lot of sequential input and output such as scanners, parsers and data generators. Gene also has build in support for container objects (objects that manage a list of other objects such as arrays, linked lists, queues, sql tables,...).
  • genyris - Inspired by the Semantic Web, Genyris presents a new programming paradigm. Objects can belong to multiple classes independent from construction. Indentation reduces parentheses yet retains the power of Lisp. External Java libraries can be imported.
  • GF - GF, Grammatical Framework, is a programming language for multilingual grammar applications. It is
  • GIPSY - A General Intensional Programming SYstem
  • Glee - The Glee Programming Language is a new vector oriented interpretive computer programming tool. It is inspired by array oriented languages like APL, J, and K. It attempts to deliver many of the useful and powerful features of those languages for manipulating numeric data. Further, it strives to provide new functionality for consistent and powerful manipulation of character data. It is targeted at applications where languages like PERL, Python, and Java have found secure homes. These are all scalar languages so Glee has something new to bring to the party ... vector processing.
  • gnarly - Design and Implementation of a Hybrid Typed Programming Language
  • Goal - Goal is an embeddable array programming language with a bytecode interpreter, written in Go. It provides both a command line intepreter (that can be used in the REPL), and a library interface. The core features are mostly there and tested, so Goal is usable both for writing useful short scripts and playing with the REPL. User testing and bug reports are welcome! Like in most array programming languages, Goal's builtins vectorize operations on immutable arrays, and encourage a functional style for control and data transformations, supported by a simple dynamic type system with little abstraction, and mutable variables (but no mutable values).
  • goaldi - Goaldi is a new general-purpose programming language that combines the goal-directed evaluation model of the Icon language with modern features such as concurrency, objects, closures, and Unicode support. While Goaldi will look familiar to Icon programmers, it is not upwards compatible.
  • Gofolio - the programming language for the ATARI portfolio
  • Golo - The world didn’t need another JVM language. So we built yet another one. A simple one.
  • GrADS - The Grid Analysis and Display System (GrADS) is an interactive desktop tool that is used for easy access, manipulation, and visualization of earth science data. GrADS has two data models for handling gridded and station data. GrADS supports many data file formats, including binary (stream or sequential), GRIB (version 1 and 2), NetCDF, HDF (version 4 and 5), and BUFR (for station data). GrADS has been implemented worldwide on a variety of commonly used operating systems and is freely distributed over the Internet.
  • Gremlin - Gremlin is a domain specific language for traversing property graphs. Gremlin makes use of Pipes to perform complex graph traversals. This language has application in the areas of graph query, analysis, and manipulation. Connectors, provided by Blueprints, exist for the following graph management systems:
  • Gui4Cli - Gui4Cli is an interpreted, untyped, procedural programming language for easily creating Windows apps. It has a wide set of commands, it can be easily extended and can create self-standing executables. It is Event-driven, and intuitive and geared to creating stand-alone guis or interfaces for other, console driven programs (as it's name implies). The new version can also handle Unicode.
  • gura - A programming language that comes with powerful operation on iterators.
  • GvR - Guido van Robot, or GvR for short, is a programming language and free software application designed to introduce beginners to the fundamentals of programming. GvR runs on Windows, Macintosh, and GNU/Linux, in a variety of languages! It's great in both the classroom and the home as a way of introducing people to the basic concepts of programming.
  • GZigZag - Zzstructure is a way of representing the structure of information. Compared with the previous ways, Zzstructure is very different, for example the concepts of 'file', 'folder' and 'application' are abandoned. Because of this a bit of fantasy, creativity and an ability to forget previous knowledge is needed in order to understand Zzstructure. A Zzstructure structure consists of cells and dimensions. A cell is the basic unit of information of a Zzstructure structure. Cells containing related information can be connected with each other along dimensions, the number of which is unlimited. A Zzstructure structure is separate from its visualisation (= the way the data is presented on the screen), which means that a Zzstructure structure can have many visualisations designed for different purposes.
  • Hachi - Hachi is a next-generation systems language that combines the speed and control of C++ with a clean, modern syntax and built-in memory safety without garbage collection, reference counting or borrow checking. It transpiles to highly optimized C++ for native performance while offering auto-free memory management through static lifetime analysis. Hachi makes it easy to embed C and C++ code directly in source files, giving developers seamless access to existing libraries and low-level control. It is designed for high-performance software and applications that need to run close to the metal, all while keeping the language simple, expressive, and enjoyable to write.
  • Happy - A scripting language with syntactic sugar for code generation. Happy has the concept of a "current output." The current output is simply a System.IO.TextWriter where all template output is directed. At the moment, the current output must be determined by the host program executing the Happy script. This is usually the command-line application, in which case the current output is directed at the file specified in one of the command-line options. A host program in which Happy has been embedded can specify any TextReader as the current output.
  • Harlan - Harlan is a domain specific language for programming GPUs. This project serves primarily as a testbed for implementation and optimization techniques. The language is intentionally small, in order to simplify the process of exploring new analyses and optimizations.
  • Heptagon - Heptagon is a synchronous dataflow language whose syntax and semantics is inspired from Lustre, with a syntax allowing the expression of control structures (e.g., switch or mode automata).
  • Herschel - Herschel is an general-purpose multiparadigm programming language. It is strongly typed, offering type inference and parametric polymorphism ("generics"). It is consequently object oriented (everything is a object, even functions), while its consequent multiple dispatch approach keeps a strong functional touch. The object model is class-oriented, supporting multiple inheritance as well as the separation of types ("protocols", "interfaces") and classes.
  • HicEst - Integrated development environment with graphical user interface designed for immediate results in the development of Windows applications.
  • Hop - a multitier JavaScript also supports the Scheme programming language. With Hop.js, JavaScript and Scheme are fully interoperable and applications can mix both languages. This page mostly describes the JavaScript layer. The Scheme layer is described in a dedicated programming manual.
  • hue - A functional programming language
  • HypoLambda - A very compact functional programming language for .NET. Its syntax is based on Python, but whitespaces are ignored. Everything is an expression. The language runtime is embeddable, its AST is accessible, and it compiles to portable pcode. There's a REPL you can play with, and the project includes lots of unit tests.
  • I - I is a programming language designed by the I Project. It has been designed to be efficient to write and run. The system incorporates many major libraries allowing the creation of major projects such as Aciqra. It is an interpreted language and supports CGI scripting through the use of the CGI for Aciv/I extension.
  • IBAL - IBAL is a functional language for specifying probabilistic models. Models in IBAL look like programs in a functional programming language. In the functional approach, a model is a description of a computational process. The process stochastically generates a value, and the meaning of the model is the distribution over the value generated by the process.
  • ICE - ICE: A new BASIC-like programming language for the CE calculators. ICE compiles a TI-BASIC-like language into eZ80 binary, the native machine code of the CE calculators.
  • Idle - Idle is a simple but powerful scripting language, in basically the same vein as the venerable Perl or Python languages. It is, however, an altogether more lightweight application: the basic installation zip weighs in at around 800 KB (and this includes the full documentation and loads of example scripts). At the core of Idle sits a tweaked and significantly enhanced version of Lua. Idle inherits from Lua its elegant and powerful language definition as well as a highly-optimised interpreter kernel (an extremely fast compiler is included as well). Idle, like Lua, is readily extended with additional functions, modules and libraries (which can be written either in C/C++ or in Idle itself).
  • IENJINIA - IPL is the IENJINIA Programming Language used in the IENJINIA Devkit to write games for the IENJINIA Virtual Console. It is a very simple interpreted language with dynamic typing, static scoping and automatic garbage collection.
  • ilang - ilang is designed to be a new type of programming lanuage that supports different types of programming paradimes with a focus towards artificial inteligence
  • ILYC - ILYC is an interpreted programming language with a simple and friendly syntax, which is suitable for beginners and hobbyist. The purposes of creating such a language was for the author to practice programming and for others to study how to implement an interpreter in the .NET framework.
  • IMP - IMP is an "ALGOL-like" high-level language that was originally designed as the implementation language for the Edinburgh Multi-Access System, developed at Edinburgh University. It was widely used at Edinburgh University for implementing systems, teaching programming and as a general purpose programming language on many different machines. Because IMP did not see significant commercial adoption (unlike its contemporary, C and later C++), it is not generally available on current platforms. For the Edinburgh Computing History Project, which aims to collect and publish significant software archives from Edinburgh University, this was a problem, because much of that software heritage is written in IMP. The solution - to produce an IMP compiler for current mainstream Intel x86 machines.
  • Impulse - Impulse is a small, dynamically typed, message based prototypical language written with simplicity in mind. Its syntax and semantics are derived mostly from Ruby, Io, Smalltalk and Dylan, and it's purpose is to be a smarter 'scripting' language, with features such as trait composition, extension methods (wich solves monkey-patching), and constructor field initialization. A core goal is to keep the language, both the implementation and the syntax, small and lightweight.
  • Incanter - Incanter is a Clojure-based, R-like platform for statistical computing and graphics.
  • ink - A narrative scripting language for games
  • Insanity - Insanity is a block-based programming language with powerful commands, such as file I/O, cloud variables, and much more. It is based off Scratch 1.4 by MIT.
  • interp - interp is a powerful programming language. Check-out the language features, then take the tour. It is targeted for Linux/Unix-based systems, yet remains adaptable to less powerful embedded systems that were never intended to host a programming language.
  • Ioke - Ioke is a dynamic language targeted at virtual machines, currently the Java Virtual Machine and the Common Language Runtime. It's been designed from scratch to be a highly flexible general purpose language. It is a prototype-based programming language that is inspired by Io, Smalltalk, Lisp and Ruby.
  • ipl - ipl stands for the Invocation (programming) Language, a concurrent programming language described by Karl Fant in his book Computer Science Reconsidered: The Invocation Model of Process Expression (Wiley-Interscience 2007).
  • IronAHK - IronAHK is a rewrite of AutoHotkey, a powerful and easy to use scripting language for automation on the desktop. It is developed in C# for .NET and Mono which brings cross-platform compatibility, increased performance, enhanced security, Unicode, native 64-bit support, smaller file sizes for compiled binaries and much more.
  • ironlua - IronLua currently features a working top-down-operator-precedence Lua 5.2 parser but no compiler for the time being. I do not plan on using the DLR. The solution also includes a C# interpreter, but it's all work-in-progress.