Awesome programming languages

The list of 914 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.

A (44):

A+ - A+ is a powerful and efficient programming language. It is freely available under the GNU General Public License. It embodies a rich set of functions and operators, a modern graphical user interface with many widgets and automatic synchronization of widgets and variables, asynchronous execution of functions associated with variables and events, dynamic loading of user compiled subroutines, and many other features. Execution is by a rather efficient interpreter. A+ was created at Morgan Stanley. Primarily used in a computationally-intensive business environment, many critical applications written in A+ have withstood the demands of real world developers over many years. Written in an interpreted language, A+ applications tend to be portable.
ABC - ABC is an interactive programming language and environment for personal computing, originally intended as a good replacement for BASIC. It was designed by first doing a task analysis of the programming task.ABC is easy to learn (an hour or so for someone who has already programmed), and yet easy to use. Originally intended as a language for beginners, it has evolved into a powerful tool for beginners and experts alike.
ABCL - ABCL: An Object-Oriented Concurrent System. The tenet of our ABCL research project is to exploit both paralle. lism and object orientation. Parallelism is ubiquitous in our problem domains; parallelism is not only the source of computational power, but also promotes structural simplicity/naturalness in design and algorithm. Object-orientation accompanying parallelism, enhances system modularity, flexibility, and safety.
ABS - ABS is a programming language that works best when you're scripting on your terminal. It tries to combine the elegance of languages such as Python, or Ruby, to the convenience of Bash.
ACCEPT - ACCEPT, an approximate compiler for C and C++ programs based on Clang. Think of it as your assistant in breaking your program in small ways to trade off correctness for performance.
Ada - A programming language for readable, correct, and performant software. Get started with Alire, the Ada package manager.
Adamant - Adamant was to be a general-purpose language with high performance, deterministic safe resource management, and guaranteed thread safety.
Adept - A blazing fast language for general purpose programming.
AdvSys - AdvSys - A Language for Writing Text Adventure Games
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.
Aime - aime is an imperative procedural programming language, with a C inspired syntax. It is a high level programming language, with fully automated memory management, and strong static types.
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.
Albatross - Albatross is
- A Programming Language with Static Verification: You can develop programs and algorithms and prove them to be correct in Albatross.
- A Proof Assistant: Arbitrary mathematical theories can be expressed and proved in Albatross
- A Theorem Prover: It has a proof engine which supports you significantly in doing proofs.
Alda - Alda is a text-based programming language for music composition. It allows you to compose and play back music using only your text editor and the command line.
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.
Amiga E - E is an object-oriented/procedural/unpure functional/whatever language with quite a popular implementation on the amiga. It’s mainly influenced by languages such as C++, Ada, Lisp etc., and features extremely fast compilation, inline assembler, large set of integrated functions, powerful module concept, flexible type-system, quoted expressions, immediate and typed lists, parametric and object polymorphism, exception handling, inheritance, data-hiding, methods, multiple return values, default arguments, register allocation, fast memory management, unification, LISP-Cells, macro-preprocessing, a very powerful source-level debugger, gui-toolkit, library linker, and then some.
AMPL - AMPL is the most powerful and intuitive tool for developing and deploying complex optimization solutions in business & scientific applications. AMPL connects to most commercial and open-source solvers and allows you to switch easily between them.
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.
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.
Apex - Apex is an interface definition language (IDL) for modeling software. Generate source code, documentation, integration, everything automatically.
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.
APLX - is an advanced, second generation implementation of the APL language, closely based on IBM's APL2, but with a number of important enhancements.
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.
Argo - Pragmatic functional programming language.
Argon - Argon is an interpreted multi-paradigm dynamically typed programming language. Its syntax is mainly influenced by Python, Go and Rust.
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)
Ark - Ark is a systems programming language focused on being practical and pragmatic. We want a language that is simple, easy to write, yet powerful enough to create readable, performant and concise code for any problem
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.
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.
ASPL - ASPL is a modern programming language featuring beautiful simplicity, seamless cross-compilation, advanced mobile support, powerful C-interoperability, and so much more. It has been designed to be practical for both beginners and experienced programmers and to help you build better software, quicker.
astro - Astro is a fun programming language designed for safe high-performance applications. It is essentially a statically-typed systems language that
- facilitates rapid prototyping,
- features high-level abstractions with zero overhead,
- ensures memory safety without a (tracing) Garbage Collector, and
- supports data-race-free concurrency.
atlantis - a system programming language and ecosystem
Atom - is a programmable, register based virtual machine for Win32 computers. The program is a text-base console application. The VM can be programmed using a neo-assembler language called Atom Assembler. This document discusses the VM and explains each opcode in Atom Assembler.
Atom - A general purpose programming language that easy to use, read and integrated
ATS - ATS is a statically typed programming language that unifies implementation with formal specification. It is equipped with a highly expressive type system rooted in the framework Applied Type System, which gives the language its name. In particular, both dependent types and linear types are available in ATS.
Austral - A systems programming language that uses linear types to provide memory safety and capability-secure code. [linear types]
AutoIt v3 - is a freeware BASIC-like scripting language designed for automating the Windows GUI and general scripting. It uses a combination of simulated keystrokes, mouse movement and window/control manipulation in order to automate tasks in a way not possible or reliable with other languages (e.g. VBScript and SendKeys). AutoIt is also very small, self-contained and will run on all versions of Windows out-of-the-box with no annoying "runtimes" required! AutoIt was initially designed for PC "roll out" situations to reliably automate and configure thousands of PCs. Over time it has become a powerful language that supports complex expressions, user functions, loops and everything else that veteran scripters would expect.
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.
AWKA - Awka is an open-source implementation of the AWK programming language. Awka is not an interpreter like Gawk, Mawk or Nawk, but instead it converts the program to ANSI-C, then compiles this using gcc or a native C compiler to create a binary executable. This means you must have an ANSI C compiler present on your system for Awka to work.

B (42):

B4X - Simple, powerful and modern development tools. With B4X, anyone who wants to, can develop real-world solutions.
BabyCobol - BabyCobol is a project in language design aimed at creating a language that is, on one hand, small enough to be quickly implementable (fully or partially) within any framework that can support its features, and, on the other hand, complex enough to cover typical problems of legacy language processing. If you learn how to compile MiniJava, you stand a good chance of implementing a reasonably good compiler for any contemporary programming language. If you show how your language extension works on Featherweight Java, it has a good chance of being applicable to any reasonable modern object-oriented programming language. If you can handle BabyCobol with your tool and with your skills, you are ready to face the challenges of software modernisation, codebase migration and legacy language processing in general. At this day and age, being future proof means being able to handle software of the past.
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.
Battlestar - Subset of assembly with an alternative syntax and with support for inline C, specifically for 64-bit x86 Linux, 32-bit x86 Linux and 16-bit x86 DOS.
Bau - Bau is a simple, concise, safe, powerful and fast programming language. Features: Easy to learn; Concise syntax; Memory-safe; Statically typed; Fast compilation and execution (transpiles to C).
BCPL - BCPL ("Basic Combined Programming Language") is a procedural, imperative, and structured programming language. A stripped down and syntactically changed version of BCPL, called B, was the language on which the C programming language was based. BCPL introduced several features of many modern programming languages, including using curly braces to delimit code blocks.
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.
BETA - BETA is a modern language in the Simula tradition. The resulting language is smaller than Simula in spite of being considerably more expressive. BETA is a strongly typed language like Simula, Eiffel and C++, with most type checking being carried out at compile-time. It is well known that it is not possible to obtain all type checking at compile time without sacrificing the expressiveness of the language. BETA has optimum balance between compile-time type checking and run-time type checking.
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.
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.
Bla - We investigate an (unpure) functional language whose concept of environment is not implicit as in traditional languages, but made available explicitly as a first class value. This results in a semantics for environments that is best known from the object oriented paradigm, and gives us a united function/class concept in a very orthogonal way. We also look at the language as a real-world general purpose language, considering semantics (of type-inference, for example), implementation issues, and practical experience in using the compiler.
Blacklight - blacklight is a general-pupose multithreading concatenative stack-based programming language with first-class queues and objects with delegation.
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.
Bleach - Bleach: a programming language aimed for teaching introductory 'Compilers' courses.
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.
Bob - Bob is a simple object-oriented scripting language. Bob’s syntax is similar to C or C++ but it is dynamically typed and has automatic memory management.
Bob2 - Revised version of Bob derived from the Nuon work at VM Labs
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).
Boo - Boo is an object-oriented, statically typed, general-purpose programming language that seeks to make use of the Common Language Infrastructure's support for Unicode, internationalization, and web applications, while using a Python-inspired syntax[2] and a special focus on language and compiler extensibility. Some features of note include type inference, generators, multimethods, optional duck typing, macros, true closures, currying, and first-class functions.
Borealis - Borealis is a small, elegant and consistent scripting language. Includes a C-like syntax that's easy to implement.
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!
Brain - Brain is a high-level, purely object-oriented, prototype based scripting language, mostly similar to the Self language.
BRL - The Beautiful Report Language. A language designed for server-side WWW-based applications, particularly database applications. It is based on Scheme, which makes the syntax extremely simple yet powerful. This implementation is a Java Servlet using the Kawa Scheme compiler.
Brython - A Python 3 implementation for client-side web programming.
Bulfinch - Just a little toy language to learn about register-based VMs.
Burro - A digital typesetting language
Buzz - A small/lightweight statically typed scripting language written in Zig.
β-Juliet - β-Juliet is a fairly minimal event-oriented language. In β-Juliet, the world is modelled as a set of events which have no inherent organization or order. Each event can be denoted with a symbol, such as DominoFalls, CatMeows, or SunSets, or (in version 2.0) a string of symbols, such as Address Line Six Goes High or Greengrocer Falls Asleep on Subway. Each event can cause other events to occur — these are termed consequences of the event. In addition, this causation may be conditional, but the only condition that is possible to check is: given two events, which one happened more recently?

C (73):

