Awesome programming languages

The list of 397 awesome programming languages that you might be interested in. If you like exploring programming languages, or you are making your own programming language, then it's place for you. Here you can find interesting programming languages that are not well known or promote your own programming language. Also, it's the place to look for a new ideas and inspiration. Feel free to make a contribution.

Related:

• Awesome Programming Languages articles;
• See also section;

Contents

A (23):

• Ada - A programming language for readable, correct, and performant software. Get started with Alire, the Ada package manager.
• Adept - A blazing fast language for general purpose programming.
• Agda - Agda is a dependently typed functional programming language. It has inductive families, i.e., data types which depend on values, such as the type of vectors of a given length. It also has parametrised modules, mixfix operators, Unicode characters, and an interactive Emacs interface which can assist the programmer in writing the program.
• Agena - Agena is an easy-to-learn procedural programming language suited to be used in scientific, mathematical, scripting, networking, and many other applications. Binaries are available for Solaris, Windows, Linux, OS/2, Mac OS X, Raspberry Pi and DOS.
• Aith - Low level functional programming language with linear types, Generalized Inline Functions, levity polymorphism and regions. Aith is a perfomant systems programming language with am empathises on type systems. As of now Aith is very early stages and very little is implemented.
• Alan - Alan is a Autoscalable Programming Language:
  • 🔭 Predictable runtime for all computations - A program is represented as DAG(s) where the running time for all computations can be predicted because there is no unbounded recursion or iteration;
  • ⛓ Automatic IO concurrency and parallelism across events and arrays - Alan exploits opportunities for IO concurrency or CPU parallelization across machines in a cluster via arrays and a static event loop without threads, channels, promises, futures, locks, etc;
  • ✅ Almost no runtime errors - No deadlocks, livelocks, undefined variables, divide-by-zero, integer under/overflow, array out-of-bounds access, etc;
  • ⚡️ No GC pauses - Alan’s runtime manages memory allocation, access, and deallocation for you like Java, Python, or Javascript. However, Alan’s static event system and automatic event-oriented memory model does so without garbage collector pauses.
• Alumina - Alumina is an imperative, general-purpose, statically typed, compiled system programming language. Alumina is heavily inspired by Rust, especially in terms of syntax and standard library API. Unlike Rust, however, Alumina is not memory-safe and it requires manual memory management.
• AngelScript - AngelScript is an extremely flexible cross-platform scripting library designed to allow applications to extend their functionality through external scripts. It has been designed from the beginning to be an easy to use component.
• Ante - Ante is a low-level functional language for exploring refinement types, lifetime inference, and other fun features. In general, ante is low-level (no GC, values aren't boxed by default) while also trying to be as readable as possible by encouraging high-level approaches that can be optimized with low-level details later on.
• Antimony - Antimony is a general-purpose toy language. Its primary goal is to be simple and easy to understand, not to be efficient.
• Apex - Apex is an interface definition language (IDL) for modeling software. Generate source code, documentation, integration, everything automatically.
• Ape - Ape is an easy to use programming language and library written in C. It's an offspring of Monkey language, but it evolved to be more procedural with variables, loops, operator overloading, modules, and more.
• APL - APL (named after the book A Programming Language) is a programming language developed in the 1960s by Kenneth E. Iverson. Its central datatype is the multidimensional array. It uses a large range of special graphic symbols to represent most functions and operators, leading to very concise code. It has been an important influence on the development of concept modeling, spreadsheets, functional programming, and computer math packages. It has also inspired several other programming languages.
• April - April (Array Programming Re-Imagined in Lisp) - The APL programming language (a subset thereof) compiling to Common Lisp.
• Arend - Arend is a theorem prover and a programming language based on Homotopy Type Theory.
• Argon - Argon is an interpreted multi-paradigm dynamically typed programming language. Its syntax is mainly influenced by Python, Go and Rust.
• Argo - Pragmatic functional programming language.
• ArkScript - ArkScript is a small, fast, functional and scripting language for C++ projects ; the syntax is inspired by Lisp. It's a scripting language aiming for high portability and easily embedding in C++ projects, with a few nice features such as tail call optimization and macros.
• Ark - Ark is a tiny, fast, and somewhat useful programming language focused on runtime stability and simple code syntax. Every instruction is a single character, but it is NOT an esolang. (anymore)
• Arturo - Arturo is an independently-developed, modern programming language, vaguely related to various other ones - including but not limited to Logo, Rebol, Forth, Ruby, Haskell, D, SmallTalk, Tcl, and Lisp. The language has been designed following some very simple and straightforward principles: a) Code is just a list of words and symbols, b) Words and symbols within a block are interpreted - when needed - according to the context, c) No reserved words or keywords - look for them as hard as you can; there are absolutely none.
• ATS - Unleashing the Potentials of Types and Templates.
• Austral - A systems programming language that uses linear types to provide memory safety and capability-secure code. [linear types]
• Avail - Avail is a multi-paradigmatic general purpose programming language whose feature set emphasizes support for articulate programming. Avail is an open-source project that comprises a language virtual machine and a standard library.

B (24):

• B4X - Simple, powerful and modern development tools. With B4X, anyone who wants to, can develop real-world solutions.
• Backlang - A new Rust, C# inspired Language for .Net
• BAIK - BAIK is a scripting language which syntax is in Indonesian for Windows and Linux on Server, Desktop, Laptop and Embedded Computer, including IoT. It supports GPIO, Animation, PDF, UTF8, Printer, OOP, GUI, CGI, Databases, Graphics and TCP/IP.
• Bait - Bait is a compiled general purpose programming language with a simple syntax but still powerful feature set and standard library for building reliable software.
• Ballerina - Ballerina is an open-source programming language for the cloud that makes it easier to use, combine, and create network services.
• Barn - Barn is a simple programming language written in GoLang and compiled to C++. Syntax is very simple, and Barn can call C/C++ functions natively so creating new bindings should be easy. Barn was written with the goal of being as fast and easy to use as possible. Barn is just a little project with which I can chill and just code.
• Beads - The Beads project is a daring attempt to generate a new language that will replace the current popular toolchain stack of HTML/CSS/JS/+Frameworks+Database, with a single language.
• Beanshell - BeanShell is a small, free, embeddable Java source interpreter with object scripting language features, written in Java. BeanShell dynamically executes standard Java syntax and extends it with common scripting conveniences such as loose types, commands, and method closures like those in Perl and JavaScript.
• Beef - Beef is a performance-oriented compiled programming language.
• Berry - A ultra-lightweight embedded scripting language optimized for microcontrollers.
• Beryl - Beryl is a small, interpreted, embeddable scripting language with value semantics and first class functions. The main feature of Beryl is that the core interpreter can run without any dynamic memory allocation*, and it does not need to parse or compile scripts beforehand. It can also be built without any external dependencies, excluding some typedefines and constants needed from stddef.h and limits.h; however these could be provived from a custom header if needed.
• Bhl - BeHavior Language is a strictly typed programming language specifically tailored for gameplay logic scripting.
• Bite - Bite is a dynamically typed, object oriented programming language. Dynamically typed, because the type of the content of a variable can change during runtime of the program. Object-oriented, because you can define classes to encapsulate your code and data. Bite uses modules, classes and functions to separate code.
• Blade - Blade is a simple, clean, and embeddable dynamic programming language created to be simple enough for beginners, yet powerful and expressive for professionals. It has a very small syntax set with a very low learning curve. Blade improves upon the best features of JavaScript, Python, and Ruby to give developers a familiar and powerful system that feels native for developers coming from any of these languages and an easy way to leverage the strength of any.
• Blech - Blech is a language for developing reactive, real-time critical embedded software.
• BlitzMax - BlitzMax is a fast cross-platform, open-source programming language.
• Blue - The Blue Programming Language, A powerful, V E R Y Easy to use language, that can compile to eight of your favourite languages. A compiled, dynamically typed, object oriented programming language. Coming in at only 30 keywords, this is an easy to use language with unseen compiler speed. Blue is extremely powerful thanks to it's small, compact, file size. It was written in only 3200 lines of Haxe code.
• BL - The Biscuit Language (BL) is simple imperative programming language using LLVM backend implemented in C. Biscuit is designed to be simple, fast and explicit. Language syntax is inspired by JAI.
• Boba - A general purpose statically-typed concatenative programming language. Key features include:
  • Expressive, mostly implicit static types and kinds
  • Language-incorporated unit and property tests + runners
  • Algebraic effects via scoped effect handlers
  • Algebraic data types and pattern matching on constructors
  • Compile-time resolved function overloading
  • Structurally typed tuples, records and variants
  • Byte-code VM-in-Go backend with straight-forward first-order FFI access
  • Familiar looping, branching, and variable definition syntax constructs
