Uncategorized

• Uncategorized

  • 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 - 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 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.
  • 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.
  • Ixion - Ixion is a compiled programming language for the jvm platform, combining modern OOP and FP. Written in pure java.
  • 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.
  • 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.
  • 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.
  • 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).
  • 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.
  • 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.
  • Jsi - Jsi is a C (+/-) embeddable JavaScript interpreter alternative to languages such as Python, Lua, and Tcl
  • 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.
  • 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.
  • Kantalo - It is a new programming language, not object-oriented, with the aim of being simpler and having a lower learning curve.
  • kaoscript - kaoscript is programming language combining features from ES7, CoffeeScript, TypeScript, Rust, Swift, C# and more. Currently, kaoscript is transpiled to JavaScript.
  • 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.
  • 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.
  • Kernel - Kernel is a conservative, Scheme-like dialect of Lisp in which everything is a first-class object.
  • Key - a dynamic language that allowed both class abstraction and object description.
  • 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.
  • 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
  • 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.
  • 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.
  • 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.
  • 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 - 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.
  • 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.
  • 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.
  • 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.
  • LC-3 - Version 3.01 of the Windows LC-3 assembler and simulator
  • LeekScript - Leek Wars is a programming game in which you have to create the most powerful leek and destroy your enemies!
  • LENS - LENS stands for "Language for Embeddable .NET Scripting".
  • Leo<HTML> - a HTML precompiler for static home page generation. It detects special HTML tags in your page and generates HTML code out of it
  • 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:
  • 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.
  • 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
  • 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.
  • 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.
  • 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.
  • 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
  • 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.
  • 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.
  • 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
  • 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
  • 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.
  • 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!
  • 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.
  • 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 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:
  • 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.
  • 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.
  • 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](https://rohbot.net/mond/).
  • 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:
  • 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.
  • 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 - 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.
  • 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.
  • μ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#.
  • 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:
  • Nelua - Nelua (stands for Native Extensible Lua) is a minimal, efficient, statically-typed and meta-programmable systems programming language heavily inspired by Lua, which compiles to C and native code.
  • Neptune - A fast, a dynamically typed, concurrent and embeddable scripting language.
  • Neva - Next-generation programming language that solves programmers' problems
  • 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.
  • 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.
  • Niva - Smalltalk like programming 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.
  • NPL - NPL or Neural Parallel Language is an open source, high-performance scripting language.
  • NullC - Fast C-like programming language with advanced features.
  • NumFu - A pure, interpreted, functional programming language. NumFu's simple syntax and semantics make it well-suited for educational applications, such as courses in functional programming and general programming introductions. It is also ideal for exploring mathematical ideas and sketching algorithms, thanks to its native support for arbitrary-precision arithmetic.
  • Oak - A portable programming language with an incredibly compact backend.
  • 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.
  • OCaml - A general-purpose, industrial-strength programming language with an emphasis on expressiveness and safety. OCaml is a multi-paradigm programming language which extends the Caml dialect of ML with object-oriented features.
  • Odin - The Odin programming language is designed with the intent of creating an alternative to C.
  • Oil - Oil is a new Unix shell. It's our upgrade path from bash to a better language and runtime.
  • Okta - Okta is a new open source, general-purpose programming language that, although it's still in its childhood, aims to provide a simple platform to create low level, efficient software.
  • One - It is an open source, self-hosted, bootstrapping system programming language which makes it easy to build reliable and efficient software. One is a programming language that makes it easy to build reliable, efficient and performant software. [system]
  • 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.
  • 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 - 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 - A state machine based programming language for formally modeling and specifying complex distributed systems.
  • 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.
  • Pascal Script - Pascal Script is an Object Pascal/Delphi/Lazarus-compatible interpreter with bytecode compiler that delivers a scripting environment for application programs.
  • PascalABCNet - PascalABC.NET is the new generation Pascal programming language that combines simplicity of classic Pascal, a great number of modern extensions and broad capabilities of Microsoft .NET Framework. It's ree, simple and powerful IDE. Built-in form designer for rapid development of Windows desktop applications.
  • Passerine - A small extensible programming language designed for concise expression with little code. Passerine is a small, concise, extensible functional scripting language, powered by a VM written in Rust.
  • Peachpie - PeachPie is a modern PHP compiler based on the Microsoft Roslyn compiler platform and drawing from our popular Phalanger project. It allows PHP to be executed within the .NET framework, thereby opening the door for PHP developers into the world of .NET - and vice versa.
  • 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