C2 - The C2 project attempts to create a new language, strongly based on C. In a nutshell, the main differences with C are:
- no more header files (too much typing)
- no includes
- packages (needed if we can't have includes)
- compiled per target (not per file)
- more logical keywords (public/local replaces static)
- integrated build system
C3 - C3 is a C-like language trying to be "an incremental improvement over C" rather than a whole new language.
C3 - C3 is a xBase language compiler for 16, 32 and 64 bit's. It generates OBJs that may be directly linked to create an executable application for Windows.
CafeOBJ - CafeOBJ is a language for writing formal (i.e. mathematical) specifications of models for wide varieties of software and systems, and verifying properties of them. CafeOBJ implements equational logic by rewriting and can be used as a powerful interactive theorem proving system. Specifiers can write proof scores also in CafeOBJ and doing proofs by executing the proof scores.
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.
Calc4 - Calc4 is a programming language where everything in its code is an operator.
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.
Camelot - Camelot is a language of the ML family. It is strict, first-order but allows for use-only higher-order functions. It includes object-oriented extensions, mainly for creating and using objects in an existing class hierarchy. Programmers familiar with ML or Ocaml should have no problems understanding the basic language promitives. `
Cane - A small MIDI sequencer DSL designed around vectors and euclidean rhythms.
Cant - a programming language descended mainly from E and Scheme.
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.
Carth - A Scheme-looking, purely functional programming language
CASL - CASL (Compact Application Solution Language) is an easy to use Windows Integrated Development Environment (IDE) that allows you to build applications for the PalmOS®, PocketPC / Windows Mobile and Windows using a single set of code. You can easily create applications that target multiple operating systems using a high-level programming language (similar to BASIC) that will only take a small investment of your time to learn. Even if you have never created software before, CASL can help make your idea a reality.
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.
Castile - A simple imperative language with union types (and a compiler for same, with multiple targets)
Cat - Cat is a functional stack-based programming language inspired by the Joy programming language. The primary differences is that Cat provides a static type system with type inferencing (like ML or Haskell), and a term rewriting macro language extension language called MetaCat. Cat is a high-level intermediate language translation that can also be used as a stand alone language for simple application development. In this way it occupies a similar niche to PostScript. Cat is also an appropriate language for teaching of basic programming concepts.
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.
Cecil - Cecil is a purely object-oriented, type-safe, garbage-collected language intended to support rapid construction of high-quality, extensible software.
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.
Chalice - Chalice is an experimental language that explores specification and verification of concurrency in programs. The language supports dynamic object creation, dynamic thread creation (fork and join), mutual-exclusion and readers-writers locks, monitor invariants, thread pre- and postconditions. The language allows fine-grained locking via specifications that track fractional permissions for memory locations. The research project also includes an automatic static program verifier for Chalice.
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.
Circom - Circom is a circuit programming language and a compiler that allows programmers to design and create their own arithmetic circuits for ZK proofs.
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.
Citrine - The inspiration for the Citrine Programming Language comes from Smalltalk (message-based, pure object oriented programming), JavaScript (prototypal inheritance), and BASIC (dynamic scope). The name Citrine refers to the yellow coloured gem and honours the short lived tradition to name programming languages after shiny minerals like Pe(a)rl and Ruby.
CLAIRE4 - Claire is a general-purpose programming language, best suited to application software requiring sophisticated data modeling, rule processing or problem solving. WebClaire adds extensions for fuller integration with the operating system and for programming web applications.
clio - Clio is a functional, distributed programming language that compiles to JavaScript. It runs in the browser and on the server and is made to be a suitable language for scientific programming. Clio takes advantage of multiple CPUs and multiple CPU cores (parallelism) by default, is able to use network resources, is easy to run on clusters and on the cloud.
Clip - Clip is CA-Clipper 5.3 compatible compiler for Linux-UNIX and Cygwin with new OO-model, FiveWin and GTK compatible GUI and many other useful features.
CLIPS - Developed at NASA’s Johnson Space Center from 1985 to 1996, the C Language Integrated Production System (CLIPS) is a rule‑based programming language useful for creating expert systems and other programs where a heuristic solution is easier to implement and maintain than an algorithmic solution. Written in C for portability, CLIPS can be installed and used on a wide variety of platforms. Since 1996, CLIPS has been available as public domain software.
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.
clprolf - clprolf (CLear PROgramming Language and Framework) has been made for simplify programming, especially OOP. It is a superset of java. The clprolf framework is available for Java, C#, or PHP.
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.
CMOC - CMOC is a 6809-generating cross-compiler for a large subset of the C language. It generates assembly language code for the Motorola 6809 processor and targets the Tandy Color Computer, the Dragon computer, the Vectrex video game console, the Thomson MO and TO computers, and the OS-9 and FLEX operating systems. It runs under GNU/Linux and other Unix-like environments like Darwin and Cygwin. It requires the LWTOOLS assembler (lwasm) and linker, by William Astle.
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.
colm - Colm = COmputer Language Machinery. Colm is a programming language designed for the analysis and transformation of computer languages. Colm is influenced primarily by TXL
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.
Concurnas - Concurnas is an open source JVM programming language designed for building reliable, scalable, high performance concurrent, distributed and parallel systems
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.
Cotowali - A statically typed scripting language that transpile into POSIX sh
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.
Cppfront - Cppfront is an experimental compiler from a potential C++ 'syntax 2' (Cpp2) to today's 'syntax 1' (Cpp1), to learn some things, prove out some concepts, and share some ideas. This compiler is a work in progress and currently hilariously incomplete... basic functions work, classes will be next, then metaclasses and lightweight exceptions.
Creed - A concatenative language for text processing script, inspired by ed and sam
Crema - Crema is a LLVM front-end that aims to specifically execute in sub-Turing Complete space. Designed to be simple to learn, and practical for the majority of programming tasks needed, Crema can restrict the computational complexity of the program to the minimum needed to improve security
Crow - - Crow programs can be run directly from source.
- You can also build your program to a standalone executable. In either case, you don't need a build system.
- You can directly call C functions.
- Data is garbage collected. Don't worry about what's by-reference or by-value.
- Crow is statically typed. There's no subtyping or implicit conversion. There are no null references. Overload resolution is unambiguous.
- I/O is controlled. Normal functions can't do I/O except by invoking a lambda from a parameter.
- You can launch parallel tasks and get the result as a future.
- Mutability is controlled. The type system tracks whether a type allows access to mutable data. This ensures that mutable data is not shared across threads.
- Syntax is expression-based. Function bodies are expressions with no return needed.
- Even if and for are expressions.
- Code is flat. Most declarations are not nested inside of anything.
- Expressions are type-checked with an expected type. The same syntax like (1, 2) could be a list, tuple, vector, etc. This saves you from having to write new Foo().
- There are discriminated unions, including option types.
- There are templates; these are type-checked abstractly, not at each instantiation.
- All crow code goes in modules. There are no global declarations.
Crumb - Crumb is a high level, functional, interpreted, dynamically typed, general-purpose programming language, with a terse syntax, and a verbose standard library. It features:
- Strictly no side effects* to help you write functional code
- The ability to localize the effects of imported Crumb files.
- Dynamic typing and garbage collection.
- 0 keywords, everything is a function.
Crush - Crush is an attempt to make a traditional command line shell that is also a modern programming language. It has the features one would expect from a modern programming language like a type system, closures and lexical scoping, but with a syntax geared toward both batch and interactive shell usage.
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.
CSL - CSL is a simple lisp-like macro language for scripting high-level logic and data structures in a way that interfaces easily to the C programming language
CSL - The C Scripting Language (CSL) is a programming language available for Windows, OS/2 and UNIX systems. CSL follows the C syntax very closely. It is used like an interpreter: a program written with an editor can be run directly like any shell script. The CSL scripting engine can be integrated into own applications as a macro language. CSL offers two programming interfaces: A "C" API for 32-bit C compilers, and C++ class interface for selected compilers.
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.
Curv - Curv is a programming language for creating art using mathematics. It’s a 2D and 3D geometric modelling tool that supports full colour, animation and 3D printing.
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.
Cyclone - Cyclone is like C: it has pointers and pointer arithmetic, structs, arrays, goto, manual memory management, and C’s preprocessor and syntax. It adds features such as pattern matching, algebraic datatypes, exceptions, region-based memory management, and optional garbage collection.
Cylvre - Cylvre is a strongly typed, programming language with type inference for the JVM.
cypher - Cypher is Neo4j’s declarative query language, allowing users to unlock the full potential of property graph databases.
Céu - Céu is a reactive language that aims to offer a higher-level and safer alternative to C.
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.

D (30):

D - General-purpose programming language with static typing, systems-level access, and C-like syntax.
Dachs - Dachs is a general-purpose programming language designed to be enjoyable, statically-typed and dog-friendly. Dachs is intended to be used for efficient applications and tools development, not for system programming.
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 - Darklang is an integrated language, framework, and editor for building web backends: REST API endpoints, asynchronous background workers, scheduled jobs, and persistent storage. Darklang's framework is tightly coupled to the infrastructure, and as you write code you're able to develop from real incoming requests/traces.
Dark Basic Pro - Dark Basic Pro is an open source BASIC programming language for creating Windows applications and games.
Darklang - a combined language, editor, and infrastructure to make it easy to build backends and CLIs.
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.
Dashrep - Dashrep™, the text-manipulation programming language that is powerful and fast, yet simple
Daybreak - Programming language that compiles to C
Derw - An Elm-inspired language that transpiles to TypeScript. Derw is a type-safe language in the ML family designed to replace or augment your TypeScript and JavaScript code - both on the client and the server. If you've never encountered an ML language before, some of the core principles - which Derw follows - is a clean and concise syntax, paired with a powerful type system.
DeviceScript - TypeScript for Tiny IoT Devices (ESP32, RP2040, ...). DeviceScript brings a TypeScript developer experience to low-resource microcontroller-based devices. DeviceScript is compiled to a custom VM bytecode, which can run in very constrained environments. [Tiny, IoT]
Dhall - Dhall is a programmable configuration language that you can think of as: JSON + functions + types + imports
Dialect - Dialect is an interpreted programming language with GUI, networking, and object oriented capabilities. The Dialect language (a.k.a. Aristar Dialect Pro) source code has been released to the public under an Apache style Open Source license. The source code is available on sourceforge.net directly from the CVS repository and also as a separate zip package file.
Dictu - Dictu is a high-level dynamically typed, multi-paradigm, interpreted programming language.
Diesel - Diesel is a purely object-oriented, type-safe, garbage-collected language intended to support rapid construction of high-quality, extensible software. Diesel is an evolutionary successor to Cecil, retaining Cecil's support for multimethods, first-class function objects, uniform access to all instance variables and methods via dynamically dispatched messages, predicate classes, multiple inheritance, open classes where methods and instance variables are declared separately from their classes, and a constraint-based polymorphic static type system.
Dino - High-Level scripting object-oriented language:
- Multi-precision integers
- Heterogeneous extensible arrays, array slices
- Associative tables with possibility to delete elements
- Powerful and safe class composition operation for (multiple) inheritance and traits description
- First class functions, classes, and fibers with closures, anonymous functions, classes, fibers
- Exception handling
- Concurrency
- Pattern matching
- Unicode 8 support
DML - DML is a simple templating language designed for managing web sites based in static HTML files (no CGI, SSI, etc.). It has been obsoleted by DML2 which has in turn been obsoleted by XSLT.
DML2 - DML2 is an object-oriented content storage and document formatting framework. Using a fairly simple, object-oriented language and a few templates, generating different types of media from the same source content is made easy. This tool has been obsoleted by XSLT.
Draak - Draak is a Multilanguage Macro compiler. What does that mean? Draak is a compiler that has the ablity to compile any language for any platform by being a generic compiler. It reads in a language description file and uses it to compile a program. It has two parts: parser and macros. The parser replaces Yacc and Lex, and the macros replaces the code generation for traditional compilers.
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.
Dream Maker - The DM (Dream Maker) language uses a syntax similar to C/C++ to build networked multi-user worlds. This reference and the accompanying guide discuss the structure and function of DM.
Dusa - a logic programming language that has features of both Datalog and answer set programming.
DustyScript - The intent of this project is to write a programming language powerful enough to retain a 8/9-yr old's interest but simple enough... that the syntax can be grasped by them
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 (37):

E - E is an object-capability programming language and platform for writing distributed, secure, and robust software.
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.
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.
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.
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.
Edward2 - Edward2 is a simple probabilistic programming language. It provides core utilities in deep learning ecosystems so that one can write models as probabilistic programs and manipulate a model's computation for flexible training and inference.
EEL - EEL is a scripting and programming language, designed specifically for hard real time applications. The primary target areas of application are control engineering and audio synthesis, but EEL should also be suitable for game scripting and for adding scripting capabilities to real time multimedia applications. The syntax is C-like, but the language is higher level than C, and "safe" in the sense that EEL programs should not be able to crash the virtual machine or the host application. EEL has dynamic typing, automatic memory management, exception handling and built-in high level data types such as vectors, arrays and tables. New such data types can be added at run time by host applications. EEL compiles into byte-code that runs on a virtual machine, which means that no explicit support for specific architectures is needed for portability. The implementation is deliberately very self contained and has few dependencies, so that it can be easily integrated into "strange" environments, such as embedded devices running real time operating systems.
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.
egison - Egison is a functional programming language featuring its expressive pattern-matching facility. Egison allows users to define efficient and expressive pattern-matching methods for arbitrary user-defined data types including non-free data types such as lists, multisets, sets, trees, graphs, and mathematical expressions. This is the repository of the interpreter of Egison.
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.
ela - Ela is a simple, yet powerful modern functional language with a state-of-art syntax. Ela combines strict and lazy evaluation, dynamic typing and features, which are normally adopted by statically typed languages, such as algebraic data types and Haskell style type classes.
elastiC - elastiC is a portable high-level object-oriented interpreted language with a C like syntax.
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.
ELFE - ELFE (Extensible Language for Everyday (and the Internet of Things)) is a very simple and small programming language specifcally designed for everyday programming, notably for the Internet of Things. While ELFE is a general-purpose programming language, it is designed to facilitate the configuration and control of swarms of small devices such as sensors or actuators. It can also be used as a powerful, remotely-accessible extension language for larger applications.
Elijah - a high-level language suitable for replacement of C/C++ and Java. (And of course any other language in existence or non-existence, except FORTRAN and NULL.)
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.
Elvish - Elvish is an expressive programming language and a versatile interactive shell, combined into one seamless package. It runs on Linux, BSDs, macOS and Windows.
EML - Extended ML (EML) is a framework for specification and formal development of Standard ML (SML) programs. EML specifications look just like SML programs except that axioms are allowed in signatures and in place of code in structures and functors. Some EML specifications are executable, since SML function definitions are just axioms of a certain special form. This makes EML a "wide-spectrum" language which can be used to express every stage in the development of a SML program from the initial high-level specification to the final program itself and including intermediate stages in which specification and program are intermingled.
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.
emu - Emu (The EMbeddable Utility Language) is a clean, fast, flexible and free programming language. It is designed to be embedded into other files, such as text documents, web page etc
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.
Enterprise - Enterprise™ is a non-deterministic-unnecessarily-statically-typed™ Turing-complete-ish™, Quantum-out-of-the-box™ programming language.
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.
ErgoAI - Flora-2 (now ErgoAI) is an advanced object-oriented knowledge representation and reasoning system. It is a dialect of F-logic with numerous extensions, including meta-programming in the style of HiLog, logical updates in the style of Transaction Logic, and defeasible reasoning. Applications include intelligent agents, Semantic Web, knowledge-based networking, ontology management, integration of information, security policy analysis, and more.
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.
ETAC - ETAC™ (pronounced: E-tack) is a syntactically simple but extremely versatile general purpose dictionary and stack based interpreted script programming language fully capable of traditional high-level block structured language style syntax.
etalk - A Simple Object-Oriented Language
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).
Evlan - Evlan is a programming language and a virtual machine, similar to Java/JVM or C#/.NET, but with many advantages. While Java and C# are essentially small extensions to the 35-year-old C/C++ software paradigm, Evlan makes a point of being very different.
evolve - Evolve is an interpreted programming language, it has been designed to be easy to use so anyone can quickly learn how to write a PC program. To this end the instruction set has been kept to a minimum and the commands and syntax have been kept as simple as possible.
execline - execline is a (non-interactive) scripting language, like sh - but its syntax is quite different from a traditional shell syntax. The execlineb program is meant to be used as an interpreter for a text file; the other commands are essentially useful inside an execlineb script. execline is as powerful as a shell: it features conditional loops, getopt-style option handling, filename globbing, and more. Meanwhile, its syntax is far more logical and predictable than the shell's syntax, and has no security issues.
Expr - Expression language and expression evaluation for Go.

F (62):

F - F is a pure functional concatenative language originally designed as an extension of False. F contains the list-operations of K3 and the dip combinator of Joy. Floating-point and symbolic datatypes are supported. One-time assignment is enforced in syntax. A theory of function-valence and -charge is outlined. F also contains a general continuation primitive $, and the pattern sublanguage of XY. G is a variant of F in which the K3 adverbs are implemented as primitives.
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.
Fabric - Fabric is a high-level programming language for building open distributed applications with strong security. Fabric enables securely computing and storing information, and sharing code and data across trust boundaries. It is being developed by the Applied Programming Languages Group at Cornell University.
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.
FALSE - I designed this language in ‘93 with two particular objectives: confusing everyone with an obfuscated syntax, and designing an as powerful language as possible with a tiny implementation: in this case a compiler executable of just 1024 bytes (!), written in pure 68000 assembler.
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.
FAST - FAST is a new programming language, which combines the advantages of other programming languages:
- FAST supports functions as data types
- FAST is fully object-oriented and knows multiple inheritance
- FAST has dynamical memory management and garbage collection
- FAST includes library units on its own
- FAST speaks Assembler
- FAST knows macros
- FAST has a clear and consequent syntax
- FAST compiles within tenths of seconds and creates efficient code
- FAST has lots of useful features such as e.g. the prevention of the Division by Zero error FAST programs are written as plain text and then sent thru the FAST compiler. Small and efficient code is created and a COM-File results. Up to now, FAST only compiles for MS-DOS (I just have not yet found out how to assemble a binary executable for WINDOWS).
FAST - FAST: A Transducer-Based Language for Tree Manipulation
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.
Fay - A proper subset of Haskell that compiles to JavaScript.
fbgc - Small Language and Calculator in C
FBSL - Freestyle Basic Script Language (FBSL) is a programming language.
- It's powerful.
- It's easy to learn.
- It can produce GUI or console-based applications.
- It can produce standalone executables.
- It's free for non-commercial use.
Fe - A tiny, embeddable language implemented in ANSI C.
Felix - An advanced, statically typed, high performance scripting language with native C++ embedding.
Fennel - Fennel is a lisp that compiles to Lua. It aims to be easy to use, expressive, and has almost zero overhead compared to writing Lua directly.
Feral - Feral is a dynamically typed, imperative, interpreted language which revolves (to most extent) around the idea of minimalism.
ferite - ferite is a scripting language and engine all in one managable chunk. It is designed to be easily extended in terms of API, and to be used within other applications making them more configurable and useful to the end user. It has a syntax similiar to a number of other langauges but remains clean and it's own language.
ferite - ferite is a scripting language and engine all in one managable chunk. It is designed to be easily extended in terms of API, and to be used within other applications making them more configurable and useful to the end user. It has a syntax similiar to a number of other langauges but remains clean and it's own language. It's origins are from one of those "it seems like a good idea", the good idea was provoked by finding perl a real pain in the arse to embed (from what I gather it's easier nowadays). It started in the summer of 2000 (with various tries and fails within the pre-ceding two years). It is slowly maturing and should be fit for general consumption by the first quarter of 2003, by which point we start to add more exotic features.
FermaT - The FermaT Transformation System is a powerful industrial-strength program transformation system based on the WSL language. FermaT has been used sucessfully in several major assembler to C and assembler to COBOL migration projects involving the conversion of millions of lines of hand-written assembler code to efficient and maintainable C or COBOL code.
Fermat - Fermat is a computer algebra system for Macintosh, Windows, Linux, and Unix by me, Robert H. Lewis of Fordham University, that does arithmetic of arbitrarily long integers and fractions, multivariate polynomials, symbolic calculations, matrices over polynomial rings, graphics, and other numerical calculations. It is extremely fast and extremely economical of space.
Ficl - Ficl is an acronym for "Forth Inspired Command Language". Ficl is a programming language interpreter designed to be embedded into other systems as a command, macro, and development prototyping language.
Fig - a compiled, statically-typed, garbage collected and expressive programming language.
Figaro - Figaro is a probabilistic programming language that supports development of very rich probabilistic models and provides reasoning algorithms that can be applied to models to draw useful conclusions from evidence. Both model representation and reasoning algorithm development can be challenging tasks. Figaro makes it possible to express probabilistic models using the power of programming languages, giving the modeler the expressive tools to create a wide variety of models. Figaro comes with a number of built-in reasoning algorithms that can be applied automatically to new models. In addition, Figaro models are data structures in the Scala programming language, which is interoperable with Java, and can be constructed, manipulated, and used directly within any Scala or Java program.
FIJI - FIJI the ForthIsh Java Interpreter is an interactive environment with a procedural syntax similar to the Forth programming language. FIJI can load, introspect, and execute Java classes and methods. FIJI's main use is for unit and component testing of Java, or for an interpreter in an all-Java environment.
Finch - Finch is a simple bytecode interpreted, purely object-oriented, prototype-based, dynamically-typed programming language. It's mostly inspired by Smalltalk, Self, and Javascript.
Finitio - Finitio is a data language. For now, it is limited to a data definition language (DDL). Think "JSON/XML schema", but a slightly different way, that puts the emphasis on precision. Finitio comes with a dedicated type system for defining data and a theory, called information contracts, for interoperability with programming and data exchange languages.
FiveTran - Fivetran, a FORTRAN language targeting Mako. Mako is an extremely simple stack-based virtual machine intended for the creation of video games.
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.
Flavor - Flavor (Formal Language for Audio-Visual Object Representation) is an object-oriented media representation language designed for simplifying the development of applications that involve a significant media processing component (encoding, decoding, editing, manipulation, etc.). It provides a formal way for describing any coded audio-visual or general multimedia bitstream, and it comes with a translator that can automatically generate C++/Java code from the Flavor description. The generated code can readily be used as a bitstream parser, generator or tracing tool.
Fleng - This software is an implementation of "FLENG", a low level concurrent logic programming language descended from Prolog. A compiler is provided to translate programs written in FLENG into assembly language which can subsequently be compiled and linked into a binary executable.
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.
Florid - FLORID (F-LOgic Reasoning In Databases) is a deductive object-oriented database system employing F-Logic as data definition and query language. The development was supported by the Deutsche Forschungsgemeinschaft (project La 598/3-2). With the increasing interest in semistructured data, Florid has been extended for handling semistructured data in the context of Information Integration from the Semantic Web.
Flow - a safe, functional strongly-typed programming language.
Floyd - Floyd is a general-purpose programming language designed for making very large and robust programs that run really fast, while ducking many of the problems of older languages. Floyd wants to become a better choice than C++, Rust, C#, Python and Javascript for any project.
Flux - Flux is a lightweight scripting language for querying databases (like InfluxDB) and working with data. It's part of InfluxDB 1.7 and 2.0, but can be run independently of those.
Foma - Foma is a compiler, programming language, and C library for constructing finite-state automata and transducers for various uses. It has specific support for many natural language processing applications such as producing morphological analyzers. Although NLP applications are probably the main use of foma, it is sufficiently generic to use for a large number of purposes.
Forest - Forest is a domain-specific language for describing filestores.
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.
Formula 2.0 - FORMULA 2.0 is framework for formally specifying domain-specific languages (DSLs) and model transformations. FORMULA specifications are succinct descriptions of DSLs, and specifications can be immediately connected to state-of-the-art analysis engines without additional expertise. FORMULA provides: (1) succinct specifications of DSLs and compilers, (2) efficient compilation and execution of input programs, (3) program synthesis and compiler verification.
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.
frawk - an efficient awk-like language
FreeBASIC - FreeBASIC is a completely free, open-source, multi-platform BASIC compiler, with syntax similar to MS-QuickBASIC, that adds new features such as pointers, object orientation, unsigned data types, inline assembly, and many others.
FreeOberon - Cross-platform IDE for development in Oberon programming language made in the classical FreePascal-like pseudo-graphic style.
FreePascal - Free Pascal is a mature, versatile, open source Pascal compiler. It can target many processor architectures: Intel x86 (16 and 32 bit), AMD64/x86-64, PowerPC, PowerPC64, SPARC, SPARC64, ARM, AArch64, MIPS, Motorola 68k, AVR, and the JVM. Supported operating systems include Windows (16/32/64 bit, CE, and native NT), Linux, Mac OS X/iOS/iPhoneSimulator/Darwin, FreeBSD and other BSD flavors, DOS (16 bit, or 32 bit DPMI), OS/2, AIX, Android, Haiku, Nintendo GBA/DS/Wii, AmigaOS, MorphOS, AROS, Atari TOS, and various embedded platforms. Additionally, support for RISC-V (32/64), Xtensa, and Z80 architectures, and for the LLVM compiler infrastructure is available in the development version. Additionally, the Free Pascal team maintains a transpiler for pascal to Javascript called pas2js.
Frege - Frege is a Haskell for the JVM. It brings purely functional programing to the Java platform. Like any Haskell, it is purely functional, enjoys a strong static type system with global type inference and non-strict - also known as lazy - evaluation. Frege compiles to Java, runs on the JVM, and uses any Java library you want. It can be used inside any Java project.
Frenetic - Frenetic is an open-source Software Defined Network (SDN) controller platform designed to make SDN programming easy, modular, and semantically correct
friend - 1)Compiler/interpreter for a simple OO language. The language allows to use networking very easily, including such protocols as TCP, UDP, Raw Sockets 2) Library for reading/manipulating Java bytecode
Frost - Frost is a high-level, general-purpose multiparadigm programming language
FScript - FScript is an extremely simple scripting language. Its intended use is as an embedded language in other Java programs. It is very simple to embed - it can be as simple as sub-classing one class to add your own functionality. However is not a complete programming language, as it has no library of standard functions (such as IO and string processing). FScript supplies a base functionality (such as flow control, variable handling and basic math operations) that can extended by the host application.
Ftwalk - Ftwalk is a general purpose script programming language. It is based on the concepts of Awk, but has been extended to support features such as are found in languages like Perl, Python, and Ruby.
FUN - FUN is a simple, structured, imperative, dynamic, object-oriented, functional and high-level programming language. FUN was developed by Wisdom ZHANG in 2010 as a scripting language to reuse resources of Pascal. FUN's syntax is simple and clear, it comes from Ada and was changed for easy to use and input. FUN's exception handling syntax is similar to Delphi. FUN is dynamic typing and supports type conversions automatically when needed. FUN supports class-based object-oriented programming. FUN supports first-class functions functional programming, looks like Lisp and Javascript. FUN implements a simple and lightweight reference counting garbage collector. FUN's regular expressions handling is Perl-Compatible. FUN provides simple and powerful list process, it looks like arrays, associative arrays, hash tables, dictionaries or mappings too.
Funnel - Funnel is a programming language based on Functional Nets. Functional Nets combine key ideas of functional programming and Petri nets to yield a simple and general programming notation. They have their theoretical foundation in Join calculus.
Fusion - Fusion is a programming language which can be translated automatically to C, C++, C#, D, Java, JavaScript, Python, Swift, TypeScript and OpenCL C. Instead of writing code in all these languages, you can write it once in Fusion. [Transpiler]
Futhark - High-performance purely functional data-parallel array programming on the GPU. Futhark is a small programming language designed to be compiled to efficient parallel code. It is a statically typed, data-parallel, and purely functional array language in the ML family, and comes with a heavily optimising ahead-of-time compiler that presently generates GPU code via CUDA and OpenCL, although the language itself is hardware-agnostic and can also run on multicore CPUs.
Fux - Flawless Unambiguous Programming - A Modern, Flexible Programming Language for All. Fux is a modern and flexible programming language, perfect for use in a variety of domains by both novice and expert developers. With its efficient use of LLVM, it provides performance similar to C++, while being portable and running on a wide range of platforms.
Fuzion - A language with a focus on safety and performance. It unifies concepts found in other programming languages to improve productivity and shall provide tools for performance and correctness.
Fuzuli - JFuzuli is the JVM implementation of our programming language Fuzuli which is based on LISP syntax and Algol family programming logic. Fuzuli is a modern collaboration of these two separate family of languages.

G (45):

GALATEA - Glider with Autonomous, Logic-based Agents, TEmporal reasoning and Abduction. GALATEA is software to model and simulate multi-agent systems. It is the product of two lines of research: simulation languages based on Zeigler's theory of simulation and logic-based agents. There is, in GALATEA, a proposal to integrate, in the same simulation platform, conceptual and concrete tools for multi-agent, distributed, interactive, continuous and discrete event simulation.
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.
GAML - GAML is an agent-oriented language dedicated to the definition of agent-based simulations. It takes its roots in object-oriented languages like Java or Smalltalk, but extends the object-oriented programming approach with powerful concepts (like skills, declarative definitions or agent migration) to allow for a better expressivity in models.
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.
Gecho - Simple stack language in C. Has a few basic commands; working to implement a while loop and user-defined functions. If statement would be nice.
Gene - Gene is a common purpose programming language. It is inspired by languages such as object pascal, C++, sql and EBNF languages such as Coco/R, lex and yacc and is a pure object oriented language. It is therefor ideally suited for applications that process a lot of sequential input and output such as scanners, parsers and data generators. Gene also has build in support for container objects (objects that manage a list of other objects such as arrays, linked lists, queues, sql tables,...).
GeneralScript - GeneralScript is a lightweight general purpose scripting engine which provides Scheme like syntax.
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.
genyris - Inspired by the Semantic Web, Genyris presents a new programming paradigm. Objects can belong to multiple classes independent from construction. Indentation reduces parentheses yet retains the power of Lisp. External Java libraries can be imported.

Objects can belong to multiple classes
Classes are assigned to objects after construction
Indentation syntax reduces parentheses
Use Java class libraries like Swing
100% Java
Multi-tasking
Higher order functions and macros
Indented syntax

GF - GF, Grammatical Framework, is a programming language for multilingual grammar applications. It is
a special-purpose language for grammars, like YACC, Bison, Happy, BNFC, but not restricted to programming languages
a functional programming language, like Haskell, Lisp, OCaml, SML, Scheme, but specialized to grammar writing
a development platform for natural language grammars, like LKB, XLE, Regulus, but based on functional programming and type theory
a categorial grammar formalism, like ACG, CCG, but specialized for multilingual grammars,
a logical framework, like Agda, Coq, Isabelle, but equipped with concrete syntax in addition to logic
a platform for machine translation, like Moses, Apertium, but based on deep structural analysis (and usually applied for limited fragments of language).
ghūl - ghūl is a general-purpose, statically-typed, managed programming language. It supports object-oriented programming with functional elements through a quirky syntax reminiscent of ALGOL 68 and Pascal that aims to be both expressive and readable. The language targets .NET and interoperates with the .NET ecosystem. The self-hosting ghūl compiler, written entirely in ghūl, shows the language's capabilities and dogfooding philosophy.
GIMI - This is GIMI, the Graphical Interfaced Multitasking Interpreter. One of the few GUIs made in QuickBASIC featuring multitasking. This one has its own script language for making programs, damm fast SVGA modes, lots of programs, and more!
Giml - A functional programming language with emphasis on structural typing.
GIPSY - A General Intensional Programming SYstem
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.
Glee - The Glee Programming Language is a new vector oriented interpretive computer programming tool. It is inspired by array oriented languages like APL, J, and K. It attempts to deliver many of the useful and powerful features of those languages for manipulating numeric data. Further, it strives to provide new functionality for consistent and powerful manipulation of character data. It is targeted at applications where languages like PERL, Python, and Java have found secure homes. These are all scalar languages so Glee has something new to bring to the party ... vector processing.
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.
gnarly - Design and Implementation of a Hybrid Typed Programming Language
Go+ - The Go+ programming language is designed for engineering, STEM education, and data science.
- A static typed language.
- The simplest engineering language that can be mastered by children (script-like style).
- Performance: as fast as Go (Go+'s main backend compiles to human-readable Go).
- Fully compatible with Go and can mix Go/Go+ code in the same package (see Go/Go+ hybrid programming).
- No DSL (Domain Specific Language) support, but it's Specific Domain Friendly (see DSL vs. SDF).
- Support Go code generation (main backend) and bytecode backend (REPL: see iGo+).
- Simplest way to interaction with C (cgo is supported but not recommended).
- Powerful built-in data processing capabilities.
Goal - Goal is an embeddable array programming language with a bytecode interpreter, written in Go. It provides both a command line intepreter (that can be used in the REPL), and a library interface. The core features are mostly there and tested, so Goal is usable both for writing useful short scripts and playing with the REPL. User testing and bug reports are welcome! Like in most array programming languages, Goal's builtins vectorize operations on immutable arrays, and encourage a functional style for control and data transformations, supported by a simple dynamic type system with little abstraction, and mutable variables (but no mutable values).
goaldi - Goaldi is a new general-purpose programming language that combines the goal-directed evaluation model of the Icon language with modern features such as concurrency, objects, closures, and Unicode support. While Goaldi will look familiar to Icon programmers, it is not upwards compatible.
Goby - Goby is an object-oriented interpreter language deeply inspired by Ruby as well as its core implementation by 100% pure Go. Moreover, it has standard libraries to provide several features such as the Plugin system. Note that we do not intend to reproduce whole of the honorable works of Ruby syntax/implementation/libraries.
Gofolio - the programming language for the ATARI portfolio
Gofra - Concatenative programming language
Golo - The world didn’t need another JVM language. So we built yet another one. A simple one.
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.
GPP - GPP is a general-purpose preprocessor with customizable syntax, suitable for a wide range of preprocessing tasks. Its independence from any one programming language makes it much more versatile than the C preprocessor (cpp), while its syntax is lighter and more flexible than that of GNU m4. There are built-in macros for use with C/C++, LaTeX, HTML, XHTML, and Prolog files.
GrADS - The Grid Analysis and Display System (GrADS) is an interactive desktop tool that is used for easy access, manipulation, and visualization of earth science data. GrADS has two data models for handling gridded and station data. GrADS supports many data file formats, including binary (stream or sequential), GRIB (version 1 and 2), NetCDF, HDF (version 4 and 5), and BUFR (for station data). GrADS has been implemented worldwide on a variety of commonly used operating systems and is freely distributed over the Internet.
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.
Gremlin - Gremlin is a domain specific language for traversing property graphs. Gremlin makes use of Pipes to perform complex graph traversals. This language has application in the areas of graph query, analysis, and manipulation. Connectors, provided by Blueprints, exist for the following graph management systems:
Gren - Gren is a pure functional programming language that is easy to learn, but powerful in use.
Gri - Gri is a language for scientific graphics programming. The word "language" is important: Gri is command-driven, not point/click. Gri can make x-y graphs, contour graphs, and image graphs, in PostScript and (someday) SVG formats. Control is provided over all aspects of drawing, e.g. line widths, colors, and fonts. A TeX-like syntax provides common mathematical symbols.
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.
Gui4Cli - Gui4Cli is an interpreted, untyped, procedural programming language for easily creating Windows apps. It has a wide set of commands, it can be easily extended and can create self-standing executables. It is Event-driven, and intuitive and geared to creating stand-alone guis or interfaces for other, console driven programs (as it's name implies). The new version can also handle Unicode.
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.
gura - A programming language that comes with powerful operation on iterators.
GvR - Guido van Robot, or GvR for short, is a programming language and free software application designed to introduce beginners to the fundamentals of programming. GvR runs on Windows, Macintosh, and GNU/Linux, in a variety of languages! It's great in both the classroom and the home as a way of introducing people to the basic concepts of programming.
Gwion - A strongly-timed programming language aimed at music creation. Heavily inspired by ChucK.
GYS - GYS has built-in lexical and expression analyzer, but during interpretation it calls different user code for executing commands, operators, conversions and value getting. The interpreter is fully runtime - it reads code and interprets it at once. GYS doesn't generate any intermediate code. User doesn't have to use stack to implement his GYS-derived script language. The "abstract" GYS interpreter can be called within application to execute the script according to the designed language definition and functionality. The library provides an easy and clear way to define a scipt language interpreter step-by-step: developer can define next language elements:
GZigZag - Zzstructure is a way of representing the structure of information. Compared with the previous ways, Zzstructure is very different, for example the concepts of 'file', 'folder' and 'application' are abandoned. Because of this a bit of fantasy, creativity and an ability to forget previous knowledge is needed in order to understand Zzstructure. A Zzstructure structure consists of cells and dimensions. A cell is the basic unit of information of a Zzstructure structure. Cells containing related information can be connected with each other along dimensions, the number of which is unlimited. A Zzstructure structure is separate from its visualisation (= the way the data is presented on the screen), which means that a Zzstructure structure can have many visualisations designed for different purposes.
Gödel - Gödel is a declarative, general-purpose programming language in the family of logic programming languages. It is a strongly typed language, the type system being based on many-sorted logic with parametric polymorphism. It has a module system. Gödel supports infinite precision integers, infinite precision rationals, and also floating-point numbers. It can solve constraints over finite domains of integers and also linear rational constraints. It supports processing of finite sets. It also has a flexible computation rule and a pruning operator which generalises the commit of the concurrent logic programming languages. Considerable emphasis is placed on Gödel's meta- logical facilities which provide significant support for meta-programs that do analysis, transformation, compilation, verification, debugging, and so on

H (29):

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.
Happy - A scripting language with syntactic sugar for code generation. Happy has the concept of a "current output." The current output is simply a System.IO.TextWriter where all template output is directed. At the moment, the current output must be determined by the host program executing the Happy script. This is usually the command-line application, in which case the current output is directed at the file specified in one of the command-line options. A host program in which Happy has been embedded can specify any TextReader as the current output.
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.
Harlan - Harlan is a domain specific language for programming GPUs. This project serves primarily as a testbed for implementation and optimization techniques. The language is intentionally small, in order to simplify the process of exploring new analyses and optimizations.
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]
Heptagon - Heptagon is a synchronous dataflow language whose syntax and semantics is inspired from Lustre, with a syntax allowing the expression of control structures (e.g., switch or mode automata).
Heron - Heron is a small cross-platform language that was designed for ease of use, performance, and safety with a JavaScript like syntax. Heron emphasizes pure functional programming code, but looks like a traditional imperative or object-oriented code.
Herschel - Herschel is an general-purpose multiparadigm programming language. It is strongly typed, offering type inference and parametric polymorphism ("generics"). It is consequently object oriented (everything is a object, even functions), while its consequent multiple dispatch approach keeps a strong functional touch. The object model is class-oriented, supporting multiple inheritance as well as the separation of types ("protocols", "interfaces") and classes.
HGSL - A shading language that can be compiled into GLSL ES 3.0.
HicEst - Integrated development environment with graphical user interface designed for immediate results in the development of Windows applications.
Hilvi - Hilvl is a programming language that is versatile but with a very small syntax. All code in hilvl are single-argument invocations of actions that belong to services. Services are the fundamental building blocks of a hilvl program. And the name hilvl reflects how this is a higher level of abstraction than objects and functions.
Hobbes - Hobbes is built for high performance integration with C/C++ applications.
Hook - Hook is an imperative, cross-platform, dynamically typed scripting language that utilizes a mutable value semantics approach.
Hop - a multitier JavaScript also supports the Scheme programming language. With Hop.js, JavaScript and Scheme are fully interoperable and applications can mix both languages. This page mostly describes the JavaScript layer. The Scheme layer is described in a dedicated programming manual.
Hope - Hope is a lazily evaluated functional programming language developed in 1970's by Ross Paterson. It influenced the design of other lazy languages such as Miranda and Haskell.
hue - A functional 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.
Hylo - Hylo (formely Val) is a programming language that leverages mutable value semantics and generic programming for high-level systems programming.
HypoLambda - A very compact functional programming language for .NET. Its syntax is based on Python, but whitespaces are ignored. Everything is an expression. The language runtime is embeddable, its AST is accessible, and it compiles to portable pcode. There's a REPL you can play with, and the project includes lots of unit tests.
Húngaro - A syntax based programming language.

I (37):

I - I is a programming language designed by the I Project. It has been designed to be efficient to write and run. The system incorporates many major libraries allowing the creation of major projects such as Aciqra. It is an interpreted language and supports CGI scripting through the use of the CGI for Aciv/I extension.
IBAL - IBAL is a functional language for specifying probabilistic models. Models in IBAL look like programs in a functional programming language. In the functional approach, a model is a description of a computational process. The process stochastically generates a value, and the meaning of the model is the distribution over the value generated by the process.
ICE - ICE: A new BASIC-like programming language for the CE calculators. ICE compiles a TI-BASIC-like language into eZ80 binary, the native machine code of the CE calculators.
Idle - Idle is a simple but powerful scripting language, in basically the same vein as the venerable Perl or Python languages. It is, however, an altogether more lightweight application: the basic installation zip weighs in at around 800 KB (and this includes the full documentation and loads of example scripts). At the core of Idle sits a tweaked and significantly enhanced version of Lua. Idle inherits from Lua its elegant and powerful language definition as well as a highly-optimised interpreter kernel (an extremely fast compiler is included as well). Idle, like Lua, is readily extended with additional functions, modules and libraries (which can be written either in C/C++ or in Idle itself).
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.
IENJINIA - IPL is the IENJINIA Programming Language used in the IENJINIA Devkit to write games for the IENJINIA Virtual Console. It is a very simple interpreted language with dynamic typing, static scoping and automatic garbage collection.
ilang - ilang is designed to be a new type of programming lanuage that supports different types of programming paradimes with a focus towards artificial inteligence
ILYC - ILYC is an interpreted programming language with a simple and friendly syntax, which is suitable for beginners and hobbyist. The purposes of creating such a language was for the author to practice programming and for others to study how to implement an interpreter in the .NET framework.
Imba - Imba is a friendly full-stack programming language for the web that compiles to performant JavaScript. It has language-level support for defining, extending, subclassing, instantiating and rendering DOM nodes.
Imp - Various experiments in relational programming
IMP - IMP is an "ALGOL-like" high-level language that was originally designed as the implementation language for the Edinburgh Multi-Access System, developed at Edinburgh University. It was widely used at Edinburgh University for implementing systems, teaching programming and as a general purpose programming language on many different machines. Because IMP did not see significant commercial adoption (unlike its contemporary, C and later C++), it is not generally available on current platforms. For the Edinburgh Computing History Project, which aims to collect and publish significant software archives from Edinburgh University, this was a problem, because much of that software heritage is written in IMP. The solution - to produce an IMP compiler for current mainstream Intel x86 machines.
Impulse - Impulse is a small, dynamically typed, message based prototypical language written with simplicity in mind. Its syntax and semantics are derived mostly from Ruby, Io, Smalltalk and Dylan, and it's purpose is to be a smarter 'scripting' language, with features such as trait composition, extension methods (wich solves monkey-patching), and constructor field initialization. A core goal is to keep the language, both the implementation and the syntax, small and lightweight.
Incanter - Incanter is a Clojure-based, R-like platform for statistical computing and graphics.
Inform 6 - The latest version of the Inform 6 compiler, used for generating interactive fiction games.
Inform 7 - Inform is a programming language for creating interactive fiction, using natural language syntax. Using natural language and drawing on ideas from linguistics and from literate programming, Inform is widely used as a medium for literary writing, as a prototyping tool in the games industry, and in education, both at school and university level (where Inform is often assigned material for courses on digital narrative). It has several times ranked in the top 100 most influential programming languages according to the TIOBE index. Created in April 2006, it was open-sourced in April 2022.
Ink - Ink is a minimal programming language inspired by modern JavaScript and Go, with functional style. Ink can be embedded in Go applications with a simple interpreter API.
ink - A narrative scripting language for games
Inko - Inko is a statically-typed, safe, object-oriented programming language for writing concurrent programs.
Insanity - Insanity is a block-based programming language with powerful commands, such as file I/O, cloud variables, and much more. It is based off Scratch 1.4 by MIT.
interp - interp is a powerful programming language. Check-out the language features, then take the tour. It is targeted for Linux/Unix-based systems, yet remains adaptable to less powerful embedded systems that were never intended to host a programming language.
Io - Io is a pure object-oriented (relying on prototype-based paradigm) programming language focused on expressiveness through simplicity.
Ioke - Ioke is a dynamic language targeted at virtual machines, currently the Java Virtual Machine and the Common Language Runtime. It's been designed from scratch to be a highly flexible general purpose language. It is a prototype-based programming language that is inspired by Io, Smalltalk, Lisp and Ruby.
ipl - ipl stands for the Invocation (programming) Language, a concurrent programming language described by Karl Fant in his book Computer Science Reconsidered: The Invocation Model of Process Expression (Wiley-Interscience 2007).
IronAHK - IronAHK is a rewrite of AutoHotkey, a powerful and easy to use scripting language for automation on the desktop. It is developed in C# for .NET and Mono which brings cross-platform compatibility, increased performance, enhanced security, Unicode, native 64-bit support, smaller file sizes for compiled binaries and much more.
ironlua - IronLua currently features a working top-down-operator-precedence Lua 5.2 parser but no compiler for the time being. I do not plan on using the DLR. The solution also includes a C# interpreter, but it's all work-in-progress.
IronPython - IronPython is an open-source implementation of the Python programming language which is tightly integrated with .NET. IronPython can use .NET and Python libraries, and other .NET languages can use Python code just as easily.
IronRuby - IronRuby is a Open Source implementation of the Ruby programming language for .NET and Silverlight, heavily relying on Microsoft's Dynamic Language Runtime.
IronSapphire - Formerly Sapphire.NET, IronSapphire is aimed to be better than Sapphire.NET with its Pros, but none of its Cons. Sapphire is inspired by Conscript, C#, Python, VB.NET and Perl. It's developed in C#. Sapphire.NET is now called IronSapphire and will have improved syntax.
ISLISP - The ISLISP programming language is a member of the Lisp family of programming languages. It attempts to bridge the gap between the various incompatible members of the Lisp family of languages (most notably Common Lisp, Eulisp, LeLisp, and Scheme) by focusing on standardizing those areas of widespread agreement. It is a small language, closer to the size of Scheme than to Common Lisp, for example.
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]
ispc - ispc is a compiler for a variant of the C programming language, with extensions for "single program, multiple data" (SPMD) 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. ispc compiles a C-based SPMD programming language to run on the SIMD units of CPUs and GPUs; it frequently provides a 3x or more speedup on architectures with 4-wide vector SSE units and 5x-6x on archituctures with 8-wide AVX vector units, without any of the difficulty of writing intrinsics code. Parallelization across multiple cores is also supported by ispc, making it possible to write programs that achieve performance improvement that scales by both number of cores and vector unit size.
ivy - Ivy is an interpreter for an APL-like language. It is a plaything and a work in progress.
Ivy - Ivy is an extensible, dynamically typed, late binding language intended to be used as an embedded command language. It can also be used stand-alone: it can execute script files from the command line or presents a read-eval-print loop (REPL) to the user if no files are given. Ivy's extensibility is based on the fact that statements are syntactically identical to function calls. Also blocks (surrounded by braces) may be used as function arguments. Thus, new user-defined statements can be added just by defining functions. Function arguments are packaged up as thunks and may have their evaluation delayed and execution environment modified. This allows user defined functions to do many of the things that traditional language statements can do.
ivy - Ivy is an open-source machine learning framework that enables you to: 🔥 Autotune your model: Automatically find the optimal framework, compiler infrastructure and hardware for your specific use case using ivy.autotune. 🔄 Convert code into any framework: Use and build on top of any model, library, or device by converting any code from one framework to another using ivy.transpile. ⚒️ Write framework-agnostic code: Write your code once in ivy and then choose the most appropriate ML framework as the backend to leverage all the benefits and tools.
Ivy - Ivy is an embeddable byte-code compiled/interpreted language which is useful as both an extension and a command language. Its syntax is designed to be easy to learn and to be fairly good looking. Ivy currently supports four data types: integers, strings, functions and objects. Objects are late-binding storage devices which take the role of arrays, structures and simple look-up tables. Floating point or arbitrary length floating point numbers will be available in a future implementation. Ivy comes packaged as an interactive language like BASIC and LISP. You can either execute language statements immediately from the keyboard or run a program stored in a file. Ivy is also easy to embed into another program. Calls are provided to execute Ivy code and to add C function extensions to Ivy's interpreter.
IvyScript - The IvyScript language is used to write business rules, for manipulating process data and to define data mappings for Axon.Ivy. Axon.ivy is a Digital Business Platform that simplifies and automates the interaction of humans with their digital systems. The platform is typically in charge of the most precious business cases where companies produce value."
ixicl - ixicl is a runtime-mutable language engine capable of running script files or as a persistent daemon, and optionally storing program state in a realtime database. ixicl allows programmers to create the language used to accomplish the desired task, and add sub-languages for functionality such as scriptability. Control over the language itself allows implementation of security and cooperative programming mechanisms. It is written entirely in ANSI compliant C, and will compile on a wide variety of platforms. The developers have a background in ColdC and other persistent databases; ixicl will likely pick up where these less active projects left off.

J (38):

J - J is a high-level, general-purpose programming language that is particularly suited to the mathematical, statistical, and logical analysis of data. It is a powerful tool for developing algorithms and exploring problems that are not already well understood.
J* - J* is a dynamic embeddable scripting language designed to be as easy as possible to embed into another program. It arises from the need of having a modern scripting language with built-in support for OOP whilst mantaning simplicity of use and a low memory footprint. It can be viewed as a middle ground between Python, a more complete scripting language with lots of features and libraries, and Lua, a small and compact language that is simple to embed but doesn't provide OOP functionalities out of the box. J* tries to take the best of both worlds, implementing a fully featured class system while maintaining a small standard library and employing the use of a stack based API for communication among the language and host program, rendering embedding simple.
Jabaco - Jabaco is a simple programming language with a Visual Basic like syntax. Jabaco enables you to create powerful software for all Java supported operating systems.
Jacinda - Functional, expression-oriented data processing language. APL meets AWK. A command-line tool for summarizing and reporting, powered by Rust's regex library.
Jakt - Jakt is a memory-safe systems programming language. It currently transpiles to C++.
Jal - Jal is a high-level language for a number of Microchip PIC (16c84, 16f84, 12c508, 12c509, 16F877) and Ubicom SX (SX18 and SX28) microcontrollers. I created Jal because I did not like any of the low-cost (or free) languages for these chips and implementing a high level language looked like a nice project. Implementing an existing HLL seemed more difficult and less fun than creating my own, so I just started writing the compiler and the language evolved on with it.
JALv2 - JALv2 is a rewrite of Wouter van Ooijen's famous Just Another Language.
JAM - JAM, a cross-platform tool for building client/server applications, has the unique ability to help develop complex applications with small amounts of custom coding. JAM applications can run unmodified on a diverse array of platforms and operating environments including MS Windows, MS DOS, HP HP-UX, Sun Solaris, IBM AIX, DEC UNIX, SCO OpenServer and Compaq/DEC OpenVMS. JAM also integrates seamlessly with the most popular relational databases, while providing transparent access to legacy systems via DRDA and ODBC.
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.
Janino - Janino is a super-small, super-fast Java compiler. Janino can not only compile a set of source files to a set of class files like JAVAC, but also compile a Java expression, a block, a class body, one .java file or a set of .java files in memory, load the bytecode and execute it directly in the running JVM.
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.
Jason - Jason is an interpreter for an extended version of AgentSpeak. It implements the operational semantics of that language, and provides a platform for the development of multi-agent systems, with many user-customisable features. Jason is available Open Source, and is distributed under GNU LGPL
Jasp - JASP is a small preprocessor for Jass programming language.
JASS Tools - JASS Tools are tools for parsing and analyzing the JASS scripting language, which used for scripting Maps and AI files in Blizzard Entertainment's Warcraft III.
Javalin - The Javalin Set of Macros (JASM) provdies a universal specification that enables the assembly language programmer to easily develop object oriented applications. JASM is also portable. You can create OOP applications that run on all supported architectures and platforms.
Javauto - Javauto is an automation language, unique due to its ability to perform mouse clicks, simulate keyboard input, and perform pixel searches. It compiles to executable code that runs on the JVM, so any program you write will be cross platform.
Jazz - Jazz is a high-level programming language for expressing, in a concise and accurate way, large digital synchronous circuits. From a language-designer perspective, Jazz is a declarative, single-assignment, higher-order, lazy, functional, and object-oriented language with parameterized types and multi-methods. Jazz is strongly-typed (with a type-system derived from ML-sub) and supports both the explicit and implicit declaration of variables and methods thanks to a powerful constraint-based type-inference algorithm. The syntax of Jazz and its object model are Java-like and should look familiar to any Java programmer.
Jelly - Jelly is a tool for turning XML into executable code. So Jelly is a Java and XML based scripting and processing engine.
Jest - Jest is a simple, high-level programming language built around the concept of compile-time code generation - what is often called meta-programming. Focussing on code generation leads to a language that is clean and simple, and yet extremely expressive. For a more in-depth discussion, please see the Introduction, or read some of the blog articles as they are posted.
JFLAP - JFLAP is software for experimenting with formal languages topics including nondeterministic finite automata, nondeterministic pushdown automata, multi-tape Turing machines, several types of grammars, parsing, and L-systems. In addition to constructing and testing examples for these, JFLAP allows one to experiment with construction proofs from one form to another, such as converting an NFA to a DFA to a minimal state DFA to a regular expression or regular grammar.
Jif - Jif is a security-typed programming language that extends Java with support for information flow control and access control, enforced at both compile time and run time. The source code for the Jif compiler and run-time system is available for download. Jif is written in Java and is built using the Polyglot extensible Java compiler framework.
Jim - Jim is an opensource small-footprint implementation of the Tcl programming language. It implements a large subset of Tcl and adds new features like references with garbage collection, closures, built-in Object Oriented Programming system, Functional Programming commands, first-class arrays and UTF-8 support. All this with a binary size of about 100-200kB (depending upon selected options).
Jinx - Embeddable scripting language for real-time applications.
jl - This is a small, embeddable LISP-like language. The intended use is for configuration files where it is desirable to be able to have complex configurations (JWM, for example).
JMatch - The JMatch language extends Java with pattern matching that supports both data abstraction and iteration abstraction. Patterns are not tied to algebraic data constructors as in ML; instead, a single JMatch method may be used in several modes, some of which can serve as patterns. JMatch provides modal abstraction that simplifies the specification and implementation of abstract data types. These modes that may share a common implementation as a boolean formula. Thus, the specification, implementation, and use of iteration abstractions are made convenient, by automatically finding multiple solutions to a formula or pattern.
JME - Java Math Expression - a powerful mathematical evaluator in Spanish and a structured script language, JMEScript, that makes use of it.
Joe-E - Joe-E is a subset of the Java programming language designed to support secure programming according to object-capability discipline. Joe-E is intended to facilitate construction of secure systems, as well as to facilitate security reviews of systems built in Joe-E.
Jolie - Jolie crystallises the programming concepts of service-oriented computing as linguistic constructs. The basic building blocks of software are not objects or functions, but rather services that can be relocated and replicated as needed. A composition of services is a service.
Jolt - Jolt is a systems programming language intended to be used anywhere one would use C++. It is as willing to get dirty in the name of performance. It is not willing to compromise in the name of compatibility with legacy languages. It is a language in which everything is an object, inheriting from Object, including the “primitive” types, and yet is capable of implementing many of these same types in itself. It includes features traditionally seen in dynamically-typed object-oriented languages such as Ruby, and even has some LISP features, yet does so in a way that preserves strong static typing and the performance benefits thereof.
Joy - The language Joy is a purely functional programming language. Whereas all other functional programming languages are based on the application of functions to arguments, Joy is based on the composition of functions. All such functions take a stack as argument and produce a stack as value. Consequently much of Joy looks like ordinary postfix notation. However, in Joy a function can consume any number of parameters from the stack and leave any number of results on the stack. The concatenation of appropriate programs denotes the composition of the functions which the programs denote. One of the datatypes of Joy is that of quoted programs, of which lists are a special case. Some functions expect quoted programs on top of the stack and execute them in many different ways, effectively by dequoting.
JS++ - JS++ is a programming language designed for high-quality web and mobile development.
Jsi - Jsi is a C (+/-) embeddable JavaScript interpreter alternative to languages such as Python, Lua, and Tcl
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.
Jule - An effective programming language to build efficient, fast, reliable and safe software.
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.
Juliet - A general purpose programming language.
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.

K (40):

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.
KAGSA - KAGSA is a new Interpreted programming language based on Python, the language will be practical and reliable in your projects.
Kal - Kal is a highly readable, easy-to-use language that compiles to JavaScript. It's designed to be asynchronous and can run both on node.js and in the browser. Kal makes asynchronous programming easy and clean by allowing functions to pause and wait for I/O, replacing an awkward callback syntax with a clean, simple syntax.
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.
kalimat - Kalimat is an educational programming language for Arabic-speaking children. It aims for readability and an easy to understand syntax while providing enough features to allow for complex, interesting and fun programs.
Kalyn - Self-hosting compiler from a Haskell-like Lisp directly to x86-64, developed fully from scratch.
kaoscript - kaoscript is programming language combining features from ES7, CoffeeScript, TypeScript, Rust, Swift, C# and more. Currently, kaoscript is transpiled to JavaScript.
Kapreolo - an interactive functional programming language.
Karel The Robot - Karel The Robot is a robot simulator that affords a gentle introduction to computer programming. Users write Karel programs and feed them to the simulator to watch them execute. Karel's programming language is similar to Pascal.
KaryScript - KaryScript is an experimental language to test the possibilities of a more readable textual language. It compiles to ES6 and can be considered a much better ECMAScript
Katahdin - Katahdin is a programming language where the syntax and semantics are mutable at runtime. Katahdin employs the theory of parsing expression grammars and packrat parsing. Unlike other contemporary work, Katahdin applies these techniques at runtime to allow the grammar to be modified by a running program. New constructs such as expressions and statements can be defined, or a new language can be implemented from scratch. It is built as an interpreter on the Mono implementation of the .NET framework.
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).
KCL - KCL is an open-source, constraint-based record and functional language that enhances the writing of complex configurations, including those for cloud-native scenarios. With its advanced programming language technology and practices, KCL is dedicated to promoting better modularity, scalability, and stability for configurations. It enables simpler logic writing and offers ease of automation APIs and integration with homegrown systems. [Configuration]
Keli - Keli is a general purpose programming language where its semantics are mostly based on the pure functional programming model (as of Haskell's) which includes user-defined algebraic datatypes, case matching and higher-order functions, while its syntactic structure is strongly influenced by Smalltalk's message sending syntax, such as the unary, binary and keywords messages.
Kempe - Kempe is a stack-based language and toy compiler for x86_64 and aarch64. It requires the nasm assembler when targeting x86_64.
Kernel - Kernel is a conservative, Scheme-like dialect of Lisp in which everything is a first-class object.
Kew - Kew is a powerful but small object-oriented programming language that offers many advanced features, including proper closures, first-class variables, relations, continuations, exceptions, dynamic variables, security, transactions, persistence....
Key - a dynamic language that allowed both class abstraction and object description.
Keysharp - Keysharp is a fork and improvement of the abandoned IronAHK project, which itself was a C# re-write of the C++ AutoHotkey project. The intent is for Keysharp to run on Windows, Linux and eventually Mac. For now, only Windows is supported.
Kin - Kin is a straightforward programming language created with the purpose of aiding Kinyarwanda speakers in easily learning programming.
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.
Kind - Kind is a pure functional programming language and proof assistant.
kink - Kink is an object-based programming language, adopting object system without inheritance, and delimited continuation as a building block of control structures.
Kite - Kite is a programming language designed to minimize as much of the programmer experience as possible — quick development and running time and low CPU and memory usage. As this is a new project, we're just getting things started. Feel free to poke around and learn more!
Kitsune - Kitsune is a simple prototype based programming language. Compiles to C++ for portability. Reasonably Fast. Have fun creating a new programming language. Has a good/complete standard library with a focus on games.
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).
KiXtart - KiXtart is a free-format scripting language and has rich built-in functionality for easy scripting. It supports COM (providing access to ADSI, ADO, WMI, etc) and thus is easily extensible. Since version 4.50 KiXtart comes with inbuild pre-tokenization system for faster loading and smaller scripts and providing some level of intellectual property protection through obfuscation. 4.60 is the first version with com implementation which allows you to use kixtart from any windows application. 4.70 is the latest version
Klaxon - Minimalist RPN language that compiles to x86-64 assembly
klisp - klisp is an implementation of the Kernel Programming Language, a Scheme-like programming language by John N. Shutt in which all objects are first-class.
Klong - Klong is an array language, like K, but without the ambiguity. If you know K or APL, you may be disappointed by Klong. If you don't know any array languages, it might explode your brain. Use at your own risk!
Koan - The design of Koan is inspired in three main programming languages: Smalltalk/Perl/Scheme; this selection of language has been an entirely personal preference but that is based on the idea of offering the best of each of these languages paradigms mixed in a clean syntax/semantic language/implementation. As a real general purpose programming language, Koan is also intended to solve real problems in real life. The idea of Koan is to focus in easy interoperability with other programs (scripting/embedded capabilities) and easy interfacing with languages like C.
kobol - KOBOL is -- we hope -- an obvious play on words for COBOL, which stands for COmmon Business Oriented Language. We therefore refer to KOBOL as KOmpany Business Oriented Language.
Kodu - Kodu is a new visual programming language made specifically for creating games. It is designed to be accessible for children and enjoyable for anyone. The programming environment runs on the Xbox, allowing rapid design iteration using only a game controller for input.
Kogut - Kogut is an experimental programming language which supports impurely functional programming and a non-traditional flavor of object-oriented programming. Its semantics is most similar to Scheme or Dylan, but the syntax looks more like ML or Ruby.
Koka - Koka: a functional language with effects. Koka is a strongly typed functional-style language with effect types and handlers.
kona - Open-source implementation of the K programming language
KonsolScript - Free and open game programming language for aspiring game programmers
KPHP - KPHP takes your PHP source code and converts it to a C++ equivalent, then compiles the generated C++ code and runs it within an embedded HTTP server. You could call KPHP a transpiler, but we call it a compiler.
Ksi Scheme - Ksi is a portable, embeddable Scheme implementation written in C.

L (72):

L - L is a high-level, open-source, general-purpose and system programming language which emphasizes readability, simplicity, extensibility, conciseness and performance. The L compiler features native code generation through LLVM, and is fully documented in a literate programming style. The language and compiler are usable, but are under heavy development as new features are being implemented.
L - L is both a language and an operating environment, like Smalltalk. It is capability-secure and distributed, like E. The language is a derivative of lambda calculus, hence it is small, block-structured, dynamically-typed, and functional. State is implicitly threaded through all function calls and returns, allowing simulation of dynamic scope and side-effects. Each thread runs in its own transaction, upon completion its state changes are committed. Any concurrent threads that conflict are aborted and re-executed at a higher priority. Each commited state change is an event. Event handlers spawn new threads (repeating the cycle).
L+ - The language our compiler takes as input, called L+, supports most constructs from C (variables, branches, loops, functions, recursion and I/O) albeit with some limitations and some additions. The L+ compiler generates Java Bytecode. L+ programs can be run on any platform with a Java VM installed.
L++ - L++ is a programming language that transcompiles to C++. It uses Lisp-like syntax.
L.B.Stanza - L.B. Stanza (or Stanza for short) is a new optionally-typed general purpose programming language from the University of California, Berkeley. Stanza was designed to help programmers tackle the complexity of architecting large programs and significantly increase the productivity of application programmers across the entire software development life cycle.
L.in.oleum - L.in.oleum is an unstructured, untyped, procedural programming language. And more specifically, it's a form of cross-platform assembly language. It is oriented to the developement of general-purpose applications, especially when 100% portability, execution speed and module compactness is requested. This language has an almost 1:1 source-to-CPU instruction ratio, allows direct access to five general-purpose registers (performing basic operations from a theoretical 2 up to a pratical of even 10 times faster than memory-held variables), and if used well, is averagely twice as fast as C in pure computational power.
Laby - Your robot ant can be programmed in many languages: OCaml, Python, C, C++, Java, Ruby, Lua, JavaScript, Pascal, Perl, Scheme, Vala, Prolog. Experienced programmers may also add their own favorite language.
Lake - The Lake programming language: C but sweeter
Lang5 - A Perl based interpreter for a language which is a blend of Forth and APL. The power of lang5 stems from its arrays operations in conjunction with the underlying Forth programming paradigm of bottom up programming.
language machine - The language machine is an efficient and usable toolkit for language and grammar. It aims to be directly and immediately useful, and it embodies a powerful model of language. This requires a paradigm shift but it comes with a diagram which explains how it works. In the documentation you will find numerous examples including the metalanguage compiler frontend and the rules that generate these pages. There is also a demonstration that the language machine can very directly represent and evaluate the lambda calculus, and an outline of its place in relation to theory.
Language Processor - I did what any real geek would do; I have written a compiler compiler. It is called Language Processor. A software that you can feed in a language definition with its semantic and you get an object that can run your program in your defined language.
Larceny - Larceny is a simple and efficient implementation of the Scheme programming language. Created originally as a test vehicle for research on garbage collection and compiler optimizations, Larceny has grown into a major multiplatform system. Larceny supports the four most important standards for Scheme: IEEE/ANSI, R5RS, R6RS, and R7RS. Development of Larceny has been supported by NSF, Sun Microsystems, and Microsoft.
Lark - Lark is an experiment in designing a homoiconic language with a syntax inspired by SmallTalk. It's very early, so there isn't much to see yet, but you can play with it.
LASIC - LASIC is a language that facilitates creating and managing systems in a cloud environment. It allows you to create scripts that describe a system, its components, and the relationship between those components using a declarative syntax. Various verbs can then be applied to the script such as deploy (create a new system), shutdown, or runAction(run some action on components of the system). LASIC currently supports Amazon's cloud environment (AWS). LASIC stands for Language for Automating Systems in the Cloud.
Latte - Latte, the Language for Transforming Text, is a simple and powerful language for including markup in text documents. Documents written in Latte can be converted to high-quality HTML, making it a better language for writing World Wide Web documents.
Lava - an experimental object-oriented rapid application development (RAD) language with type parameters ("virtual types"), refactoring, and extensive static checks, that prevent inadvertent access to uninitialized variables and null objects already at programming time. The Lava programming environment LavaPE replaces text editors completely by structure editors. It provides an inheritance notion not only for single classes, but also for packages (= collections of related classes, which may have type parameters, too).
LC-3 - Version 3.01 of the Windows LC-3 assembler and simulator
ldetect - execute different commands based on stdin text language
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.
LeekScript - Leek Wars is a programming game in which you have to create the most powerful leek and destroy your enemies! Develop your own artificial intelligence thanks to LeekScript, an easy to learn language and become the best farmer!
Lemick - Lemick is a programming language with BASIC syntax, it's a typed and a compiled language, its source is compiled into a platform-independent virtual machine assembler that is later transformed into a platform-dependent representation by the just-in-time compiler. Lemick supports concurrent and distributed programming (multi-threading and distributed multi-threading). Rendezvous are used for message passing; replicas and ultra-weak consistency model implement distributed shared memory simulation. Extension of exception handling mechanism, including distributed version is being developed now. Lemick favors mixed procedural and object-oriented programming style.
LENS - LENS stands for "Language for Embeddable .NET Scripting".
Leo - Leo is a functional, statically-typed programming language built for writing private applications. Leo provides a high-level language that abstracts low-level cryptographic concepts and makes it easy to integrate private applications into your stack. Leo compiles to circuits making zero-knowledge proofs practical.
Leo - a HTML precompiler for static home page generation. It detects special HTML tags in your page and generates HTML code out of it
Letlang - Functional language with a powerful type system.
Lever - Lever is a loosely specified general purpose programming language, and a runtime implementation of that language. Many tradeoffs have been made to obtain high plasticity worthy of pride. To make use of this every feature is tried in practice to level out prickly details in the language before a major release.
levy - An implementation of Paul Levy's call-by-push-value language. The language has the following constructs:
integers with arithmetical operations *, +, `-``
booleans with conditional statements and comparison =, < of integers
functions
general recursion (fixpoint operator)
call-by-push-value features: return, thunk, force, sequencing, and let binding Call-by-push-value is very precise about what gets evaluated when and can express both call-by-value and call-by-name.
lfyre - lfyre is a general purpose, compiled programming language. It offers high performance, expressive power and flexibility. It has many features found in other languages, plus extra features as creating new operators, keywords and programming paradigms.
LHDL - LHDL - while not a hardware description language, may be seen as the first step in that direction. Check out the README for more information. Also see the ChangeLog. LHDL is Open Source -- released under an MIT-style license. See included LICENSE file for more information.
Lhogho - Lhogho is a free version of the programming language Logo and a promoter of its educational philosophy. It is specially designed to be performant, miniature, open-minded and ... artistic.
Libra - Libra is a basic stack-based programming language simulated through Haskell. Heavily inspired by Porth and Forth
Libra - Libra - Lazy Interpreter of Binary Relational Algebra
Libretto - a dynamic general purpose object-oriented programming language
LIL - LIL (stands for Little Interpreted Language) is a small highly dynamic scripting language inspired by Tcl and unix shells. LIL has two implementations, one written in C, which consists of a pair of .c and .h files and one in Free Pascal, which consists of a single pas file (a unit). Also a Lazarus package for the latter is provided.
Lily - Lily is statically-typed, with an interpreter as a reference. Lily uses reference counting for memory management with garbage collection as a fallback.
LinearML - Functional language for parallel programming
Lingo - Lingo makes it easy to learn to program for Windows. If you're new to programming, you can download Lingo and write your first program very easily. And experienced programmers benefit because Lingo is quick to install and simple to use! Lingo includes a Developer Environment for designing forms, managing projects and debugging.
Links - Links is a functional programming language designed to make web programming easier.
lisaac - motivation: focused on expressiveness through simplicity; programming for operating systems; speed execution; no virtual machine; software engineering pure: minimal syntax; all values are objects; prototype-based object model; everything is a message dynamic: all messages are dynamic; code is a runtime modifiable tree; delayed evaluation block; differential inheritance; dynamic and multiple inheritance security: strong type; design by contract; genericity accessible: small; embeddable; open source inspiration: self; smallTalk; Eiffel; C (for hardware support)
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.
LITTLE - LITTLE is a new programming language, looking like LISP, but pure Object-Oriented.
Little - Little is a statically-typed scripting language that combines C syntax and types with Perl's regexes and associative arrays, and dynamically compiles the whole lot to Tcl byte-codes. All Tcl/Tk facilities are available to Little, and source files can interleave Little and Tcl code that call each other.
Little - Little is a statically typed, C-like scripting language.
Little Man Computer - The Little Man Computer (LMC) is a simplified example of computer hardware and software which can be used to explain the fundamental principles of computer engineering. The LMC contains all of the components of modern computers: Memory, a Central Processing Unit (CPU), and input/output capability. A small but powerful programming language is used which allows the programmer to define a computation or operation for the Little Man to perform. By writing and executing simple programs, the student is able to understand the function of each component of the hardware. Writing, debugging and executing LMC programs is supported by a color menu-driven software package written in the C programming language for the DOS environment. This paper describes the organization of the LMC, the machine language of the LMC, the LMC assembly language, the LMC Assembler, and the menu-driven user interface for the LMC.
Lizard - Lizard is a domain-specific language to define and control hardware behaviour. It is intended to run on embedded systems which are connected to motor controllers, sensors etc. Most of the time it is used in combination with a higher level engine like ROS or RoSys. You can think of the microcontroller as the machine's lizard brain which ensures basic safety and performs all time-critical actions.
LMQL - LMQL is a programming language for large language models (LLMs) based on a superset of Python. LMQL offers a novel way of interweaving traditional programming with the ability to call LLMs in your code. It goes beyond traditional templating languages by integrating LLM interaction natively at the level of your program code.
lnzscript - LnzScript lets you automate Windows with JavaScript.
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.
Loci - Loci is a multi-paradigm systems programming language. Or, to describe it in a slightly more intuitive way, it’s very similar to, and a close competitor of, C++.
Logix - Logix is more than a programming language. It is multi-language programming system. With Logix, each part of your program can be developed in a language that is finely tuned to the task. Featuring a procedural macro facility, dynamic syntax extension, and multi-language parsing. A new operator, complete with syntax and semantics, can be added on-the-fly with a single line of code.
Logtalk - Logtalk is a declarative object-oriented logic programming language that extends and leverages the Prolog language with modern code encapsulation and code reuse mechanisms while also providing improved predicate semantics.
Implemented as a trans-compiler in highly portable, extensively tested, and well documented code, it can use most modern and standards compliant Prolog implementations as a backend compiler.
As a multi-paradigm language, it includes support for modules, prototypes, classes, protocols (interfaces), categories (components and hot patching), event-driven programming, and high-level multi-threading programming. Distributed under a commercial friendly license, it includes full documentation, portable libraries, portable developer tools, and a large number of programming examples to help get you started.
Loko - Loko is an interactive interpreter for the Logo programming language targeting MakoVM, an extremely simple stack-based virtual machine intended for the creation of video games. Logo is best known for beginner-oriented "Turtle Graphics" functionality, but internally the language is actually a dynamically-scoped member of the Lisp family. As such, Logo provides sophisticated list manipulation facilities and support for higher-order functions.
Lola-2 - A Logic Description Language
LOLCODE - This is a love letter to very clever people who are slightly bored. I had no idea there were so many of us out there. (from the FAQ)
Looking Glass - Looking Glass is a programming environment for ages 10 and up. With Looking Glass, you can create and share animated stories, simple games, and even virtual pets.
Loop - Our vision of Loop is to provide new infrastructure specialists with a “one-stop shop” for most of the software-defined infrastructure tools that are used in home environments, and cloud services. Think of Load balancers, Infrastructure as Code, monitoring, and containerization. These tools exist individually; However, having one language that handles different aspects of virtual infra all while having your application besides it is new. We like to call it infrastructure with code.
Lox - jlox & clox implementations of educational Lox language from great book "Crafting Interpreters".
LSCRIPT - The Lcomp Scripting Engine is a scripting engine written in Visual BASIC for DOS 1.0 that can be used by a programmer to write automatated scripts to perform routine actions in DOS. It can be used as a simple automation tool or a vast programming language
LSTS - LSTS is a proof assistant and maybe a programming language. Proofs in LSTS are built by connecting terms, type definitions, and quantified statements. Terms can be evaluated to obtain Values. Types describe properties of Terms. Statements describe relations between Terms and Types.
Lua - Lua is a powerful, efficient, lightweight, embeddable scripting language. It supports procedural programming, object-oriented programming, functional programming, data-driven programming, and data description. Lua combines simple procedural syntax with powerful data description constructs based on associative arrays and extensible semantics. Lua is dynamically typed, runs by interpreting bytecode with a register-based virtual machine, and has automatic memory management with incremental garbage collection, making it ideal for configuration, scripting, and rapid prototyping.
Luau - A fast, small, safe, gradually typed embeddable scripting language derived from Lua.
Luban - Luban is a component oriented scripting language. Luban is free and open source. Luban is named after a legendary ancient Chinese civil engineer and carpenter two thousand year ago whose constructions are still in use today.
Lucid - Lucid is a non-imperative dataflow language, designed over 20 years ago by William W. Wadge and Edward A. Ashcroft. The idea is that nearly all programming languages are based in the idea of �flow of control�. What do we get when we try to orient around �flow of data� instead? One immediate reaction would be, �well, I bet it is like programming with pipes and filters in UNIX", and sure enough it is, but Lucid goes a little beyond that.
Lucid Synchrone - Lucid Synchrone is an experimental language for the implementation of reactive systems. It is based on the synchronous model of time as provided by Lustre combined with some features from ML languages.
lucy-n - a n-Synchronous Extension of Lustre
Lush - Lush is an object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications. Lush is designed to be used in situations where one would want to combine the flexibility of a high-level, weakly-typed interpreted language, with the efficiency of a strongly-typed, natively-compiled language, and with the easy integration of code written in C, C++, or other languages. Lush is Free Software (under the GPL license) and runs on GNU/Linux, Solaris, Irix, and Windows under Cygwin. Lush can be used advantageously for projects where one would otherwise use a combination of an interpreted language like Matlab, Python, Perl, S+, or even (gasp!) BASIC, and a compiled language like C. Lush brings the best of both worlds by wrapping three languages into one: (1) a weakly-typed, garbage-collected, dynamically scoped, interpreted language with a simple Lisp-like syntax, (2) a strongly-typed, lexically-scoped compiled language that uses the same Lisp-like syntax, and (3) the C language, which can be freely mixed with Lush code within a single program, even within a single function. It sounds complicated, but it is not. In fact, Lush is designed to be very simple to learn and easy to use.
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.
LX - LX is a general purpose compiled programming language, like C, C++, Pascal, Ada or Eiffel. Although LX borrowed a lot from these respected ancestors and many others, trying to incrementally improve over each of them, LX still differs from all these other languages
Lygon - Lygon is a logic programming language that is based on linear logic. It can be viewed as Prolog extended with features derived from linear logic. These features include a declarative notion of state and the ability to express problems involving concurrency. Also, the availability of use once predicates allows simple solutions to problems such as graph manipulation. Although the design of Lygon relies on a delicate proof-theoretic analysis of linear logic, programmers need have no knowledge of proof theory.
LyteScript - An interpreted, stack-based programming language with object-oriented features.

M (83):

m80 - A build-tool independant framework for linking builds for a complete one touch system deployment in multiple environments. Includes a centralized metadata repository, code-generator framework, scripting language, re-usable macro libraries, and more.
Macro Lambda Calculus - lambda calculus using interaction nets, providing CLI and API. Its browserified version is available as an online demo.
MAD - Music as Data (MAD) is a live programming language/environment based on Processing.org written in Clojure. MAD lets you treat music as data and apply data transformation on the fly so you can experiment with notes and samples.
Magda - Magda is based upon the core notion of mixin as the only unit of reuse. The power of modularization of mixins is enhanced by two unique features. The first feature is the modularization of constructors. In Magda, many mixins with independent definitions of constructors can be combined without the need to copy any code and without the risk of clashes. The second distinctive feature modifies the way declarations of new methods, overriding methods, and method calls are done, in order to rule out accidental name clashes, even with respect to future modifications of the code.
Magmide - A dependently-typed language intended to make provably correct code possible for working software engineers.
Magnet - Magnet is an object-oriented programming language, that is prototype-based to the point of real types being absent in favor of duck types. E.g. every object providing a read method that returns a readable, is considered "readable" (meaning it can represent a string). Since this causes a recursion, there must be some "primal" readable to end that: Such primal readable is also known as a String Object in Magnet. Furthermore, Magnet is syntax driven. This means: Everything that can be done to reduce code, retain simplicity and to amaze the developer, IS done!
Magpie - Magpie is a small dynamically-typed programming language built around patterns, classes, and multimethods. It has a prototype interpreter that runs on the JVM and an in-progress bytecode VM written in C++.
Maker - Maker, a Forth-inspired compiled language targeting Mako. Mako is an extremely simple stack-based virtual machine intended for the creation of video games.
MakoForth - MakoForth is a small Forth dialect targeting MakoVM, an extremely simple stack-based virtual machine intended for the creation of video games. MakoForth should be moderately familiar to anyone who has been exposed to ANS-Forth. The major notable differences are the use of # as line comments, loop...(break)...again|until|while looping constructs and the inclusion of syntax for inline double-quoted string constants. Cells are always 32-bit two's complement signed integers.
Mango - Mango draws on the following langauges: SETL - set operations; ALGOL - imperative block structure and syntax; C - low level ops, low overhead, maps well to machine, syntax; ML - type inference, type syntax; ADA - type inference, fine grained control over primitives; PYTHON - indentation based syntax; JAVA - interfaces; C++ - set of standard collections (STL), operator; overloading, io syntax; CLU - iterators; PASCAL - sets (bit masks); PERL - richness of expressibility; COBOL - readable syntax
MANOOL - MANOOL is a programming language designed with an idea to maximize the expressive power / implementation complexity ratio.
Manticore - Manticore is a high-level parallel programming language aimed at general-purpose applications running on multi-core processors. Manticore supports parallelism at multiple levels: explicit concurrency and coarse-grain parallelism via CML-style constructs and fine-grain parallelism via various light-weight notations, such as parallel tuple expressions and NESL/Nepal-style parallel array comprehensions.
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.
Mars - Mars is a very simple imperative programming language with a catch: all of the functions and expressions are pure. That means when you call a function, it is guaranteed to have no side-effects: it can't mutate its arguments, modify global variables, or perform input/output. But unlike other pure languages, Mars gives you all the nice features of imperative programming, like local variable assignments and loops. The compiler also automatically converts inefficient copy-and-update operations into in-place destructive operations. Mars also has some other nice features borrowed from functional programming: a strong static type system, algebraic data types, pattern-matching switch statements, and higher-order functions. Mars is an experiment, not a full-featured programming language. You can use it for playing with the boundaries between imperative and declarative programming, but we don't recommend you write real software with it.
Marten - Draw software code, execute while editing, and build MacOS X applications with a single click of a button with the Marten™ software development environment for the Prograph visual programming language. Marten lets you create software graphically, connecting icons to icons rather than writing text. Gone are syntax errors, compile/link/debug steps, unexplained build failures, and autorelease pools. What's left is what software development should be... fun!
Mash - Untyped, lightweight, crossplatform OOP language.
MASICA - An educational interactive TinyBASIC interpreter targeting MakoVM, an extremely simple stack-based virtual machine intended for the creation of video games. MASICA is designed to provide an absolute minimum of features and complexity while including what is necessary to illustrate core imperative programming concepts such as variables, iteration and conditional branches. Variable names are single letters. The MASICA interface is similar to that of early 8-bit microcomputers- a prompt which can evaluate commands immediately or store a sequence of commands prefixed with line numbers. Several commands for removing or editing existing lines are also provided.
Matita - Matita (that means pencil in italian) is an experimental, interactive theorem prover under development at the Computer Science Department of the University of Bologna.
Maude - Maude is a high-performance reflective language and system supporting both equational and rewriting logic specification and programming for a wide range of applications. Maude has been influenced in important ways by the OBJ3 language, which can be regarded as an equational logic sublanguage. Besides supporting equational specification and programming, Maude also supports rewriting logic computation.
Mavscript - Mavscript allows the user to do calculations in a text document. Plain text, LaTeX and OpenOffice Writer files (.odt) are supported. The calculation is done by the algebra system Yacas (default), Jasymca or by the Java interpreter BeanShell.
mawk - mawk is an interpreter for the AWK Programming 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.
MCPL - MCPL is a simple typeless language which is based on BCPL. It makes extensive use of pattern matching somewhat related to that used in ML and Prolog, and some other features come from C.
Mecca - Mecca is a different way of programming batch. We make it a little but more real by using code that looks nothing like batch, but it is! Requires .NET 4 and above! A good knowledge of batch would help too.
Mecrisp - Welcome to the Mecrisp family of native code optimising Forth compilers for MSP430, ARM, RISC-V, MIPS, and stack machines on FPGAs.
Melody - Melody is a language that compiles to regular expressions and aims to be more easily readable and maintainable.
Mercat - Mercat is not really useful for anything much. It is, on the other hand, an excellent example of how to implement a self-hosted recursive-descent-parsed language and virtual machine
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.
Merlin - Merlin is a new network management framework that allows administrators to express policies in a high-level, declarative language based on regular expressions. The compiler automatically partitions those policies into components that can be placed on a variety of devices including switches, middleboxes, and end hosts. The compiler uses a constraint-solver to determine the optimal placement strategy using paramaterizable heuristics. Sub-policies may be further constrained by network tenants, facilitating management of federated networks. Merlin provides techniques for verifying that both the partitioned program components and the delegated sub-policies conform to the global network policy. Overall, Merlin simplifies the task of network administration by providing high-level abstractions for specifying network policies and scalable infrastructure for enforcing them.
Meta - Meta is a simple programming language. Meta is an attempt to create the conceptually simplest programming language that is still practical to use.
MetaCall - MetaCall is an extensible, embeddable, and interoperable cross-platform polyglot runtime. It supports NodeJS, Vanilla JavaScript, TypeScript, Python, Ruby, C#, Java, WASM, Go, C, C++, Rust, D, Cobol and more.
Metacza - Metacza compiles a functional language to C++ Template Meta Language. It can be used to ease Template Meta Programming in C++.
METAL - METAL is a 100% free extended BASIC language metacompiler for PowerMac.
MetaL - MetaL is shorthand for Meta-programming Language. Meta-programming is a method to develop computer programs. It works by generating source code in a target language from a program specification in a higher level language. MetaL programs source code is based on XML. MetaL compiler engine can be used to generate the same program from MetaL source code to potentially any target language. Currently supported target languages are PHP, Java and Perl. The support for other languages can be added any time.
MetaLang 99 - A functional language for C99 preprocessor metaprogramming.
Mica - Mica is: An interpreter for a garbage collected, dynamically typed, object-oriented language with prototype-based inheritance, multiple dispatch, strict encapsulation and capabilities for security, optional orthogonal persistence, and functional programming features (anonymous functions, functional lists and dictionaries, map and filter operators).
midori - Programming language based off pure type systems, and COQ. Currently aimed at both systems, and application programming. Has a simple syntax, and (planned) C integration.
MillScript - MillScript is a full featured, yet easy to use language for the batch production of templated Web sites. The language is a Java-based, early implementation of Spice: an experimental language developed by the OpenSpice group.
Min - A small but practical concatenative programming language and shell.
MiniLang - A type-safe C successor that compiles directly to various platforms. [C-killer]
MiniScript - MiniScript is modern, elegant, easy to learn, and easy to embed in your own C#, C++ or Kotlin projects.
MiniZinc - MiniZinc is a high-level constraint modelling language that allows you to easily express and solve discrete optimisation problems.
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.
Mint - A refreshing programming language for the front-end web, aiming to solve the most common issues of Single Page Applications (SPAs) at a language level:
- Reusable components
- Styling
- Routing
- Global and local state handling
- Synchronous and asynchronous computations that might fail
Mirah - Mirah is a customizable programming language featuring static types, local type inference and a heavily Ruby-inspired syntax. Mirah currently includes a typer/compiler backend for the JVM which can output JVM bytecode.
Mirelle - Mirelle is a programming \ scripting language for .NET platform, designed for simple prototyping and simulation modelling. It features lightweight syntax and extensibility via .NET assemblies.
Mirth - Mirth is a new strongly-typed concatenative programming language. Mirth is inspired by Forth, Joy, Haskell, Lisp, and monoidal category theory.
Misc - Misc is a programming language designed especially for performing calculations on large amounts of data. The Misc Engine library is a portable C++ library containing Misc compiler, interpreter and standard built-in functions. The main purpose of Misc is to serve as a base engine for other applications. For example, one could create a GUI front-end for drawing graphs using the data generated by a script written in the Misc language. The functionality of the Misc Engine by itself is limited to calculations, data manipulations and simple I/O operations. However its ability to be extended with additional functions makes it a powerful tool.
MIX/MIXAL - MIX is Donald Knuth's mythical computer as described in his monumental work The Art Of Computer Programming. As any of its real counterparts, the MIX features registers, memory cells, an overflow toggle, comparison flags, input-output devices, and a set of binary instructions executable by its virtual CPU. You can program the MIX using an assembly language called MIXAL, the MIX Assembly Language.
ML/I - ML/I is a general purpose macro processor.
MLF - We propose a type system MLF that generalizes ML with first-class polymorphism as in System F. Expressions may contain second- order type annotations. Every typable expression admits a principal type, which however depends on type annotations. Principal types capture all other types that can be obtained by implicit type instan- tiation and they can be inferred. All expressions of ML are well- typed without any annotations. All expressions of System F can be mechanically encoded into MLF by dropping all type abstractions and type applications, and injecting types of lambda-abstractions into MLF types. Moreover, only parameters of lambda-abstractions that are used polymorphically need to remain annotated.
mLite - a lightweight (and slightly odd) inhabitant of the ML universe. Much like ML, but with dynamic typing, guards, and a Haskell-style apply operator.
MMBASIC - MMBasic is a free and open BASIC interpreter for 32 bit microcontrollers. It includes floating point numbers, extensive string handling, multi dimensional arrays and structured programming features like do loops, multiline if statements, user defined subroutines and functions. MMBasic is generally backwards compatible with Microsoft's MBASIC and implements much of the ANSI Standard for Full BASIC (X3.113-1987).
Mn - A truly minimal concatenative programming language.
Mobile BASIC - BASIC for Android phones, tablets and J2ME phones
Mocha - Mocha is a new programming language that was developed for applications distributed on a small scale. You can make simple applications. Features include: if statements, nested functions, forms, and over 100 functions. To run Mocha you'll need the Visual Basic 6.0 runtime file (msvbvm60.dll), the Microsoft Common Dialog Control, and the Windows Common Controls. For the actual Mocha applications though, you only need msvbvm60.dll.
Modula-2 (GNU) - 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.
Modula-P - Modula-P is a structured programming language for asynchronous parallel programming (MIMD systems), developed by Thomas Bräunl in 1986. The language is based on sequential Modula-2, but extended by machine-independent parallel constructs. Modula-P allows explicit declaration and starting of processes. The language includes the classical synchronization concepts of semaphores, monitors with conditions, and remote procedure calls.
Mojo - Mojo is a new programming language that bridges the gap between research and production by combining Python syntax and ecosystem with systems programming and metaprogramming features. Mojo is still young, but it is designed to become a superset of Python over time.
Mond - A scripting language for .NET Core. You can try it in a browser here.
Monkey - Monkey is a programming language designed by Thorsten Ball.
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.
Monte - Monte is a programming language inspired by the E and Python programming languages. Monte aims to be:

A reliable scaffold for secure distributed computing
An example of capability-safe programming language design
A model for misuse-resistant programming

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.
Mops - A full featured, stand-alone development environment for programming the Macintosh written by Mike Hore. Inspired by Smalltalk and the commercial language Neon, Mops is based on Forth with extended object-oriented features such as multiple inheritance, early and late binding, persistent objects, and garbage collection.
morph - A mostly pure functional programming language
Mosel - Mosel is an environment for modeling and solving problems. To this aim, it provides a language that is both a modeling and a programming language. The originality of the Mosel language is that there is no separation between a modeling statement (e.g. declaring a decision variable or expressing a constraint) and a procedure that actually solves the problem (e.g. call to an optimizing command). Thanks to this synergy, one can program a complex solution algorithm by combining modeling and solving statements.
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.
Move - Move is a programming language based on Rust that was created by Facebook for developing customizable transaction logic and smart contracts for the Libra digital currency. Every transaction submitted to the Libra blockchain uses a transaction script written in Move to encode its logic.
Move - A simple, functional-biased, prototypal and powerful programming language that runs on any ES3 (or better) JavaScript platform, aimed toward people new to programming
Mozart - The Mozart Programming System combines ongoing research in programming language design and implementation, constraint logic programming, distributed computing, and human-computer interfaces. Mozart implements the Oz language and provides both expressive power and advanced functionality.
MPSL - MPSL (Minimum Profit Scripting Language) is a programming language concieved as an scripting engine for software/mp [Minimum ProfitText Editor], though it can also be used as a general-purpose programming tool. An MPSL program consists of a sequence of statements which run from top to bottom. Loops, subroutines and other control structures allow you to jump around within the code. It is a free-form language, meaning that you can format and indent it however you like, as whitespace serves to separate tokens.
Muesli - Muesli: Multiple Utility, Evaluation and Scripting Language Interface: Muesli is a library to interface an application to multiple programming language evaluators (normally, interpreters). Muesli allows your program to call any one (or more) of a number of programming language interpreters through a consistent interface, such that you can choose the language(s) to use at run-time. It can be used anywhere where you want to use a scripting language but don't want to be restricted to any particular scripting language.
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.
muon - Muon is a modern low-level programming language, inspired by C, C#, Go, Rust and Python.
mybb - My Business Basic (MyBB)
Myia - Myia is a new differentiable programming language. It aims to support large scale high performance computations (e.g. linear algebra) and their gradients. The main application Myia aims to support is research in artificial intelligence, in particular deep learning algorithms.
Myrddin - Myrddin is a programming language. It aims for control and simplicity. It features strong type checking, generics, type inference, closures, and traits. It aims to fit into a similar niche as C, but with fewer bullets in your feet. Myrddin does not aim to explore the forefront of type theory or compiler technology. It does not focus on guaranteeing perfect safety. It is satisfied to be a practical, small language.
μC++ - The μC++ project extends C++ with new constructs providing advanced control-flow including light-weight concurrency on shared-memory uni- and multi-processor computers running UNIX and Linux operating systems. μC++ accomplishes this by providing new kinds of classes: coroutines, which have independent execution states; tasks, which have their own threads; and monitors, which allow for safe communication among tasks. These new classes can take part in inheritance, overloading, and templates, just like other classes. As well, C++ exception handling is extended, allowing exceptions to propagate among coroutines and tasks. Additional capabilities include: clustering of tasks and processors, object-oriented non-blocking I/O for files and sockets, and support for real-time programming. True parallelism is achieved utilizing operating-system kernel-threads. μC++ clarifies and extends object-oriented concurrency providing generality and functionality that surpasses languages like Ada, Java, and C#.

N (26):

Nasal - Nasal: Not another scripting language!
- Vectors, Hashes and Scalars (number/strings)
- "Normal" OOP syntax
- Small! 146k source code. Easily embeddable and extensible
- Functional programming
- Garbage collected
- Threadsafe
Nature - Nature is the modern systems programming language and compiler, striving for elegant and concise syntax while prioritizing the writing and reading experience for developers. Key features of nature at the language level include:
- Type system, null safety, generics, union types
- In-house compiler/assembler/linker, not reliant on llvm. Supports compilation for amd64/riscv64/wasm architectures
- Non-intrusive interaction with C for efficient and high-performance development
- Progressive GC, supports both automatic and manual GC
- Built-in vec/map/set/tup data structures
- Package and module management
- Function tags/closures/error prompts/runtime stack traces/coroutines
- Integrated SSA/linear scan register allocation/reflection/assembler & linker
Neko - Neko is a high-level dynamically typed programming language. It can be used as an embedded scripting language. It has been designed to provide a common runtime for several different languages. Learning and using Neko is very easy. You can easily extend the language with C libraries. You can also write generators from your own language to Neko and then use the Neko Runtime to compile, run, and access existing libraries.
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.
Neon - to find out whether a useful programming language can avoid some of the common pitfalls that beginners frequently encounter in other languages. Some of these common errors avoided by design are:

Floating point errors due to binary floating point
Writing if (x = 0) when if (x == 0) is intended
Null pointer exceptions
Unintended empty loop with while (condition);
Forgetting to use the return value of a function

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).
newRPL - newRPL is a re-implementation of the HP48/49/50 series calculators programming environment. The RPL scripting language is being redesigned and recreated with even more powerful features.
Nice - Nice is a new programming language. It extends the ideas behind object-orientation in order to better support modular programming and static type safety. It also incorporates features from functional programming, and puts into practice state-of-the-art results from academic research. This results in more expressivity, modularity and safety.
Nickle - Nickle is a programming language based prototyping environment with powerful programming and scripting capabilities. Nickle supports a variety of datatypes, especially arbitrary precision numbers. The programming language vaguely resembles C. Some things in C which do not translate easily are different, some design choices have been made differently, and a very few features are simply missing. Nickle provides the functionality of UNIX bc, dc and expr in much-improved form. It is also an ideal environment for prototyping complex algorithms. Nickle's scripting capabilities make it a nice replacement for spreadsheets in some applications, and its numeric features nicely complement the limited numeric functionality of text-oriented languages such as AWK and PERL.
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).
Nimskull - An in development statically typed systems programming language; with sustainability at its core. We, the community of users, maintain it.
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.
Nosica - Nosica is an Object-Oriented language, with a syntax similar to Java or C++, and with advanced high level features such as a strong type system, automatic memory management, and global code optimisation. Nosica is developped in Java(gcj) and is GPLed. The compiler is not very usable yet even if you can write non trivial programs. For example, the Nosica standard library already contains generic containers like Vector, or Map. The compiler translates Nosica source code into C and calls gcc to compiles the result in an executable.
notc - This is a simple interpreter with c-like syntax.
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.
nScript - It is a simple script similar to C language. You can easily create small batch processes. The script has the following characteristics:
- Runs on console (WindowsCE version runs on pseudo console)
- C-like syntax
- file, socket
- array, associative array
- Regular expression
- Function execution by argument matching
NScript - NScript is a tool similar to WScript except that it allows scripts to be written in .NET languages such as C#, VB.NET and JScript.NET. NScript automatically compiles the code into an assembly in memory and executes the assembly. The NScript setup application associates NScript with ".ncs" (for C# scripts), ".nvb" (for VB.NET scripts) and ".njs" (for JScript .NET scripts) file extensions. This enables any code written in these files to be executed directly by double clicking on these files in windows explorer. I wrote this tool when I needed to write a script for automating builds. A simple batch file was not sufficient for the task and I preferred to write code in C# as opposed to VBScript or JScript. This tool came in handy as I could modify the scripts easily and execute them by double clicking on the files in windows explorer.
NullC - Fast C-like programming language with advanced features.