• Bolin - A general purpose language that is:
  • Designed to be readable;
  • Automatic memory management (no gc, no rc);
  • Has features not found in any other language (See a few on the highlights page)
  • Matches C execution speed, occasionally Bolin is faster;
  • Has a more optimal standard library;
  • Compiles 2.5 million lines per second on a laptop (MacBook Air with an M2 chip).
• Boron - Boron is a scripting language similar to REBOL. The interpreter is a C library which may be copied under the terms of the LGPLv3.
• Bosque - Bosque is an open-source project focused on developing a new Programming Language and Development Tooling Stack. The foundation of this project is the view that mechanization and automated reasoning, along with human and AI agents that leverage them, are the ideas that will define the next era of software development. The foundation of the Bosque language and stack is a carefully constructed core calculus and computation model that are uniquely amenable to automated reasoning. Building on top of this core calculus the Bosque language, as seen by a developer, is a hybrid of functional programming design, ergonomic block & assignment-based syntax, and a number of new features designed to simplify and support writing high reliability code.
• BQN - An APL-like programming language. Self-hosted!
• Brython - A Python 3 implementation for client-side web programming.

C (40):

• Ć - Ć is a programming language which can be translated automatically to C, C++, C#, Java, JavaScript, Python, Swift, TypeScript and OpenCL C. Instead of writing code in all these languages, you can write it once in Ć:
• C2 - An evolution of C.
• C3 - C3 is a C-like language trying to be "an incremental improvement over C" rather than a whole new language.
• C∀ - C∀ (Cforall) is a language design extending ISO C. The purpose of the project is to engineer modern language features into C in an evolutionary rather than revolutionary way. Java is an example of the revolutionary approach of modernizing C/C++, resulting in a new language rather than an extension of its descendents. C++, Fortran 95 and Cobol 9X are examples of the evolutionary approach where modern language features are added and problems fixed within the framework of an existing language.
• Cakelisp - A metaprogrammable, hot-reloadable, non-garbage-collected language ideal for high performance, iteratively-developed programs (especially games).
• CakeML - CakeML is a verified implementation of a significant subset of Standard ML.
• Calcit - Calcit is an interpreter built with Rust, and also a JavaScript code emitter. It's inspired mostly by ClojureScript. Calcit-js emits JavaScript in ES Modules syntax.
• Cane - A small MIDI sequencer DSL designed around vectors and euclidean rhythms.
• Carbon - Carbon is fundamentally a successor language approach, rather than an attempt to incrementally evolve C++. It is designed around interoperability with C++ as well as large-scale adoption and migration for existing C++ codebases and developers.
• Carp - A statically typed lisp, without a GC, for real-time applications. Carp is a small programming language designed to work well for interactive and performance sensitive use cases like games, sound synthesis and visualizations.
• Cassette - A new evolutionary highlevel and readable tape language (unlike brainf), with pattern matching, arity overloading, modules, lambdas (rather quotes) and much more; All topped on with a simple and aesthetic syntax.
• Cat9 - Cat9 is a user shell script for LASH - a command-line shell that discriminates against terminal emulators, written in Lua. You probably have not heard of LASH before. If you really must know, check the Backstory section below. LASH just provides some basic shared infrastructure and a recovery shell. It then runs a user provided script that actually provides most of the rules for how the command line is supposed to look and behave.
• Céu - Céu is a reactive language that aims to offer a higher-level and safer alternative to C.
• ChaiScript - ChaiScript is one of the only embedded scripting language designed from the ground up to directly target C++ and take advantage of modern C++ development techniques, working with the developer how they would expect it to work. Being a native C++ application, it has some advantages over existing embedded scripting languages:
  • It uses a header-only approach, which makes it easy to integrate with existing projects.
  • It maintains type safety between your C++ application and the user scripts.
  • It supports a variety of C++ techniques including callbacks, overloaded functions, class methods, and stl containers.
• Chapel - Chapel 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.
• Charm - Charm is a data-oriented scripting language.
• Ciao - Ciao is a modern Prolog implementation that builds up from a logic-based simple kernel designed to be portable, extensible, and modular.
• Cicada - Cicada language is a dependently typed programming language and an interactive theorem prover. The aim of cicada project is to help people understand that developing software and developing mathematics are increasingly the same kind of activity, and people who practices these developments, can learn from each other, and help each other in very good ways.
• Circle - Circle is the richest C++ compiler yet. Circle describes a path for evolving C++ to meet the needs of institutional users. The versioning mechanism that accommodated the development of the features above will also accommodate research into critically important areas like memory safety. Rather than insisting on a one-size-fit's-all approach to language development, project leads can opt into collections of features that best target their projects' needs. Features:
  • choice types;
  • pattern matching;
  • interfaces and impls;
  • language type erasure;
  • as-expressions for safer conversions;
  • a modern declaration syntax with fn and var keywords to make clearer, less ambiguous declarations;
  • a simpler syntax for binary expressions, greatly reducing the likelihood of bugs caused by confusing operator precedences;
  • a forward keyword to take the complexity and bugginess out of forwarding references;
  • safer initializer lists, which address ambiguities when calling std::initializer_list constructors and non-std::initializer_list constructors;
  • lifting lambdas to pass overload sets as function arguments;
  • nine kinds of template parameters to make templates far more comprehensive;
  • reflection traits to access packs of information about class types, enum types, function types, class specializations, and so on;
  • pack traits for pack-transforming algorithms, like sort, unique, count, erase, difference, intersection, and so on.
• Cish - A minimal, performant, strongly-typed, and multi-paradigm programming language focused on being practical and pragmatic, yet powerful enough to create readable, performant and concise code for any problem. While Cish has as much to do with Forth as Javascript has with Java, it shares the same minimalist, performance oriented approach and philosophy.
• Clojure - A dialect of Lisp, and shares with Lisp the code-as-data philosophy and a powerful macro system. Clojure is predominantly a functional programming language, and features a rich set of immutable, persistent data structures. When mutable state is needed, Clojure offers a software transactional memory system and reactive Agent system that ensure clean, correct, multithreaded designs.
• Clue - Clue is a programming language that compiles into Lua code with a syntax similar to languages like C or Rust. Clue tries to be almost as simple as Lua (with only a slightly more advanced syntax) but adds many optional features that can make code look better or make some things (like metatables) easier to code. Clue does not compile to a specfic version of Lua: flags can be toggled to alter the output to allow most if not all versions or modifications of Lua to be compiled to with Clue.
• Cmajor - Cmajor is an experimental programming language strongly influenced by C++ and C#. It is semantically closer to C++ than C# and syntactically closer to C# than C++.
• Cmajor - Cmajor is a programming language for writing fast, portable audio software. Cmajor specifically designed for writing DSP signal processing code.
• COBOL - COBOL is a compiled English-like computer programming language designed for business use. It is an imperative, procedural and, since 2002, object-oriented language.
• Coconut - Simple, elegant, Pythonic functional programming.
• Cod - Cod is an opensource concatenative stack-based general purpose programming language. Its transpiled to C and then compiled further to a native executable using external compilers like GCC.
• Cognate - Cognate is a quasi-concatenative stack oriented language that uses embedded comments to read like English prose. It is a dynamic language (yet compiled) and makes great use of combinators and higher order functions. Cognate aims to make functional programming simple, readable, and maintainable.
• Common Expression Language - The Common Expression Language (CEL) implements common semantics for expression evaluation, enabling different applications to more easily interoperate.
• Common Lisp - A dialect of the Lisp programming language, published in ANSI standard document ANSI INCITS 226-1994. Common Lisp is not an implementation, but rather a language specification. Several implementations of the Common Lisp standard are available, including free and open-source software and proprietary products. Common Lisp is a general-purpose, multi-paradigm programming language. It supports a combination of procedural, functional, and object-oriented programming paradigms.
• Compis - Contemporary systems programming language in the spirit of C.
• Component Pascal - Component Pascal is a programming language in the tradition of Niklaus Wirth's Pascal, Modula-2, Oberon and Oberon-2. It bears the name of the language Pascal and preserves its heritage, but is incompatible with Pascal. Instead, it is a minor variant and refinement of Oberon-2 with a more expressive type system and built-in string support.
• Cone - Cone is a fast, fit, friendly, and safe systems programming language. Ideal for complex, data-rich programs requiring responsive performance (e.g., 3D).
• Coq - Coq is a formal proof management system. It provides a formal language to write mathematical definitions, executable algorithms and theorems together with an environment for semi-interactive development of machine-checked proofs.
• 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.
• Covariant Script - Covariant Script is an open source, cross-platform programming language. High-performance runtime environment. Self-developed efficient compilation system. Powerful and bloat-free extension system
• Cowgol - A self-hosted Ada-inspired programming language for very small systems. Cowgol is an experimental, Ada-inspired language for very small systems (6502, Z80, etc). It's different because it's intended to be self-hosted on these devices: the end goal is to be able to rebuild the entire compiler on an 8-bit micro, although we're not there yet.
• Crystal - Crystal is a language with a Ruby like sintax, statically type-checked. It supports compile-time evaluation and code generation. It compiles to efficient native code.
• Cubiml - Cubiml is a simple ML-like programming language with subtyping and full type inference. You can try it out online in your browser here.
• Cyber - Cyber is a fast, efficient, and concurrent scripting language. You can embed it into your applications, games, or engines on desktop or web. Cyber also comes with a CLI, so you can do scripting on your computer.

D (13):

• D - General-purpose programming language with static typing, systems-level access, and C-like syntax.
• Dafny - Dafny is a verification-ready programming language. As you type in your program, Dafny's verifier constantly looks over your shoulder, flags any errors, shows you counterexamples, and congratulates you when your code matches your specifications. When you're done, Dafny can compile your code to C#, Java, JavaScript or Go (more to come!), so it can integrate with your existing workflow.
• Dale - Dale is a system (no GC) programming language that uses S-expressions for syntax and supports syntactic macros. The basic language is similar to C, with the following additional features:
  • local type deduction;
  • overloaded functions;
  • anonymous functions;
  • reference parameters;
  • initializers and destructors;
  • variants;
  • namespaces;
  • modules;
  • concepts; and
  • compiler introspection.
• Dark Basic Pro - Dark Basic Pro is an open source BASIC programming language for creating Windows applications and games.
• Dart - Dart is a programming language designed for client development, such as for the web and mobile apps. It is developed by Google and can also be used to build server and desktop applications. It is an object-oriented, class-based, garbage-collected language with C-style syntax. It can compile to either native code or JavaScript, and supports interfaces, mixins, abstract classes, reified generics and type inference. Primarally used with the Flutter GUI toolkit.
• daScript - high-performance statically strong typed scripting language.
• Dictu - Dictu is a high-level dynamically typed, multi-paradigm, interpreted programming language.
• Draco - a new .NET programming language under development. If you want further details on the language itself or want to contribute ideas, head over to the language suggestions repository.
• Dragon - The Dragon is an innovative and practical general-purpose language. The supported programming paradigms are imperative, object-oriented, declarative using nested structures, functional and natural programming. The language is portable (Windows, Linux, macOS, etc.) and can be used to create Console and GUI. The language is designed to be simple, small, flexible and fast.
• DWScript - DWScript is an object-oriented scripting engine for Delphi based on the Delphi language, with extensions borrowed from other Pascal languages (FreePascal, Prism, etc.). It introduces a few Pascal language extensions of its own as well.
• Dyalect - Dyalect is a dynamic programming language for .NET platform. It is lightweight, fast and modern. Dyalect (or Dy for short) supports Windows, MacOS and Linux. Dy runs on the top of its own high performance virtual machine. It compiles fast and can be used as an embeddable language or as a scripting language of your choice. It is also a good language to learn programming. Dyalect offers modern syntax, inspired by such languages as C#, Swift, Go and Rust, first class functions, coroutines, expressive modules, a dynamic type system with an ability to extend existing types with new methods and much more.
• Dylan - Dylan is a multi-paradigm functional and object-oriented programming language. It is dynamic while providing a programming model designed to support efficient machine code generation, including fine-grained control over dynamic and static behaviors.
• Dyon - A rusty dynamically typed scripting language.

E (19):

• Easylang - An easy programming language that runs in the browser. Easylang is a rather minimalistic simple programming language. Because of the clear syntax and semantics it is well suited as a teaching and learning language. Functions for graphic output and mouse input are built into the language. The language is written in C and is open source. Main target platform is the web browser using WASM. However, it also runs natively in Windows and Linux. The one-pass parser and compiler is quite fast. In the Web IDE, each time the Enter key is pressed, the program is parsed and formatted up to the current line.
• Ecstasy - Ecstasy is a new, general-purpose, programming language, designed for modern cloud architectures, and explicitly for the serverless cloud. Actually, to be completely honest, it's the most amazing programming language ever. No, really, it's that awesome.
• eC - An Expressive and Intuitive, C Style Object-Oriented Programming Language. eC comes bundled with the Ecere SDK, providing a comprehensive API for building apps ranging from games to business, for desktop, mobile and web platforms.
• Edina - Edina - A simple stack-oriented compiled programming language. Edina is a simple multi-paradigm programming language. It currently features a JVM compiler, a REPL and an ever expanding standard library. Edina is mostly a hobby project. Due to its stack-oriented design it's a little restrictive and hard to program in, but that's what makes it fun in my opinion.
• Effekt - A research language with effect handlers and lightweight effect polymorphism.
• Egel - Egel is an untyped concurrent functional scripting language based on eager combinator rewriting with a concise but remarkably powerful syntax.
• Eiffel - Based on a set of principles, including design by contract, command–query separation, the uniform-access principle, the single-choice principle, the open–closed principle, and option–operand separation.
• Electra - Electra is an esolang where you code like an electrician. Electra is inspired by AsciiDots. It uses instruction pointers that acts like currents in electricity. [eso]
• Elena - ELENA is a general-purpose language with late binding. It is multi-paradigm, combining features of functional and object-oriented programming. Rich set of tools are provided to deal with message dispatching : multi-methods, message qualifying, generic message handlers, run-time interfaces.
• Elixir - A dynamic, functional language for building scalable and maintainable applications. Elixir leverages the Erlang VM, known for running low-latency, distributed, and fault-tolerant systems. Elixir is successfully used in web development, embedded software, data ingestion, and multimedia processing, across a wide range of industries.
• Elm - Elm is a functional language that compiles to JavaScript. It helps you make websites and web apps. It has a strong emphasis on simplicity and quality tooling.
• EmojiCode - World’s only programming language that’s bursting with emojis. Emojicode is an open source, high-level, multi-paradigm programming language consisting of emojis. It features Object-Orientation, Optionals, Generics and Closures.
• Enchilada - Enchilada is optimized to efficiently and consistently share huge amounts of data (and code) in a distributed environment. Possible use cases:
  • Distributed and authenticated computation/code;
  • Distributed and authenticated dependency management.