O (23):

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 Lua - Objective Lua is an almost pure superset of Lua that welds the Objective C object orientation system and syntax on top of the classic Lua language. It is written entirely in Lua and works by translating Objective Lua code into Lua code as it is loaded. This means that it's incredibly portable and incredibly fast.
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.
ObjectScript - ObjectScript is a general purpose object-oriented programming language. It is designed to be simple to learn, easy to use, yet still powerful, combining the convenience of an interactive interpreter with many of the features of Java:
- a simple java-like syntax
- class system, with single inheritance and mixins
- private/protected/public fields and methods
- exceptions for error handling
- synchronization and threading
- compiles to bytecode for higher performance
- osdoc: a javadoc-like tool to extract API documents
- from src code, plus API docs accessible reflectively
- XML-RPC support
- Windows COM support
- regular expressions (requires java v1.4 or later)
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.
Ode - Ode is a stack-based, concatenative, functional programming language ..., with an interactive online development environment written in JavaScript. Ode is inspired primarily by the Joy programming language, which Ode aims to implement fully. You might even think of this language as an 'Ode to Joy'...
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]
Onyx - A data-oriented, expressive, and modern programming language
OpenComal - OpenComal is a portable and free implementation of the Comal programming language written by moi. Currently supported platforms are Unix, MsDos and Win32 (95, 98, NT, 2000, XP and whatever they come up with next :-) Comal is a crossover between Basic and Pascal, with the best features of both and none of the drawbacks of either.
OpenXION - XION is an xTalk language similar to the ones used by HyperCard, SuperCard, and Runtime Revolution. OpenXION (OH-pen-EK-shun) is the reference implementation of the XION scripting language, an open standard.
OpenZz - OpenZz is an interpreted dynamic parser which is well suited to rapid development of parsing solutions, starting from rapid language prototyping to full fledged compilers. OpenZz is a dynamic LALR(1) parser which allows its grammar to be modified and extended by commands written in its own language as well as through functionality provided by external libraries. OpenZz is implemented as a C library and exports C-bindings, so it can be joined with other code libraries both by static linking and runtime module loading. OpenZz is being developed by the INFN for use in the compilation chain of the APE("ah-pei") series of highly parallel processing computers. APE systems are developed for performing LQCD physics research.
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.
Ox - Ox is an object-oriented statistical system. At its core is a powerful matrix language, which is complemented by a comprehensive statistical library. Among the special features of Ox are its speed, well-designed syntax and editor, and graphical facilities. Ox can read and write many data formats, including spreadsheets and OxMetrics files; Ox can run most econometric Gausstm programs. Ox comes in two versions: Ox Professional and Ox Console. Ox is available for Windows, Linux, Mac (macOS), and several Unix platforms.
Ox - A platform for writing OpenFlow controllers
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 (50):

P - A state machine based programming language for formally modeling and specifying complex distributed systems.
PAIP - PAIP (pipe) is a universal filter application. It uses plugins to transmit and convert data. They can be nested, so the inner structures can become quite complex (non-linear). The command-line interface is similar to a programming language and very easy.
Parable - Parable is a small language, built over a compact byte coded virtual machine. The language uses a concatenative model with a strictly reverse polish notation, type awareness, and garbage collection. The syntax draws from earlier work on Toka and Retro, making extensive use of anonymous, nestable functions (called quotations) for function definition and control structures. The language also depends heavily on prefixes to help the compiler decide how to handle tokens. (These are a lot like colors in ColorForth, but are represented as single characters rather than color or stylistic elements).
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.
PaxScript - paxScript is an interpreter of 4 object-oriented scripting languages: paxBasic, paxC, paxPascal and paxJavaScript
- All pax-languages support such concepts of the modern programming as namespaces, nested classes, inheritance, static(shared) members, indexed properties, default parameters, overloaded routines, operator overloading, delegates, exception handling, regular expressions, conditional compilation. If you know VB.NET, C# or Object Pascal, you are already familiar with paxScript. (more...)
- Cross-language integration. For example, you can use modules written in paxBasic and paxC in your paxPascal scripts and vice versa.
- Separate compilation of the modules.
- Direct calling dll-defined routines. All calling conventions register, pascal, cdecl, stdcall, safecall are supported. (See demo.)
- Embedding scripts into html pages.
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.
Peregrine - You can consider it to be a dialect of python which compiles to clean C++. It will have no garbage collector because it is a system programming language.You can consider it to be a dialect of python which compiles to clean C++. It will have no garbage collector because it is a system programming language.
Peridot - An experimental language for exploring the applications of two level type theory to high-performance functional programming
Peter - Gemtree Peter is a visual programming tool designed for a simple and fast generation of the programs for Windows 95/98/NT/ME/2000/XP/Vista. Its principal characteristic is the graphical presentation of the program structure. The program sections are assembled using the mouse like a jigsaw puzzle. Thanks to the justification check of the element combinations, carried out already at the time of the program generation, there is no chance of syntactic failure origination. The program presentation by means of a tree structure enables a considerable improvement of the program lucidity. The creation of the program is quickly becoming extraordinary easy and flexible.
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.
Piccola - Piccola is a small, pure language for building applications from software components. Piccola is small in the sense that its syntax is tiny, and it is pure in the sense that it provides only compositional features — computation is performed entirely by components of the host programming language. The semantics of Piccola is defined in terms of a process calculus, an extension of Milner's pi calculus in which values communicated are forms, rather than tuples. A "form" is essentially an extensible nested record which also serves as a namespace in which expressions may be evaluated. This simple mechanism is responsible for much of the expressive power of Piccola.
Pico - Pico is a tiny but expressive programming language that was especially designed to teach advance computer science concepts to students in other sciences than computer science (such as Physics and Chemistry). In a sense, Pico can be seen as a non-trivial marriage between the power of languages like Scheme, and, the standard infix notation students are used to from ordinary calculus. A.o., Pico features garbage collected tables (i.e. arrays), higher order functions, objects, meta programming and reflection. But above all, Pico is small! Really small!
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.
Pict - Pict, a concurrent programming language based on the pi-calculus. Pict is a language in the ML tradition, formed by adding a layer of convenient syntactic sugar and a static type system to a tiny core. The current release includes a Pict-to-C compiler, reference manual, language tutorial, numerous libraries, and example programs. The core language - an asynchronous variant of Milner, Parrow, and Walker's pi-calculus - has been used as a theoretical foundation for a broad class of concurrent computations. The goal in Pict is to identify high-level idioms that arise naturally when these primitives are used to build working programs - idioms such as basic data structures, protocols for returning results, higher-order programming, selective communication, and concurrent objects. The type system integrates a number of features found in recent work on theoretical foundations for typed object-oriented languages: higher-order polymorphism, simple recursive types, subtyping, and a powerful partial type inference algorithm.
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.
PILL - PILL is a scripting language for applications. The syntax (based on functional languages) might look weird but it have some advantages. It contains only a minimal set of functions, applications will have to register new ones via the interpreter's API in order to make it to replay the scripts as wanted. This abstraction offers a flexible way to expand scripts abilities to virtually any domain and to allow various applications to share/re-use foreign scripts.
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.
Pinecone - Pinecone is a brand new, easy to learn, general purpose, multi-paradigm, high performance programming language created by Sophie Winter. Work on the language began on October 4th, 2016. Pinecone can now be interpreted or transpiled to C++. The language is written from scratch (it includes an integrated lexer, parser and interpreter, etc.).
Pipa - Programming as fun as flying kite
Pizza - The Pizza language is an extension to Java with three new features:
- Generics (aka Parametric polymorphism)
- Function pointers (aka First-class functions)
- Class cases and pattern matching (aka Algebraic types) Furthermore you can use the Pizza compiler embedded into other applications.
Plato - Plato is an efficient and (hopefully!) fun programming language inspired by JavaScript, TypeScript, C#, and Haskell. Plato is designed to be easy to teach and learn while being efficient and robust enough for professional coding, particularly in the realm of 3D graphics. Plato is a statically typed functional language that looks and behaves in many ways like an object-oriented scripting language, but with a lot less complexity.
PLC - PLC is a simple, powerful way to add custom scripting to any program. A basic C parser and interpreter is included, and new scripting languages can be designed easily.
Plutus - Plutus Core is the scripting language embedded in the Cardano ledger and forms the basis of the Plutus Platform, an application development platform for developing distributed applications using the Cardano blockchain.
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.
Polyglot - Polyglot is a highly extensible compiler front end for the Java programming language. It is implemented as a Java class framework using design patterns to promote extensibility. Using Polyglot, language extensions can be implemented without duplicating code from the framework itself. Polyglot has been used to implement domain-specific languages, to explore language design ideas, to simplify Java for pedagogical purposes, and for various code transformations such as optimization and fault injection.
Polylang - TypeScript-like language that compiles to zero knowledge computation.
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.
Power Fx - Microsoft Power Fx is a low-code general purpose programming language based on spreadsheet-like formulas. It is a strongly typed, declarative, and functional language, with imperative logic and state management available as needed.
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.
PowerMops - A full featured, stand-alone development environment for programming the Macintosh written by Mike Hore.
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.
Prolog -
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
Prowl - The Prowl Language is a statically-typed stack-based programming language that draws from a wide range of inspirations, mainly functional, logic, and stack-based languages. However, the language is unique with its powerful program combinator system. Prowl exploits a homomorphism between string concatenation and concatenative languages that allows regex to be used as a computational and mental model for control flow. This model provides a rigid framework to solve combinatory and constraint problems (in addition to general purpose programming) yet retains performant translations into DFAs due to the regex base. With stacks for data and regex for control flow, Prowl provides a unique but ergonomic way to think about hard problems.
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.
Pure Data - Pure Data (or just "Pd") is an open source visual programming language for multimedia. Pure Data is developed by Miller Puckette since 1996 and you can find it on his official website along with the official documentation and other related resources.
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
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.
Pyretic - Python + Frenetic = Pyretic. Pyretic is one member of the Frenetic family of SDN programming languages. As such Pyretic enables network programmers and operators to write succinct modular network applications by providing powerful abstractions. Pyretic is both a programmer-friendly domain-specific language embedded in Python and the runtime system that implements programs written in the Pyretic language on network switches.