• Eolang - EO (stands for Elegant Objects or ISO 639-1 code of Esperanto) is an object-oriented programming language based on 𝜑-calculus. We're aware of popular semi-OOP languages and we don't think they are good enough, including Java, Ruby, C++, Smalltalk, Python, PHP, C#: all of them have something we don't tolerate. EO is not planning to become a mainstream language—this is not what we want. Our main goal is to prove to ourselves that true object-oriented programming is practically possible. Not just in books and abstract examples, but in real code that works. That's why EO is being created—to put all that "crazy" pure object-oriented ideas into practice and see whether they can work.
• Erg - A statically typed language that can deeply improve the Python ecosystem.
• Erlang - A programming language used to build massively scalable soft real-time systems with requirements on high availability. Some of its uses are in telecoms, banking, e-commerce, computer telephony and instant messaging. Erlang's runtime system has built-in support for concurrency, distribution and fault tolerance.
• Eta - What is Eta? Eta is a pure, lazy, strongly typed functional programming language on the JVM. It brings two big ecosystems, the JVM and Haskell, together. This allows you to harness the best of both ecosystems to build your applications quickly and effectively. Eta's concurrency support helps you to build highly scalable systems.
• Euphoria - Euphoria is a powerful but easy-to-learn and easy-to-use programming language. It has a simple syntax and structure with consistent rules, and is also easy to read. You can quickly, and with little effort, develop applications big and small for Windows and UNIX variants (Linux, FreeBSD, and OS X).
• Expr - Expression language and expression evaluation for Go.

F (24):

• F# - a functional-first, general purpose, strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. Developed by Microsoft for the .NET platform.
• F* - F* (pronounced F star) is a general-purpose functional programming language with effects aimed at program verification. It puts together the automation of an SMT-backed deductive verification tool with the expressive power of a proof assistant based on dependent types. After verification, F* programs can be extracted to efficient OCaml, F#, C, WASM, or ASM code. This enables verifying the functional correctness and security of realistic applications. The main ongoing use case of F* is building a verified, drop-in replacement for the whole HTTPS stack in Project Everest. This includes verified implementations of TLS 1.2 and 1.3 and of the underlying cryptographic primitives.
• Factor - Factor is a concatenative, stack-based programming language with high-level features including dynamic types, extensible syntax, macros, and garbage collection.
• Falcon - Falcon is an Open Source, simple, fast and powerful programming language, easy to learn and to feel comfortable with, and a scripting engine ready to empower mission-critical multithreaded applications. Falcon provides six integrated programming paradigms: procedural, object oriented, prototype oriented, functional, tabular and message oriented. And you don't have to master all of them; you just need to pick the ingredients you prefer, and let the code follow your inspiration.
• Fantom - Fantom is a portable language that runs on the JVM and modern web browsers. It features a familiar Java-like syntax, static (and dynamic) typing, elegant system library, closures, immutability, actor concurrency, and much more.
• Fanx - Fanx is a full-stack programming language base on Fantom. It is an object oriented and static typing language with elegant libraries.
• Faust - Faust (Functional Audio Stream) is a functional programming language specifically designed for real-time signal processing and synthesis. A distinctive characteristic of Faust is to be fully compiled.
• 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.
• Fe - A tiny, embeddable language implemented in ANSI C.
• FixScript - FixScript is an extensible scripting language designed for simple implementation and strong support for both backward and forward compatibility. You can use FixScript both as a standalone and embedded programming language. You can build standalone native executables for any supported platform from every platform. The best results are obtained when combined with the C language to get a very powerful tool. This way you can use the best of the two worlds, using the language for the high-level stuff and C doing the interoperability and fast stuff while having a good integration between both languages.
• 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.
• Formality - Formality is an efficient proof language. An lightweight proof-gramming language. It aims to be:
  • Fast: no garbage-collection, optimal beta-reduction, massively parallel compilers.
  • Secure: a powerful type system capable of proving mathematical theorems.
  • Portable: the entire language desugars to a 500 lines core type-theory.
• 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.
• Forth - A procedural, stack-oriented programming language and interactive environment. Forth is used in the Open Firmware boot loader, in space applications such as the Philae spacecraft, and in other embedded systems which involve interaction with hardware. Multiple implementaitons, both proprietary and FOSS.
• Fortran - A general-purpose, compiled imperative programming language that is especially suited to numeric computation and scientific computing. It has been in use for over six decades in computationally intensive areas such as numerical weather prediction, finite element analysis, computational fluid dynamics, geophysics, computational physics, crystallography and computational chemistry. It is a popular language for high-performance computing and is used for programs that benchmark and rank the world's fastest supercomputers.
• 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.
• 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.

G (17):

• Gambas - Gambas is a full-featured object language and development environment built on a BASIC interpreter.
• GameMonkey Script - Embedded scripting language for C++ apps, tools and games.
• Garnet - what if Rust was small?
• GDScript - Scripting language built into the Godot game engine. GDScript is a high-level, dynamically typed programming language used to create content. It uses a syntax similar to Python (blocks are indent-based and many keywords are similar). Its goal is to be optimized for and tightly integrated with Godot Engine, allowing great flexibility for content creation and integration.
• 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.
• 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).
• 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.
• Guile - Guile is designed to help programmers create flexible applications that can be extended by users or other programmers with plug-ins, modules, or scripts. With Guile you can create applications and games for the desktop, the Web, the command-line, and more.
• Gwion - A strongly-timed programming language aimed at music creation. Heavily inspired by ChucK.

H (17):

• Hack - Hack is built specifically for HHVM, a high performance runtime for your Hack applications, and reconciles the fast development cycle of a dynamically typed language with the discipline provided by static typing, while adding many features commonly found in other modern programming languages.
• 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.
• Hare - Hare is a systems programming language designed to be simple, stable, and robust. Hare uses a static type system, manual memory management, and a minimal runtime. It is well-suited to writing operating systems, system tools, compilers, networking software, and other low-level, high performance tasks.
• 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]
• HGSL - A shading language that can be compiled into GLSL ES 3.0.
• 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.
• Húngaro - A syntax based programming language.
• 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.

I (6):

• 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.
• Inko - Inko is a statically-typed, safe, object-oriented programming language for writing concurrent programs.
• 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.
• 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]

J (12):

• 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.
• JME - Java Math Expression - a powerful mathematical evaluator in Spanish and a structured script language, JMEScript, that makes use of it.
• JS++ JS++ is a programming language designed for high-quality web and mobile development.
• 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.
• Juvix - A more elegant language for a more civilized age. Juvix synthesizes a high-level frontend syntax, dependent-linearly-typed core language, whole-program optimisation system, and backend-swappable execution model into a single unified stack for writing formally verifiable, efficiently executable smart contracts which can be deployed to a variety of distributed ledgers.
• 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.

K (9):

• 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).
• Kawa - Kawa is a general-purpose programming language that runs on the Java platform. It aims to combine:
  • the benefits of dynamic scripting languages (non-verbose code with less boiler-plate, fast and easy start-up, a REPL, no required compilation step); with
  • the benefits of traditional compiled languages (fast execution, static error detection, modularity, zero-overhead Java platform integration).
• Kind - A minimal, efficient and practical programming language that aims to rethink functional programming from the scratch, and make it right. Under the hoods, it is basically Haskell, except without historical mistakes, and with a modern, consistent design. On the surface, it aims to be more practical, and to look more like conventional languages. Kind is statically typed, and its types are so powerful that you can prove mathematical theorems on it.
• 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:
  • An interactive console for testing code;
  • An interpreter;
  • A native-code compiler producing static executables (incomplete).
• Koka - Koka: a functional language with effects. Koka is a strongly typed functional-style language with effect types and handlers.
• K - A proprietary array processing programming language developed by Arthur Whitney and commercialized by Kx Systems. The language serves as the foundation for kdb+, an in-memory, column-based database, and other related financial products. The language, originally developed in 1993, is a variant of APL and contains elements of Scheme. Advocates of the language emphasize its speed, facility in handling arrays, and expressive syntax.

L (12):

• 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.
• 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.
• 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.
• Luau - A fast, small, safe, gradually typed embeddable scripting language derived from Lua.
• 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.

M (25):

• Macro Lambda Calculus - lambda calculus using interaction nets, providing CLI and API. Its browserified version is available as an online demo.
• Magmide - A dependently-typed language intended to make provably correct code possible for working software engineers.
• 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.
• Mbeddr - mbeddr is a set of integrated and extensible languages for embedded software engineering, plus an IDE. It supports implementation, testing, verification and process aspects. It integrates with command-line build tools and integration servers, as well as file-based version control systems. mbeddr has support for requirements and product line definition, software documentation, implementation in C and C extensions such as state machines physical units or interfaces and components, as well as testing, mocking, as well as formal verification. mbeddr comes with a state-of-the-art IDE including syntax coloring, code completion, go to definition, realtime type checks, quick fixes, refactorings, customizable find-usages, automated synchronization between related parts of the code, version control integration and debugging.
• Melody - Melody is a language that compiles to regular expressions and aims to be more easily readable and maintainable.
• Mercury - Mercury is a logic/functional programming language which combines the clarity and the expressiveness of declarative programming with advanced static analysis and error detection features.
• MetaLang 99 - A functional language for C99 preprocessor metaprogramming.
• MiniScript - MiniScript is modern, elegant, easy to learn, and easy to embed in your own C#, C++ or Kotlin projects.
• Minsk - Minsk, a handwritten compiler in C#. It illustrates basic concepts of compiler construction and how one can tool the language inside of an IDE by exposing APIs for parsing and type checking.
• Min - A small but practical concatenative programming language and shell.
• Mn - A truly minimal concatenative programming language.
• Modula-2 - Modula-2 is a programming language developed by Niklaus Wirth at ETH in Zurich, Switzerland in the late 70's. Wirth also developed Algol-W, Pascal, Modula, and Oberon. Modula-2 corrects some of the deficiencies of Pascal. It is suitable for learning programming, for large projects written and maintained in the fashion of professional software engineers, and for real time embedded systems. Modula-2 is small, expressive, easy to learn and to read.
• Modula-3 - Critical Mass Modula-3.
• Mond - A scripting language for .NET Core. You can try it in a browser here.
• Monkey 2 - Monkey2 is an easy to use, cross platform, games oriented programming language from Blitz Research.
• Monkey X - A games oriented programming language from Blitz Research.
• Monkey - Monkey is a programming language designed by Thorsten Ball.
• MoonScript - MoonScript is a dynamic scripting language that compiles into Lua. It gives you the power of one of the fastest scripting languages combined with a rich set of features.
• Motion - Motion is a clean, dynamically typed programming language, created in C with no dependencies.
• Motorway - An esoteric programming language based around the British motorway network.
• MUMPS - "Massachusetts General Hospital Utility Multi-Programming System", or M, is a high performance transaction processing key–value database with integrated programming language. It was originally developed at Massachusetts General Hospital for managing hospital laboratory information systems. MUMPS technology has since expanded as the predominant database for health information systems and electronic health records in the United States. MUMPS-based information systems run over 40% of the hospitals in the U.S., run across all of the U.S. federal hospitals and clinics, and provide health information services for over 54% of patients across the U.S.
• Mun - A programming language empowering creation through iteration.

N (15):

• Nelua - Nelua (stands for Native Extensible Lua) is a minimal, efficient, statically-typed and meta-programmable systems programming language heavily inspired by Lua, which compiles to C and native code.
• Neptune - A fast, a dynamically typed, concurrent and embeddable scripting language.
• Neut - A dependently-typed programming language with compile-time malloc/free determination.
• Never - Never is a simple functional programming language. Technically it may be classified as syntactically scoped, strongly typed, call by value, functional programming language.
• NewLang - NewLang is a high-level programming language that combines standard algorithmic constructs with declarative programming and tensor computing for machine learning problems. The main feature of the language is an easy, logical and non-contradictory syntax, which is not based on the use of reserved keywords, but on a strict system of grammatical rules using punctuation marks (which also includes language operators).
• Nimskull - An in development statically typed systems programming language; with sustainability at its core. We, the community of users, maintain it.
• Nim - Nim is a compiled, garbage-collected systems programming language with a design that focuses on efficiency, expressiveness, and elegance (in that order of priority).
• Nit - Nit is an expressive language with a script-like syntax, a friendly type-system and aims at elegance, simplicity and intuitiveness.
• Nix - Expression language for the Nix package manager. The Nix expression language is a pure, lazy, functional language.
• Noja - Noja is a high level language with dynamic typing inspired from CPython, which features an import system, type assertions, multiple return values and more!
• North-Hollywood Python - A strongly-typed, memory-safe, compiled dialect of Python, that transpiles to human-readable C.
• Nox - Nox is a programming language written in Rust. Memory and thread safety without compromising performance are the most important goal. Performance is also the most important goal. The language should be as simple as it possibly can given the above goals.
• NPL - NPL or Neural Parallel Language is an open source, high-performance scripting language.
• Nsbasic - A complete, powerful development environment. Create apps for iOS, Android, Windows, MacOS and Linux.
• NullC - Fast C-like programming language with advanced features.

O (14):

• Oak - A portable programming language with an incredibly compact backend.
• Oberon - Oberon is a general-purpose programming language first published in 1987 by Niklaus Wirth and the latest member of the Wirthian family of ALGOL-like languages (Euler, ALGOL W, Pascal, Modula, and Modula-2).
• Oberon+ - Oberon+ is a general-purpose, procedural and object-oriented programming language in the tradition of Oberon-07 and Oberon-2. The most important features of Oberon+ are block structure, modularity, separate compilation, static typing with strong type checking, generic programming, garbage collection, and type extension with type-bound procedures.
• Objeck - Objeck is an object-oriented programming language with functional features. Objeck emphasizes, expression, simplicity, portability, and scalability. The programming environment consists of a compiler, virtual machine, and command line debugger with IDE plugins.
• Objective-J - Objective-J is a new programming language based on Objective-C. It is a superset of JavaScript, which means that any valid JavaScript code is also valid Objective-J code. Anyone familiar with JavaScript and object-oriented programming concepts, classical inheritance in particular, should have no difficulty learning Objective-J. Familiarity with Objective-C will be helpful, but it is not required.
• OCaml - A general-purpose, industrial-strength programming language with an emphasis on expressiveness and safety. OCaml is a multi-paradigm programming language which extends the Caml dialect of ML with object-oriented features.
• Odin - The Odin programming language is designed with the intent of creating an alternative to C.
• Oil - Oil is a new Unix shell. It's our upgrade path from bash to a better language and runtime.
• Okta - Okta is a new open source, general-purpose programming language that, although it’s still in its childhood, aims to provide a simple platform to create low level, efficient software.
• One - It is an open source, self-hosted, bootstrapping system programming language which makes it easy to build reliable and efficient software. One is a programming language that makes it easy to build reliable, efficient and performant software. [system]
• Orion - Orion is a high level, purely functional Lisp dialect.
• OverScript - OverScript is a simple and powerful C-like statically-typed language written in C# and is great for both embedding in .NET programs and building standalone applications. The project was developed from scratch without looking back at traditional approaches to creating languages. The unique approach allows the language to go beyond the standard features and have great potential for improvement.
• OxygenBasic - BASIC compiler. Run programs directly, or compile to 32/64 bit binary. Supports C headers and assembly code. Supports Unicode source scripts.
• Oz - Oz is a multiparadigm programming language, developed in the Programming Systems Lab at Université catholique de Louvain, for programming language education. It has a canonical textbook: Concepts, Techniques, and Models of Computer Programming.

P (28):