Q (7):

Q - Q is an interpreted, dynamically typed functional programming language based on term rewriting which allows you to define functions using symbolic equations. It works on (32 bit) Linux, OS X, Unix and Windows, and comes with a bunch of useful libraries which turn it into a practical programming tool. The Q programming system is free software distributed under the GPL.
Qi - Lightweight and fast programming language designed to be written in Chinese.
Qogo - This application was developed to teach 5 to 10 year olds the principles of programming via the venerable "Turtle Graphics" paradigm. It is written in TCL so it runs on all computer platforms. It features a full IDE with undo support and interactive construction as well as being able to save newly created commands as new instructions.
Quick Macros - Quick Macros - automation software for Windows 7/8/10/11. Some features:
- User interface automation, launching programs, file management, text processing, custom dialogs, internet functions, web page automation, Excel automation, database/XML/CSV functions, regular expressions, VBScript, C#.
- Many triggers, including hotkeys, mouse, window, autotext, scheduler, toolbars and menus.
- Records keyboard and mouse actions.
- Captures, finds and clicks web page objects, other UI objects, on-screen images and text.
- Programming language with functions, classes, full dll/API/COM support.
- You can create programs for various purposes. Run in Quick Macros or as exe files.
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 (37):

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.
RapidBATCH - A general-purpose scripting language platform for automation.
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.
Ravi - Ravi is a dialect of Lua with limited optional static typing and features a JIT compiler powered by MIR as well as support for AOT compilation to native code.
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.
Restructor - Restructor is a system / algorithm to automatically refactor entire code-bases down to their least-redundant form (normal form). It’s a research project I worked on 2005-2010.
Retro - RETRO is a clean, elegant, and pragmatic dialect of Forth. It provides a simple alternative for those willing to make a break from legacy systems. The language draws influences from many sources including traditional Forth systems, cmForth, colorForth, Factor, and Parable. It was designed to be easy to grasp and adapt to specific uses. The basic language is very portable. It runs on a tiny virtual machine (Nga), which is written in C. There are multiple interface options, the main one (rre) is buildable with just the standard C compiler and libraries on most systems.
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.
Rhumb - Experimental International Language
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.
Robin - Robin is a functional programming language with eager evaluation, latent typing, and a homoiconic syntax (see Scheme), based on a radically simple core semantics (see Pixley) in which both functions and macros are defined in terms of a more basic abstraction, the fexpr. Expressions in Robin are referentially transparent; programs interact with the outside world through an event-oriented framework.
Roc - Roc is a language for making delightful software.
Rock - Little language made with Rust and LLVM. Aim to follow the enforced safeness of the Rust model with a borrow checker (SoonT) 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.
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.
Rowlang - RowLang is a minimalistic esoteric programming language written as an analogy to rowing.
RPL/2 - Reverse Polish Lisp/2 release 4.1.31, half-compiled high-level language using shared libaries and mainly aiming at scientific calculations and complex algorithms
rpn - rpn - Reverse Polish Notation CLI calculator. A math functional language using reverse (postfix) polish notation
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 (50):

SaC - Single-Assignment C is an array programming language predominantly suited for application areas such as numerically intensive applications and signal processing. Its distinctive feature is that it combines high-level program specifications with runtime efficiency similar to that of hand-optimized low-level specifications. Key to the optimization process that facilitates these runtimes is the underlying functional model which also constitutes the basis for implicit parallelisation. This makes SAC ideally suited for harnessing the full potential of a wide variety of modern architectures ranging from a few symmetric cores with shared memory to massively parallel systems that host heterogeneous components including GPUs and FPGAs.
SATySFi - SATySFi (pronounced in the same way as the verb “satisfy” in English) is a new typesetting system equipped with a statically-typed, functional programming language. It consists mainly of two “layers” ― the text layer and the program layer. The former is for writing documents in LaTeX-like syntax. The latter, which has OCaml-like syntax, is for defining functions and commands. SATySFi enables you to write documents markuped with flexible commands of your own making. In addition, its informative type error reporting will be a good help to your writing.
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.
Scopes - The Scopes Programming Language & Compiler Infrastructure
Seed7 - Seed7 is a higher level language compared to Ada, C++ and Java.
Self - Self is a prototype-based dynamic object-oriented programming language, environment, and virtual machine centered around the principles of simplicity, uniformity, concreteness, and liveness.
Senegal - Senegal is a powerful, small-but-fast, concurrent, class-based, and dynamically-typed programming language with a modern syntax.
shc - shc - Generic shell script compiler
SheerPower - Sheerpower is a next generation database and scripting language for Windows. It is supported on Windows 10, 11, and Windows Server 2016 and above.
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.
Silice - A language for hardcoding algorithms into FPGA hardware
SimpleScript - SimpleScript is a simple programming tool for scripting languages (Perl, PHP, Python, Ruby, TCL) written in Obj-C/Cocoa. It can be used by experienced developers to write and test on the fly small routines, and is a good solution for educational purposes. Do not use it in production environments or to manage large projects.
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.
Sirius - Sirius is a general-purpose programming language which could best be described as a cross between Pascal and BASIC, although that may be misleading. Syntactically, it is similar to Pascal. Functionally, it resembles languages such as VAX BASIC and Borland's Delphi. Conceptually, it is like C in some respects: minimal keywords, access to low-level programming, etc. But the main idea behind Sirius is simply a programming tool which reduces the amount of time required to write applications. For instance, the language has all of the common data types built-in, so that you don't have to reinvent the wheel for linked lists, binary trees, queues, stacks, and the like. It also allows static strings and dynamic strings with automatic garbage collection.
SISC - SISC is an extensible Java based interpreter of the algorithmic language Scheme. SISC uses modern interpretation techniques, and handily outperforms all existing JVM interpreters (often by more than an order of magnitude).
Slang - Statically typed scripting language... syntax errors should be catched at design time!
Slang - S-Lang is a multi-platform programmer's library designed to allow a developer to create robust multi-platform software. It provides facilities required by interactive applications such as display/screen management, keyboard input, keymaps, and so on. The most exciting feature of the library is the slang interpreter that may be easily embedded into a program to make it extensible. While the emphasis has always been on the embedded nature of the interpreter, it may also be used in a stand-alone fashion through the use of slsh, which is part of the S-Lang distribution.
SMAL - The machine independant SMAL assembler and linker supports conditional and macro assembly and all linkage editing operations commonly associated with languages such as FORTRAN and C. It comes with a user's manual that also explains how to customize it to support a variety of machine instruction sets.
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.
SOUL - The SOUL language is a small, carefully crafted DSL for writing real-time DSP code. Its design goals are to be fast, secure, safe, and simple for even beginners to learn. The SOUL runtime is a collection of tools and technologies for running SOUL code with very high efficiency, on heterogeneous CPUs and DSPs, both locally and remotely.
SPA - A simple interpreter of a pseudo assembler language.
sparcl - Sparcl: A Language for Partially-Invertible Computation. This is an implementation of a system presented in the paper: Kazutaka Matsuda and Meng Wang: Sparcl: A Language for Partially-Invertible Computation, ICFP 2020.
SPARK - SPARK stands for the Scanning, Parsing, and Rewriting Kit. It formerly had no name, and was referred to as the "little language framework." The first version (circa 1998) was described in the paper Little Languages in Python at the 7th International Python Conference.
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.
SpécialK - SpécialK, an anaesthetizing algorithmic language. The SpécialK language is a logical and functionnal language similar to Erlang, and used in 2nd year of CS at the university of Nice in algorithmics course of E.Kounalis. SpécialK is a SpécialK to Scheme compiler.
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.
SR - SR (Synchronizing Resources) is a language for writing concurrent programs. The main language constructs are resources and operations. Resources encapsulate processes and variables they share; operations provide the primary mechanism for process interaction. SR provides a novel integration of the mechanisms for invoking and servicing operations. Consequently, all of local and remote procedure call, rendezvous, message passing, dynamic process creation, multicast, and semaphores are supported. SR also supports shared global variables and operations.
Stab - A multi-paradigm programming language designed for the Java Virtual Machine
Stacksmith - An intuitive software erector kit targeted at people new to programming, but with enough potential to stay useful once they've learned, inspired by HyperCard.
Stan - Stan is a state-of-the-art platform for statistical modeling and high-performance statistical computation. Many thousands of users rely on Stan for statistical modeling, data analysis, and prediction in the social, biological, and physical sciences, engineering, and business.
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.
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.
STOICAL - STOICAL is vastly different from its predecessors. Primarily because so much has changed since the decades ago that they were developed. Today STOICAL is powerful and general enough to be used as a high performance replacement for semi-compiled and interpreted languages like Perl, Python, SED and Awk. And because of STOICAL's advanced support for networking and concurrent threads of execution, it can be used to write efficient long-running servers and daemons that would normally need to be written in C. The intent here is not to explore the intricacies of archaic systems, but to create a new and modern language, well suited to the world as it exists today. STOICAL might therefore be more accurately represented by the recursive acronym SINS, SINS Is Not STOIC, but this word has a remarkable stigma attached to it ;-)
Strand - "Strand" is an open-source implementation of the identically named parallel Prolog dialect as described in the book "Strand: New Concepts for Parallel Programming" by Ian Foster and Stephen Taylor. Strand represents a very elegant and concise notation for expressing concurrent and distributed algorithms using only a small number of fundamental language constructs and a very simple execution model.
Streem - Streem is a stream based concurrent scripting language. It is based on a programming model similar to the shell, with influences from Ruby, Erlang, and other functional programming languages.
Strictly False - I have designed an eccentric programming language (Strictly False) an extension of Wouter van Oortmerssen's elegant False programming language. ... to run my interpreter (and my language is definitely more powerful), you need Moscow ML.
Stroscot - Stroscot is an imperative programming language designed for modern processors.
Stroyent - Stroyent is an infix, procedural systems programming language targeting MakoVM. Stroyent syntax superficially resembles that of C, but there are many important differences in the semantics of these languages.
SubC - SubC is a fast and simple public domain compiler for a clean subset of the C programming language. It can compile itself and passes gcc -Wall -pedantic.
Sunder - a modest systems programming language for Unix-like platforms.
Suneido - Suneido™ is a complete, integrated application platform – a system for developing and deploying applications without the frustrations of integrating multiple different products. Suneido incorporates an object-oriented programming language, client-server relational database software, and application frameworks and components. It includes the integrated development environment (IDE) used to create applications as well as the client and server required to run applications across networks. Suneido is Open Source – it is provided free, with complete source code.
Superx++ - Superx++ is an object-oriented language that is entirely based on XML's syntactical structure. Superx++ conforms with the XML version 1.0 specification as published on the W3C web site. Programming in XML itself has great potential and Superx++ pushes the envelope!
Swallow - A minimalist functional programming language
Sylvan - A general-purpose programming language that aspires to have support for attribute grammars, managed effects, and efficient pure functional programming.