• P - A state machine based programming language for formally modeling and specifying complex distributed systems.
• Pascal Script - Pascal Script is an Object Pascal/Delphi/Lazarus-compatible interpreter with bytecode compiler that delivers a scripting environment for application programs.
• PascalABCNet - PascalABC.NET is the new generation Pascal programming language that combines simplicity of classic Pascal, a great number of modern extensions and broad capabilities of Microsoft .NET Framework. It's ree, simple and powerful IDE. Built-in form designer for rapid development of Windows desktop applications.
• Passerine - A small extensible programming language designed for concise expression with little code. Passerine is a small, concise, extensible functional scripting language, powered by a VM¹ written in Rust.
• Peachpie - PeachPie is a modern PHP compiler based on the Microsoft Roslyn compiler platform and drawing from our popular Phalanger project. It allows PHP to be executed within the .NET framework, thereby opening the door for PHP developers into the world of .NET – and vice versa.
• Peridot - An experimental language for exploring the applications of two level type theory to high-performance functional programming
• Pharo - Pharo is a pure object-oriented programming language and a powerful environment, focused on simplicity and immediate feedback (think IDE and OS rolled into one).
• Phix - Phix is a self-hosted hybrid interpreter/compiler, developed by Pete Lomax. It is very easy to use, and similar to Euphoria.
• PicoLisp - PicoLisp is a programming language, a dialect of the language Lisp. Its most prominent features are simplicity and minimalism. It is built on one internal data type: a cell. On the language level, a programmer can use three different data types (numbers, symbols, and lists) being represented by cells and differentiated by bits at the end of the cell.
• Pikt - Pikt is a pixel-based, Turing complete esoteric programming language that generates fast and lightweight programs out of aesthetically pleasant image sources. Indeed, Pikt's most interesting feature is flexibility: every keyword, statement, function, operator and so on is linked to one - or more - color, which can be easily customized via color schemes.
• Pinafore - Pinafore is a language that allows you to structure information and create user interfaces for it. Currently it's at the "proof of concept" stage. You can build it from source and run it.
• Pocketlang - A lightweight, fast embeddable scripting language. Pocketlang is a small (~3000 semicolons) and fast functional language written in C. It's syntactically similar to Ruby and it can be learned within 15 minutes. Including the compiler, bytecode VM and runtime, it's a standalone executable with zero external dependencies just as it's self descriptive name. The pocketlang VM can be embedded in another hosting program very easily.
• Polyglot - Experiment with PHP+C polyglot snippets and a transpiler written in OCaml.
• Pony - Pony is a compiled, actor-model, capabilities-secure, high performance programming language that prevents concurrency mistakes such as data races and deadlocks by design with reasonable syntactic defaults. Its FFI allows Pony to interface with other languages.
• PowerMops - A full featured, stand-alone development environment for programming the Macintosh written by Mike Hore.
• POWER-KI - POWER-KI allows HYBRID PROGRAMMING, i.e. the development of applications with components created with different languages in a single package, making the most of each of them. In fact from POWER-KI it is possible to directly execute PyThon code, C / C ++ code using WRAP and javascript in the Web User Interface. In this way, for example, it is possible to create applications based on Python code that take advantage of the POWER-KI Native Cloud for the user interface or create C / C ++ functions for maximum performance.
• Preql - Preql is an interpreted, relational programming language, that specializes in database queries and compiles to SQL.
• Priml - Priml is a stack-oriented scripting language based on Forth and BASIC.
• Processing - Processing is a flexible software sketchbook and a language for learning how to code. Since 2001, Processing has promoted software literacy within the visual arts and visual literacy within technology. There are tens of thousands of students, artists, designers, researchers, and hobbyists who use Processing for learning and prototyping.
• Prompto - The full stack language hosted in the cloud. Prompto frees you from time consuming tasks and lets you focus on making visible differences: creative web pages, meaningful data models and relevant business logic.
• Prose - In distributed computing environments, getting software components to integrate and communicate with each other can involve large teams of developers, and involve significant amounts of time and money. Such projects can be very difficult to manage. PROSE is designed from the ground-up to address these challenges with a range of innovative features that are unique to the language. It consists of:
  • A high-level modular scripting language, which compiles into bytecode
  • An assembly language for low-level bytecode development
  • An execution engine, which interprets the bytecode
  • A hierarchical object tree through which all components are addressed
• PureBasic - PureBasic is a modern BASIC programming language. The key features of PureBasic are portability (Windows, Linux, OS X and Raspberry supported with the same source code), the production of very fast and optimized native 32-bit or 64-bit executables and, of course, the very simple BASIC language syntax. PureBasic has been created for the beginner and expert alike. We have put a lot of effort into its conception to produce a fast, reliable system and friendly BASIC compiler.
• PureScript - A strongly-typed functional programming language that compiles to JavaScript
• Pure - Pure is a modern-style functional programming language based on term rewriting. It offers equational definitions with pattern matching, full symbolic rewriting capabilities, dynamic typing, eager and lazy evaluation, lexical closures, built-in list and matrix support and an easy-to-use C interface.
• Pure - A pure type system implemented in OCaml.
• PXP - A superset of PHP with extended syntax and runtime capabilities.
• Pycopy - Pycopy - a minimalist and memory-efficient Python dialect. Good for desktop, cloud, constrained systems, microcontrollers, and just everything.
• Pyret - Pyret is a programming language designed to serve as an outstanding choice for programming education while exploring the confluence of scripting and functional programming. It's under active design and development, and free to use or modify.

Q (4):

• Qi - Lightweight and fast programming language designed to be written in Chinese.
• Quil - A Portable Quantum Instruction Language.
• Quirrel - Quirrel - Gaijin Entertainment dynamic script language (former Squirrel).
• Quorum - Quorum is a general purpose programming language designed for several purposes. First, we regularly run experiments with people at various age and experience ranges, investigating ways to make the language easier to use. Evidence gathered from these studies is filtered back into the design, making quorum an "evidence-based" programming language. Second, as our team is interested in issues of equity for all people, perhaps especially people with disabilities, we are careful to design libraries that are friendly to the broad population. This means many internal libraries in the language have support for accessibility.

R (28):

• R3 - R3 is a Colorforth like laneguage, a FORTH dialect, R3 is a 64 bits, very small dictionary and simple working, strong typed, many version for windows/linux/mac and raspberry pi.
• R4 - R4 is a Colorforth like laneguage, a FORTH dialect, R4 is 32bits, very small dictionary and simple working, strong typed, many version for windows/linux/mac and raspberry pi.
• Racket - A general-purpose, multi-paradigm programming language and a multi-platform distribution that includes the Racket language, compiler, large standard library, IDE, development tools, and a set of additional languages including Typed Racket (a sister language of Racket with a static type-checker), Swindle, FrTime, Lazy Racket, R5RS & R6RS Scheme, Scribble, Datalog, Racklog, Algol 60 and several teaching languages.
• RAD Basic - RAD Basic 100% compatible with your Visual Basic 6 projects.
• Radish - Radish is an easy-to-learn, object-oriented programming language written in C#. If you know JavaScript, you know Radish.
• Ragel - Ragel compiles executable finite state machines from regular languages. Ragel targets C, C++ and ASM. Ragel state machines can not only recognize byte sequences as regular expression machines do, but can also execute code at arbitrary points in the recognition of a regular language. Code embedding is done using inline operators that do not disrupt the regular language syntax.
• Raku - A member of the Perl family of programming languages. Formerly known as Perl 6, it was renamed in October 2019. Raku introduces elements of many modern and historical languages. Compatibility with Perl was not a goal, though a compatibility mode is part of the specification.
• RascalMpl - Rascal Metaprogramming Language. Rascal is a programming language; such that meta programs can be created by, understood by, and debugged by programmers. Rascal primitives include immutable data, context-free grammars and algebraic data-types, relations, relational calculus operators, advanced patterns matching, generic type-safe traversal, comprehensions, concrete syntax for objects, lexically scoped backtracking, and string templates for code generation. It has libraries for integrating language front-ends, for reusing analysis algorithms, for getting typed meta-data out of version management systems, for interactive visualization, etc.
• Rave - Rave is a statically typed, compiled, procedural, general-purpose programming language.
• Reason - Simple, fast & type safe code that leverages the JavaScript & OCaml ecosystems.
• Red - Red is a next-generation programming language strongly inspired by Rebol, but with a broader field of usage thanks to its native-code compiler, from system programming to high-level scripting and cross-platform reactive GUI, while providing modern support for concurrency, all in a zero-install, zero-config, single 1MB file!
• Renjin - JVM-based interpreter for the R language for the statistical analysis. The primary goals of the project are to provide a modern interpreter that serves as a drop-in replacement for GNU R, but is easier to integrate with other systems, offers better performance, and is more extensible.
• Req - A simple and opinionated HTTP scripting language. It is designed for easily making HTTP requests, and working with their responses. Below is an example that calls out to the GitHub API and displays the user making the call.
• ReScript - ReScript compiler and syntax provide the best experience to write JS and React applications. Unifying the tools in one coherent platform and core team allows us to build features that wouldn't be possible in the original BuckleScript + Reason setup.
• Rewrite - Rewrite is estimated to be a Turing complete, s-expression based term rewriting system. Its original intention is operating over s-expressions to expand asserted template occurrences while aiming to be intuitive enough to introduce code templating to non-technical users. To try Rewrite within browser, please refer to Rewrite Playground.
• Rexx - Rexx is a structured, high-level programming language designed for ease of learning and reading. It was developed at IBM by Mike Cowlishaw. Rexx is a full language that can be used as a scripting, macro language, and application development language. It is often used for processing data and text and generating reports. Rexx is the primary scripting language in some operating systems, e.g. OS/2, MVS, VM, AmigaOS, and is also used as an internal macro language in some other software, such as SPF/PC, KEDIT, THE and the ZOC terminal emulator. Additionally, the Rexx language can be used for scripting and macros in any program that uses Windows Scripting Host ActiveX scripting engines languages (e.g. VBScript and JScript) if one of the Rexx engines is installed.
• Rhai - Rhai - An embedded scripting language for Rust.
• Rhovas - Rhovas is a programming language for API design and enforcement. Using Rhovas, developers can better express the contracts and intention of their code to help create correct, maintainable software.
• Ribbon - Ribbon is a dynamic interpreted programming language. It's inspired by the likes of Python, Javascript and a little bit of Lua.
• Rickroll lang - A light meme based, process oriented, dynamic, strong, esoteric programming language. All of the keywords/statements are came from Rick Astley's lyrics. I believe that rick roll is not only a way to promote people’s communication, it is also one of the most paramount art in the human history. The purpose of the Rickroll Language is to introduce this art to people in a distinctive way – programming.
• Ring - Simple and flexible programming language for applications development. Ring is a practical general-purpose multi-paradigm language. The supported programming paradigms are Imperative, Procedural, Object-Oriented, Functional, Metaprogramming, Declarative programming using nested structures, and Natural programming. The language is portable (MS-DOS, Windows, Linux, macOS, Android, WebAssembly, etc.) and can be used to create Console, GUI, Web, Games, and Mobile applications. The language is designed to be Simple, Small, and Flexible.
• Rio - A script-feeling, safe, naturally compatible replacement for C, with no runtime nor std lib of its own.
• Rivet - A general-purpose programming language, focused on simplicity, safety and stability.
• Rock - Little language made with Rust and LLVM. Aim to follow the enforced safeness of the Rust model with a borrow checker (Soon™) and achieve high native performances thanks to LLVM. Rock is highly inspired from Livescript and Rust, and will also borrow (pun intended) some features from Crystal, from functional languages like Haskell, and even from Rust itself.
• Roc - Roc is a language for making delightful software.
• Roman II - Roman II is a dynamic programming language with a naive mark and sweep garbage collector, all written from the ground up in about 5000 lines of the GNU11 dialect of C.
• Rune - The Rune Language, an embeddable dynamic programming language for Rust.
• RustScript - RustScript is a functional scripting language with as much relation to Rust as Javascript has to Java.