T (28):

T3X - T3X is a small, portable, procedural, block-structured, recursive, almost typeless, and to some degree object-oriented programming language. Its syntax is similar to Pascal, its semantics resembles BCPL's.
T3XFORTH - T3XFORTH is an old-school, plain vanilla FORTH system that is mostly compatible to FORTH-79 with some parts borrowed from FIG FORTH, FORTH-83, and EFORTH, and taking some inspiration from Leo Brodie's (classic, 1983) book, "Starting FORTH". T3XFORTH runs on 8086 processors under DOS on an IBM PC, or stand-alone using the PC BIOS. It can also run on 32-bit Unix systems using a T3XFORTH VM emulator.
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.
Tamsin - Tamsin is an oddball little language that can't decide if it's a meta-language, a programming language, or a rubbish lister. Its primary goal is to allow the rapid development of parsers, static analyzers, interpreters, and compilers, and to allow them to be expressed compactly. Golf your grammar! (Or write it like a decent human being, if you must.)
Tandem - Tandem is an experimental rewriting language where the rewrite rules form a Kleene algebra. The object being rewritten by a Tandem program is a collection of labelled stacks -- a finite mapping from strings to strings. The strings are always rewritten at the left edge, so they are effectively stacks. A Tandem program consists of a single rewrite rule along with zero or more pragmas. The rewrite rule is applied to an initial state to possibly obtain a final state. This rule is applied only once. However, in Tandem, a rule is a composite object which may contain subrules that get applied many times.
Tao - A statically-typed functional language with polymorphism, typeclasses, sum types, pattern-matching, first-class functions, currying, good diagnostics, and much more!
Tao3D - Tao3D is a dynamic document description language designed specifically for real-time 3D animations. It can be used to present complex information in an entertaining and interactive way.
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.
Teal - Teal is a simplified language for teaching program analysis concepts.
Teal - A typed dialect of Lua
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.
Thistle - Thistle is a programming language and compiler, suitable for introductory programming instruction. It creates a single file, compiled executable application. Thistle comes with a code editor, helpfile, sample code, and the FASM assembler. There are two versions of Thistle. Thistle creates a console application. Thistle-Win creates a Windows application.
Thon - a small functional language
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.
Tint - Tint is a string substition language; it is intended to be used as an extention language. Tint Emacs is an emacs clone for Win32, Mac OS X, Darwin, and Linux. It uses Tint as its extension language.
Tinymoe - English-like programming language, for DSL (Domain Specific Language) building and embedding, with dynamic typing, multiple dispatching and build-in continuation.
Toka - Toka is a concatenative programming language related to Forth. It should be easy to learn, extend, and use. Development is ongoing, and updates occur almost daily. The language is not compatible with any known existing Forth implementation, although some Forth code can be ported to Toka. Among the provided features are a memory allocator with basic garbage collection, dynamic allocations for functions and data, a decompiler, and a basic FFI. The implementation was designed to be easily portable between Unix-like systems
Tokay - Tokay is a programming language to quickly implement solutions for text processing problems. This can either be just simple data extractions, but also parsing entire structures or parts of it, and turning information into structured parse trees or abstract syntax trees for further processing. Therefore, Tokay is both a tool and language for simple one-liners, but can also be used to implement code-analyzers, refactoring tools, interpreters, compilers or transpilers. Actually Tokay's own language parser is implemented in Tokay itself.
ToonTalk - ToonTalk is an interpreter for a concurrent constraint programming language. Concurrent constraint programming is a synthesis of concurrent logic programming and constraint logic programming. (See, for example, Saraswat). The class of languages for which programs are roughly interchangeable with ToonTalk programs include Oz, E-Lang, Janus, Flat Guarded Horn Clauses, KL1/KLIC, Flat Concurrent Prolog, Parlog, and Strand. The syntax of all these languages is textual while ToonTalk has an action-oriented video game animation syntax. The programming environment is completely different as well. In ToonTalk, the process of constructing, testing, and debugging programs closely resembles playing a video game. "From Prolog and Zelda to ToonTalk" is a paper discussing these ideas in detail.
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.
Tyro - TYRO is a very high level programming language designed mainly for the beginners of the programming, to develop a thorough understanding of the fundamental concepts of languages.