S (18):

• Scheme - Scheme is a dialect of the Lisp family of programming languages. It was the first dialect of Lisp to choose lexical scope and the first to require implementations to perform tail-call optimization, giving stronger support for functional programming and associated techniques such as recursive algorithms. It was also one of the first programming languages to support first-class continuations.
• Seed7 - Seed7 is a higher level language compared to Ada, C++ and Java.
• Senegal - Senegal is a powerful, small-but-fast, concurrent, class-based, and dynamically-typed programming language with a modern syntax.
• Shiika - Shiika is a statically-typed programming language that makes me most productive.
  • Easy to write like Ruby or Python;
  • Static type checking (Null safety!);
  • Object-oriented but has enums and pattern-matching;
  • Written in Rust, compiles to single binary via LLVM IR.
• Simula - This is a new Simula System created by the Open Source Project 'Portable Simula Revisited'. The project was initiated as a response to the lecture held by James Gosling at the 50th anniversary of Simula in Oslo on 27th September, 2017. This Simula System is written in Java and compiles to pure Java code with one exception, the Goto Statement need to be corrected in the byte code, which is done automatically.
• Slang - Statically typed scripting language... syntax errors should be catched at design time!
• SmallBASIC - SmallBASIC is a fast and easy to learn BASIC language interpreter ideal for everyday calculations, scripts and prototypes. SmallBASIC includes trigonometric, matrices and algebra functions, a built in IDE, a powerful string library, system, sound, and graphic commands along with structured programming syntax.
• Solidity - Solidity is an object-oriented programming language for implementing smart contracts on various blockchain platforms, most notably, Ethereum.
• Soul - Soul is an esoteric concatenative one-stack language, a small explorative language with an interpreter written in a day. Most concatenative languages work on a state, often that's another stack. For example, Forth has a data and return stack and Postscript has an extra stack outputting to a page. Soul is a minimalist language that provides one thing, and one thing only, the one sole stack.
• Sphinx - Sphinx is a dynamically typed programming language that is inspired by Lua and Python, and implemented entirely in Rust!
• SpiderBasic - SpiderBasic is new web client-side programming language based on established BASIC rules. Its allows development of very complex, windowed based web applications, including mobile app for iOS and Android. It provides a large commandset to handle complex and reactive GUI, 2D games, and many more in a coherent manner. Every library and commands behave the same and have similar syntax for easier and faster learning.
• Spiral - Functional language with intensional polymorphism and first-class staging.
• Squilu - A scripting language that accepts a subset of javascript and C/C++.
• Squirrel - Squirrel is a high level imperative, object-oriented programming language, designed to be a light-weight scripting language that fits in the size, memory bandwidth, and real-time requirements of applications like video games.
• Stark - Stark is a new language and OS with the help of the .NET ecosystem and seL4 micro-kernel.
• Starlark - Starlark (formerly known as Skylark) is a language intended for use as a configuration language. It was designed for the Bazel build system, but may be useful for other projects as well.
• Star - An experimental programming language that's made to be powerful, productive, and predictable. One of the most important goals of Star is that it's designed to be completely consistent. In other words, Star has been designed to not have edge cases, footguns, or any sort of "magic" that's exclusive to language built-ins.
• Stroscot - Stroscot is an imperative programming language designed for modern processors.

T (13):

• TableM - A relational language.
• Taichi - Productive & portable high-performance programming in Python. Taichi Lang is an open-source, imperative, parallel programming language for high-performance numerical computation. It is embedded in Python and uses just-in-time (JIT) compiler frameworks, for example LLVM, to offload the compute-intensive Python code to the native GPU or CPU instructions.
• Tamgu(탐구) - A FIL Language that combines in one language an imperative paradigm, a functional paradigm and a logical paradigm. Mixes in one code A Python-like formalism, a Haskell-like formalism and a Prolog-like formalism.
• Tao - A statically-typed functional language with polymorphism, typeclasses, sum types, pattern-matching, first-class functions, currying, good diagnostics, and much more!
• Tcl - Tcl is a high-level, general-purpose, interpreted, dynamic programming language. Tcl supports multiple programming paradigms, including object-oriented, imperative and functional programming or procedural styles. It is commonly used embedded into C applications for rapid prototyping, scripted applications, GUIs, and testing.
• Terra - Terra is a low-level system programming language that is embedded in and meta-programmed by the Lua programming language
• ThinBasic - Very fast "BASIC like" programming language useful to Beginners and to Gurus. BASIC interpreter for Windows able to create console and gui applications with most of the user interface controls, automate process, automate data exchange, connect to databases, send mails, connect to ftp sites, rest api, parsing strings, tokenizing, traversing xml, handling files, Windows Registry, OpenGl, graphics, sound, printing ... and much more.
• Timid - A small programming language that made to be able to quickly solve problems like tedious math homework in as little time as possible (as in runtime). Also, it's possible to compile code once, and run anywhere using the Timid Runtime.
• Toy - Refinement types + dependent types = ❤️. A Toy proof-of-concept implementation of a language with refinement types that compiles to Idris.
• Toy - The Toy programming language interpreter, written in C.
• TwinBasic - TwinBasic: a modern, BASIC programming language, aiming for 100% backwards compatibility with existing VB6/VBA projects. A complete replacement development environment offering significant new features and improvements over the VB6 IDE.
• Typst - A new markup-based typesetting system that is powerful and easy to learn.
• Tyr - Tyr is an experimental minimalistic language. It's meant to be both a programming language and a conlang. Programmers should think of it as a speakable programming language. Conlangers should see it as a logical conlang, which can also be used for programming. To achieve this, this language has clear and simple nesting rules based on the words, but no syntax for nesting. You can write sentences without the need of indentation. Any kind of indent is not even allowed. It's still in an early stage and only supports a few math primitives. Many things will probably be changed. I'll only document the current state here.