U (7):

uiua - Uiua (wee-wuh ) is a general purpose, stack-based, array-oriented programming language with a focus on simplicity, beauty, and tacit code. Uiua lets you write code that is as short as possible while remaining readable, so you can focus on problems rather than ceremony.
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.
Unit - Unit is a General Purpose Visual Programming Language and Environment built with a primary focus on Developer Experience. It is heavily inspired by Live, Data Flow, Reactive, Functional and Object Oriented Programming paradigms. Formally, units are Multi Input Multi Output (MIMO) Finite State Machines (FSM). A program in Unit is represented as a Graph.
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. It is similar to C++ or Rust. Main goal is a safety, but not with cost of verbosity. [C++ killer, Rust killer]

V (17):

V - Simple, fast, safe, compiled language for developing maintainable software. Compiles itself in <1s with zero library dependencies.
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().
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.
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.
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.
Vigil - Vigil, the eternal morally vigilant programming language
Vinci - A proof-of-concept compiler targeting SPIR-V for a toy ML functional shading language.
Vinegar - Vinegar is a semi-concatenative language where every operation can fail.
violet - A programming language, half theorem prover
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.
Visula - Visula is a general-purpose visual programming language (VPL) based on object-orientation. Visula programs are diagrams that are edited in a graphical editor. Programmers don't write software - they draw it!
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.
Vortex - Vortex is a language-independent optimizing compiler infrastructure for object-oriented and other high-level languages, written entirely in Cecil. It primarily operates as a whole-program optimizer, performing aggressive analyses and optimizations given the whole program. It has front-ends for Cecil, Diesel, Smalltalk, Java, C++, and Modula-3. These front-ends translate into the Vortex RTL intermediate language. Vortex produces either portable C++ code or SPARC assembly code.
Vox - Vox is a multiparadigm programming language inspired by D (60%), Jai (30%), and Zig (10%). Vox language compiler. AOT / JIT / Linker. Zero dependencies.

W (14):

Wa - Wa is a general-purpose programming language designed for developing robustness and maintainability WebAssembly software. Instead of requiring complex toolchains to set up, you can simply go install it - or run it in a browser.
Wak - Stack-based text-processing language
Wasp - Wasp (Web Application Specification) is a Rails-like framework for React, Node.js, and Prisma. Build your app in a day and deploy it with a single CLI command!
- 🚀 Quick start: Due to its expressiveness, you can create and deploy a production-ready web app from scratch with very few lines of concise, consistent, declarative code.
- 😌 No boilerplate: By abstracting away complex full-stack features, there is less boilerplate code. That means less code to maintain and understand! It also means easier upgrades.
- 🔓 No lock-in: You can deploy the Wasp app anywhere you like. There is no lock-in into specific providers; you have full control over the code (and can actually check it out in .wasp/ dir if you are interested ).
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).
Wenyan - 文言文編程語言 A programming language for the ancient Chinese.
- Natural Language Programming sharing the grammar of Classical Chinese
- Compiles to JavaScript, Python, or Ruby
- Turing complete
- An Online IDE
- Examples to get started
- A packages manager wyg(文淵閣) and awesome packages from the community.
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.
Wing - Winglang is a new open-source programming language designed for the cloud (aka "cloud-oriented"). Wing enables developers to build distributed systems that leverage cloud services as first-class citizens by combining infrastructure and application code in a safe and unified programming model (aka "cloud-oriented"). Wing programs can be executed locally (yes, no internet required) using a fully-functional simulator, or deployed to any cloud provider (yes, Wing programs are portable across providers).
WisniaLang - A compiler for an experimental programming language that produces tiny Linux binaries (ELF x86_64) without LLVM dependency!
Wisp - Wisp turns indentation into lisp expressions.
Wren - Wren is a small, fast, class-based concurrent scripting language.
Wu - An expression oriented, gradually typed and mission-critical programming 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.
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 (11):

X Language - X Language is a new multi-syntax programming including a portable set of APIs to create console or graphical applications runnable on many platforms (UNIX/X11, Win32, ...). X Language comes with an interpreter, a compiler and a debugger.
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.
XIDEK - XIDEK provides technical guidance and source code so that you can readily design and implement an interpreter according to your own requirements. You may need, for example, to create a special interpreter for a domain specific language, script language, or other "little language". XIDEK can save you weeks or months of work. It gives you parsers, support modules, explanations, examples, organization and a framework upon which you can build.
XL - A minimalist, general-purpose programming language based on meta-programming and parse tree rewrites
xlisp - XLISP - an object-oriented LISP
Xojo - Build Native, Cross-Platform Apps. Rapid application development for Desktop, Web, Mobile & Raspberry Pi.
XPL - The XPL programming language is a derivative of PL/I designed for compiler writing. XPL was first announced at the 1968 FJCC in San Francisco, CA. XPL is the name of both the programming language and the compiler generator system (or TWS: translator writing system) based on the language.
xpl - eXample Programming Language. C-like language syntax; arithmetic and conditional expressions; dynamically typed; 3 data-types: integer, float, string; simple control structures (conditionals, iterations); 6 build-in functions
XSB - XSB is a Logic Programming and Deductive Database system for Unix and Windows.
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 (4):

Yab - Yab | yet another Basic for HAIKU.
Yeti - Yeti is ML style functional programming language, that runs on the JVM.
Yorick - Yorick is an interpreted programming language for scientific simulations or calculations, postprocessing or steering large simulation codes, interactive scientific graphics, and reading, writing, or translating large files of numbers.
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 (8):

Z# - Z-Sharp is a custom programming language I made because I don't like c++ very much (Z-Sharp's interpreter is written in c++ though). Z-Sharp scripts have the file extension .ZS. The base syntax and formatting I would say is quite similar to C# or Python, but differs as task complexity increases. It also has support for graphics using SDL2.
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.
zeptoforth - zeptoforth is a Cortex-M Forth, currently targeted at RP2040 boards such as the Raspberry Pi Pico, the Raspberry Pi Pico W, the Arduino Nano RP2040 Connect, the Cytron Maker Nano RP2040, the SeeedStudio XIAO RP2040, and the WIO RP2040 (which it has been tested with) using 25Q Quad SPI flash compatible with the Winbond Quad SPI flash on the Raspberry Pi Pico, RP2350 boards such as the Raspberry Pi Pico 2 and the Pimoroni Pico Plus 2, the STM32L476, STM32F407, and STM32F746 DISCOVERY boards, and the STM32F411 "Black Pill" board. Ports to more platforms are on hold due to the current chip shortage (aside from a possible port to an STM32H7 board I have lying around somewhere). A hack exists for getting zeptoforth to work properly on STM32F411 Nucleo 64 boards using the binaries compiled for STM32F411 "Black Pill" boards.
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.
Zngr L Compiler - Zngr L Compiler is the first Compiler for the theoretical language L , in the world , which used in the computation theory that teaches in the computer science departments in any faculty of since , as a basic language for computations .

Name		Name	Last commit message	Last commit date
Latest commit History 652 Commits
.gitattributes		.gitattributes
LICENSE		LICENSE
README.md		README.md
awesome-pl-articles.md		awesome-pl-articles.md

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

Awesome programming languages

Related:

Contents

A (44):

B (42):

C (73):

D (30):

E (37):

F (62):

G (45):

H (29):

I (37):

J (38):

K (40):

L (72):

M (83):

N (26):

O (23):

P (50):

Q (7):

R (37):

S (50):

T (28):

U (7):

V (17):

W (14):

X (11):

Y (4):

Z (8):

See also:

About

Releases

Packages

Contributors 44

Languages

License

ChessMax/awesome-programming-languages

Folders and files

Latest commit

History

Repository files navigation

Awesome programming languages

Related:

Contents

A (44):

B (42):

C (73):

D (30):

E (37):

F (62):

G (45):

H (29):

I (37):

J (38):

K (40):

L (72):

M (83):

N (26):

O (23):

P (50):

Q (7):

R (37):

S (50):

T (28):

U (7):

V (17):

W (14):

X (11):

Y (4):

Z (8):

See also:

About

Topics

Resources

License

Stars

Watchers

Forks

Releases

Packages 0

Contributors 44

Languages

Packages