U (5):

• Umka - Umka is a statically typed embeddable scripting language. It combines the simplicity and flexibility needed for scripting with a compile-time protection against type errors. Its aim is to follow the Python Zen principle Explicit is better than implicit more consistently than dynamically typed languages generally do.
• Unicon - Unicon is a very high level programming language. It runs on many operating systems including most Linux distributions, Windows, macOS, and BSD systems. It also supports most modern CPU architectures such as i386, amd64, armhf, arm64, and ppc64el.
• Unison - Unison is a modern, statically-typed purely functional language, similar to Haskell, but with the ability to describe entire distributed systems with a single program.
• Ur - Ur is a programming language in the tradition of ML and Haskell, but featuring a significantly richer type system. Ur is functional, pure, statically typed, and strict. Ur supports a powerful kind of metaprogramming based on row types.
• Ü - Experimental programming language that is compilable, statically-typed C++-like language.

V (12):

• V1 - V1 is a simple functional interpreter language with syntax from C, PHP and JavaScript. It was developed from the scratch. The focus is on administrative and experimental programming, but it has enhanced benefits like Multithreading, CGI, Web functions and native function calling. The most buildin functions are compatible with PHP, for example fopen().
• Vala - Vala is a programming language that aims to bring modern programming language features to GNOME developers without imposing any additional runtime requirements and without using a different ABI compared to applications and libraries written in C.
• Vale - Vale is the fast, safe, and easy programming language. It uses single ownership with constraint references for memory safety without garbage collection, and an emphasis on modern, readable syntax.
• Val - Val is an open source, general-purpose programming language designed around on the concept of (mutable) value semantics. The language aims to be safe and efficient, yet expressive enough to support multiple programming paradigms and implement concurrent algorithms safely and efficiently.
• Verona - Project Verona is a research programming language to explore the concept of concurrent ownership. We are providing a new concurrency model that seamlessly integrates ownership.
• Verse - Verse is a programming language developed by Epic Games that you can use to create your own gameplay in Unreal Editor for Fortnite, including customizing your devices for Fortnite Creative.
• Victim - Victim is dynamically typed interpreted scripting language written in Haskell. The name is inspired by source code of malloc.
• Vinci - A proof-of-concept compiler targeting SPIR-V for a toy ML functional shading language.
• Virgil - A Fast and Lightweight Programming Language. Its design blends functional and object-oriented programming paradigms for expressiveness without a lot of overhead, either syntactically or at runtime. Its implementation is focused primarily on static compilation to produce native executables that are standalone. It is well-suited to writing small and fast programs. That makes it ideal for building certain kinds of programs like compilers and virtual machines. It is currently being used for virtual machine and programming language research.
• Vortex - Vortex is a language designed to explore links and relationships between entities. It heavily relies on side effects, and as such it would fall under the Dysfunctional Programming paradigm.
• Vox - Vox is a multiparadigm programming language inspired by D (60%), Jai (30%), and Zig (10%). Vox language compiler. AOT / JIT / Linker. Zero dependencies.
• V - Simple, fast, safe, compiled language for developing maintainable software. Compiles itself in <1s with zero library dependencies.

W (7):

• Wax - A tiny programming language that transpiles to C, C++, Java, TypeScript, Python, C#, Swift, Lua and WebAssembly 🚀.
• Well - Well lang is somewhat functional kinda stack based language. This language includes your normal things like variables, mathamatics, loops, etc. It compiles directly to assembly (NASM).
• Whiley - Whiley employs state-of-the-art techniques for ensuring your software is correct. You can specify functions using preconditions and postconditions, and then statically verify your implementation meets its specification.
• Wren - Wren is a small, fast, class-based concurrent scripting language.
• Wuffs - Wuffs (Wrangling Untrusted File Formats Safely) is a memory-safe programming language (and a standard library written in that language) for wrangling untrusted file formats safely. Wrangling includes parsing, decoding and encoding. Example file formats include images, audio, video, fonts and compressed archives.
• Wu - An expression oriented, gradually typed and mission-critical programming language.
• Wyvern - Wyvern is a new general-purpose programming language designed to support adaptation and assurance. Key features of Wyvern's evolving design include:
  • A simple object model with good support for both object-oriented and functional programming
  • Static type safety
  • Extensibility with domain-specific syntax via libraries written within the language
  • A simple but powerful capability-safe module system
  • Support for various aspects of software architecture within the running system

X (4):

• X# - X# is an open source development language for .NET, based on the xBase language. It comes in different flavours, such as Core, Visual Objects, Vulcan.NET, xBase++, Harbour, Foxpro and more. X# has been built on top of Roslyn, the open source architecture behind the current Microsoft C# and Microsoft Visual Basic compilers.
• X10 - X10 is a statically-typed object-oriented language, extending a sequential core language with places, activities, clocks, (distributed, multi-dimensional) arrays and struct types. All these changes are motivated by the desire to use the new language for high-end, high-performance, high-productivity computing.
• Xojo - Build Native, Cross-Platform Apps. Rapid application development for Desktop, Web, Mobile & Raspberry Pi.
• Xtend - Xtend is a flexible and expressive dialect of Java, which compiles into readable Java 8 compatible source code. You can use any existing Java library seamlessly. The compiled output is readable and pretty-printed, and tends to run as fast as the equivalent handwritten Java code.

Y (3):

• Yab - Yab | yet another Basic for HAIKU.
• Yeti - Yeti is ML style functional programming language, that runs on the JVM.
• Yuescript - Yuescript is a Moonscript dialect. It is derived from Moonscript language 0.5.0 and continuously adopting new features to be more up to date. Moonscript is a language that compiles to Lua. Since original Moonscript has been used to write web framework lapis and run a few business web sites like itch.io and streak.club with some large code bases. The original language is getting too hard to adopt new features for those may break the stablility for existing applications.

Z (5):

• Zang - Zang is a dynamically typed high level programming language.
• Zenon - Zenon is a statically typed language that compiles to C++. It offers safe and easy application development thanks to high-level features and fast compile times, while keeping C++'s performance and familiar syntax.
• Zephir - Zephir - is a high level programming language that eases the creation and maintainability of extensions for PHP. Zephir extensions are exported to C code that can be compiled and optimized by major C compilers such as gcc/clang/vc++. Functionality is exposed to the PHP language.
• ZetScript - ZetScript is a programming language with an API that allows bind C++ code in script side.
• Zig - General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.

See also:

• Wikipedia's List of Programming Languages.
• Awesome Basic - A curated list of awesome BASIC dialects, IDEs, and tutorials.
• Awesome Lisp languages - A list of Lisp-flavored programming languages.
• Lua languages - Languages that compile to Lua.
• Awesome Scheme - A curated list of awesome Scheme libraries and resources.
• Awesome low level programming languages
• List of languages that compile to JS - List of languages that compile to JavaScript and many other transpilers.
• PL catalog - A catalog of programming languages.
• Programming languages - Awesome Programming Languages.
• Programming Language Design - Programming Language Design is dedicated to the theory, design and implementation of programming languages.
• GitHub programming languages - A list of programming languages that are actively developed on GitHub.
• Lox implementations - Lots implementations of Lox language written in many programming languages.
• Langs written in Rust - A list of programming languages implemented in Rust, for inspiration. This is a (probably incomplete) list of languages implemented in Rust. It is intended as a source of inspiration and comparison, and as a directory of potentially interesting projects in this vein.
• Programming Language Database - PLDB: a Programming Language Database. A computable encyclopedia about programming languages.