Programming languages are (generally) human-friendly means of getting a computer to do something interesting on a human's behalf. Some languages may be friendlier than others; where opinions will genuinely differ as to which are friendlier, there are some that deliberately seek to be as obtuse and unreadable as possible, and those are usually called "esoteric" programming languages and fit into their own category of madness.

See also Language Places and PLZoo

See also language reading and language development

---

"Every configuration file becomes a Turing-complete language eventually." --James Gosling

Every simple language will eventually end up Turing complete

Language concepts

Syntax/paradigms

Toward a better programming

"Programming Paradigms for Dummies: What Every Programmer Should Know"; includes a chart of the major programming paradigms:

• Descriptive declarative programming XML, S-expression
• First-order functional programming
• Imperative programming Pascal, C
• Imperative search programming SNOBOL, Icon, Prolog
• Functional programming Scheme, ML
• Deterministic logic programming
• Relational & logic programming Prolog, SQL embeddings
• Constraint (logic) programming CLP, ILOG Solver
• Concurrent constraint programming LIFE, AKL
• Lazy concurrent constraint programming Oz, Alice, Curry
• Continuation programming Scheme, ML
• Lazy functional programming Haskell
• Monotonic dataflow programming
• Declarative concurrent programming Pipes, MapReduce
• Lazy dataflow programming
• Lazy dataflow concurrent programming Oz, Alice, Curry
• ADT functional programming Haskell, ML, E
• ADT imperative programming CLU, OCaml, Oz
• Nonmonotonic dataflow programming
• Concurrent logic programming Oz, Alice, Curry, Excel, AKL, FGHC, FCP
• Functional reactive programming (FRP)
• Weak synchronous programming FrTime, SL
• Strong synchronous programming Esterel, Lustre, Signal
• Multi-agent dataflow programming Oz, Alice, AKL
• Event-loop programming E in one val
• Multi-agent programming
• Message-passing concurrent programming Erlang, AKL
• Active object programming
• Object capabilities programming CSP, Occam, E, Oz, Alice, publish/subscribe, tuple space (Linda)
• Sequential object-oriented programming
• Stateful functional programming Java, OCaml
• Concurrent object-oriented programming
• Shared-state concurrent programming Smalltalk, Oz, Java, Alice
• Software transactional memory SQL embeddings

Declarative, imperative, functional, constraint, logic, relational, concurrent, dataflow, synchronous, mesage-passing, event-loop, object-oriented, stateful, shared-state

My ontology:

• Assembly/Machine: Characterized by little-to-no abstraction over the target platform.
• Imperative (Steps taken to achieve a certain result. Von Neumann machines.) vs Declarative (Statements about what should exist, not how it comes into being)
• Procedural: Characterized by imperative execution statements with well-defined entry and exit points.
• Object-oriented: Characterized by the union of state and behavior into a first-class concept, either at compile-time, run-time, or both. Ontological/categorical relationships between objects are often (though not always) possible, usually capturing some form of additive reuse, aka "inheritance". Objects are usually broken into two different kinds of object systems, typically depending on whether they are ahead-of-(execution-)time type-checked or not:

  • "Class"-based object languages: The more "traditional" OOP systems in which an object is forged out of a template/"cookie-cutter" expression known as a class. Typically these languages are compiled and strongly-type-checked, and if runtime inspection facilites (reflection) are available, they will be read-only. Objects obtained as part of the runtime inspection facilities are generally read-only, and often cached/singletonized/memoized.

  • "Prototype"-based object languages: Most popularized by ECMAScript, prototype-based object languages have long existed, going as far back as CLOS, Self, Smalltalk, and others. Here, inheritance is a runtime relationship understood by the runtime (an object is cloned from a prototype "class" object, and as part of that cloning process a well-known pointer/reference is established back to the "class" object for "class"-level properties/methods), and is often malleable. Most prototype-object languages are dynamically-typed and often weakly-typechecked, since the runtime doesn't have a priori knowledge of how the various relationships are set up after the program has begun execution.

  Note that any language which supports records (4.1) and lexical function closures (4.2) can build objects "by hand", and even support inheritance by defining a runtime convention of a particularly-named-slot in a record to hold a reference to a prototype object. Given that functional languages often support both, this often leads to (a) functional-object hybrid languages with varying degrees of support for both, or (b) functional language zealots to insist that objects are unnecessary.

  Most object languages are imperative when defining methods, though this is not a requirement.

• Functional: Characterized by mathematics-inspired functions as first-class concepts. Preference for expressions over statements, lazy execution, immutable values, and so on. | Wikipedia | Some reading | Functional programming brought us monads and all the fun that goes with that. Frequently cites/builds off of the lambda calculus.

• Metaprogramming (aka MetaObject Protocol): Characterized by the idea that we can elevate "above" the object concept, in a variety of different ways: source generation, semantic macros, parametric polymorphism, and so on. Many MOPs allow for the runtime manipulation of object instances or types without requiring recompilation. This is not quite the same as dynamic languages that allow us to build objects out of data and functions-as-values, but it's not too far away, either.
• Probabalistic
  "Make it easier to to probabilistic inference in custom models." | Probabalistic Models of Cognition | "TOWARDS COMMON-SENSE REASONING VIA CONDITIONAL SIMULATION: LEGACIES OF TURING IN ARTIFICIAL INTELLIGENCE"
  Some slides on the concept; they mention a Microsoft Research language, Csoft, that does not appear in Google, and reference InferNET as being close to what Csoft was supposed to offer.

"Programming Language Explorations" suggested tags: declarative, imperative, applicative, functional, logic, von Neumann, object-oriented, expression-oriented, persistent, concurrent, reactive, dataflow, stack, free-form, curly brace, visual, compiled, interpreted, very high-level, system, scripting, glue, intermediate, esoteric, toy, educational, domain-specific

• JavaScript: imperative, functional, dynamic, prototypal
• CoffeeScript: functional, expression-oriented, dynamic
• Lua: Imperative, prototypal, scripting
• Python: imperative, glue, dynamic, scripting

Memory management

Languages often break down to automatically-managed memory vs. manually-managed, but most of the time that means heap management; static and stack allocation are (almost?) always automatically managed by virtue of their allocation schemes.

Language execution types

• Compiled: Source is ahead-of-time transformed into a binary output ready for "direct" execution--it can be loaded and run without additional help. Most compilers do some form of validity-checking, usually making use of type-checking, to ensure the program will run correctly. Several "flavors" of compiled targets fall into different categories:

  • Native: Source is compiled into binary format ready for direct execution by an operating system.

  • Transpiled: Source is ahead-of-time transformed into another source format. Term became popular with languages that transpiled into ECMAScript, but technically this has been around since long before then. (When I was taking ECS 140A at UCDavis in 1991, we had an assignment to write a language that transpiled into C, for example.) C has long been the preferred target of transpilers before ECMAScript, given its original goal of being a "higher-level assembly language". C-- is a variant of C made specifically for transpilation/compilation purposes.

  • Bytecode: This is usually a binary output format that is some level of abstraction higher than native CPU assembly language, but not much more. The intent is to provide an easier format for either direct execution or transformation into native assembly (Just-In-Time compilation) within a virtual machine. Some bytecode formats are well-documented and "external" (like the JVM and CLR formats). In many cases, however, an interpreter is actually doing an on-the-fly compilation of source to an internal bytecode format at runtime, since most bytecode formats are easier to JIT, and/or the bytecode provides a layer of abstraction from the language syntax to the underlying runtime.

• Interpreted: Generally this means that source is not pre-examined until the moment it is asked to run. At that point, validity-checking is done, whether "just" syntactical verification or an additional deeper type-based analysis.

Note that the lines are significantly blurring; several "interpreted" languages internally compile the source into an AST or bytecode format for faster execution, and several "compiled" languages are available to run at the command-line a la shell scripts or REPLs by internally taking source through their compilation pipeline and executing the result.

In the long run, the key differentiator around "compiled vs interpreted" may be solely whether the tool/language does ahead-of-time error-checking.

Types

A type system (a system in which one can define and/or declare types) is the mechanism by which the language detects errors either ahead of time (during compilation) or at runtime.

Runtime Introspection and Modification

Types can often be inspected at runtime regardless of the type-safe or type-checked nature of the language/platform; in many languages/platforms, the process of inspection is known as "reflection".

If the types can be manipulated/changed at runtime, then the language is often said to be a "MetaObject Protocol" language, meaning that it can operate at a "meta-object" level. These tend to be dynamically-type-checked/weakly-type-safe interpreted languages, since it is hard to enforce type-safety when types changing up at runtime.

Fun

• "History of Programming Languages" by James Iry. Illustrated--pictures and large fonts.
• "Say something you dislike about a language you love"
• "Say something nice about a language you dislike"

---

Detail Pages:

• 3BC-Lang Low-level language, tiny virtual machine, intermediate representation, embeddable, easy for beginners.
• ActionScript Programming language for the Adobe Flash plugin for web browsers.
• Ada The committee-designed language for government work.
• Ada++ An open source programming language aimed at making Ada more accessible.
• Adama RDF database
• Afnix A multi-threaded functional writing system with dynamic symbol bindings that support the object oriented paradigm. The system features a state of the art runtime engine that supports both 32 and 64 bits platforms.
• Agda A dependent types language.
• Alef A concurrent programming language designed for the Plan 9 operating system from Bell Labs.
• Alice Introductory programming language.
• Alice (AliceML) A functional programming language based on Standard ML, extended with rich support for concurrent, distributed, and constraint programming.
• AlloyTools Open source language and analyzer for software modeling.
• Alore Explores optional typing in a Python-like programming language.
• Alpaca Functional programming inspired by ML for the Erlang VM.
• AngelScript A statically typed curly brace language resembling C++ itself.
• ANI Concurrent=by-default programming language.
• Anko Scriptable interpreter with syntax similar to Go.
• Ante A compiled systems language focusing on providing extreme extensibility through the use of a compile-time API. Using such an API, compiler extensions can be created within the program itself, allowing for the addition of a garbage collector, ownership system, automatic linters, etc, all in a normal library without requiring any changes to the compiler itself.
• ANTLR Code-generating parser tool
• Apache.org The Apache site is a collection of numerous open-source projects, in all stages of life (incubating, maintained, archived).
• Apache Polygene (Retired) Composite Oriented Programming implementation.
• Apache Royale A productive, open-source frontend application technology that lets you code in MXML and ActionScript3 and output to different formats.
• Apeji PX An object-oriented programming language extension for Java, intended to facilliate parallel computing on multi-core processors, GPU, Grid and Cloud.
• Apex A strongly typed, object-oriented programming language that allows developers to execute flow and transaction control statements on Salesforce servers in conjunction with calls to the API. Using syntax that looks like Java and acts like database stored procedures, Apex enables developers to add business logic to most system events, including button clicks, related record updates, and Visualforce pages. Apex code can be initiated by Web service requests and from triggers on objects.
• APL An array language, and one of the oldest programming languages still in use today, next to FORTRAN, Lisp and COBOL.
• Arc A new dialect of Lisp.
• Archimate DSL A DSL for generating Archimate diagrams from source.
• Arden (syntax) A markup language used for representing and sharing medical knowledge and used in an executable format by clinical decision support systems to generate alerts, interpretations, and to screen and manage messages to clinicians.
• Aria Expressive, noiseless, interpreted, toy programming language.
• Ark Systems programming language; goal is to a cleaner C without deviating from C's original goals of simplicity.
• ArkScript A small, fast, functional and scripting language for C++ projects.
• ARM Assembly ARM and AArch64 Assembly links
• as (GNU assembler) The GNU assembler.
• Aseba Event-driven programming language for driving robots in an educational environment.
• ASM.js An extraordinarily optimizable, low-level subset of JavaScript.
• AsmL Abstract State Machine Language, an executable specification language based on the theory of Abstract State Machines.
• ASN.1 (Abstract Syntax Notation) A standard interface description language for defining data structures that can be serialized and deserialized in a cross-platform manner.
• AspectC++ A strongly-typed aspect-oriented programming language starting from C++.
• AspectJ A strongly-typed aspect-oriented programming language starting from Java.
• Aspect-Oriented Programming (AOP) A flavor of MOP that uses stronger compiler- or library-enforced restrictions to constrain metaobject programming to fewer places or possibilities, in the name of keeping the code more predictable and understandable.
• Assembly language (generic) Collection of assembly language resources that don't fit in one of the other categories.
• AssemblyScript A TypeScript-like language for WebAssembly.
• Astro Multiparadigm language with Python syntax compiling to WASM and native code
• Asymptote Descriptive vector graphics language that provides a natural coordinate-based framework for technical drawing.
• ATS 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.
• Aucoda A "meta-compiler" that can take Au source and transpile to a different application language/platform.
• Aurora A language that can accept not only text but symbols (formulae, etc) as input.
• AutoHotKey The ultimate automation scripting language for Windows.
• Avail Programming Language Multi-paradigmatic general purpose programming language (and environment) emphasizing support for articulate programming.
• A Very Gentle Introduction To Relational & Functional Programming This tutorial will guide you through the magic and fun of combining relational programming (also known as logic programming) with functional programming.
• Awesome (lists) (Project Awesome) A curated collection of lists.
• Awk Tool for text processing and manipulation.
• Axum Discontinued MSR project to explore concurrency and channels as a direct part of the language.
• B4X A modern version of Visual Basic for multiple platforms.
• Babel A transpiler for writing next generation JavaScript.
• Ballerina A service-oriented programming language.
• Barb A small dynamic scripting language for .NET.
• bash (command-line shell) Command-line shell and associated shell-scripting language.
• Basic (and variants) Various notes and implementations of the BASIC programming language.
• Batsh A language that cross-compiles to bash and Windows batch command-line shell-scripting languages.
• BBytes An interesting collection of links, which partly served to inspire this website itself.
• BeanShell Object-ish scripting language early to the JVM.
• Beef An open source performance-oriented compiled programming language which has been built hand-in-hand with its IDE environment.
• Beta BETA is a modern language in the Simula tradition; it is strongly typed language like Simula, Eiffel and C++, with most type checking being carried out at compile-time.
• Bflat A native compiler for C# that comes with everything you need to build C# apps for any of the supported platforms.
• Bicep A domain-specific language (DSL) that uses declarative syntax to deploy Azure resources.
• BIPLAN (Byte coded Interpreted Programming LANguage) An experimental compact programming language and virtual machinethat fits in less than 12KB of program memory and is implemented in less than 2000 lines of code.
• bison Classic implementation (of yacc) for language development
• Bitsy the best language to implement when writing your first compiler or interpreter.
• Blade A simple, fast, clean, and dynamic language that allows you to develop applications quickly.
• Blockly The Blockly library adds an editor to your app that represents coding concepts as interlocking blocks. It outputs syntactically correct code in the programming language of your choice. Custom blocks may be created to connect to your own application.
• Bloodshed Compilers Collection of compilers resources
• Bolt A language with in-built data-race freedom!
• Boo Object-oriented language for the CLR incorporating Python-style syntax.
• Boomerang A general, open source, retargetable decompiler of machine code programs.
• Boomerang Language for writing lenses (bidirectional transformations) that operate on ad-hoc, textual data formats. Every lens program, when read from left to right, describes a function that maps an input to an output; when read from right to left, the very same program describes a “backwards” function that maps a modified output, together with the original input, back to a modified input.
• Boron An embeddable scripting language similar to Rebol.
• BorrowScript Combining TypeScript with Rust's borrow-checker (therefore requiring no GC).
• Bosque A language rethinking intermediate representation/bytecode to be more tool-friendly.
• BridgeScript A statically typed, platform independent programming language. It's syntactically similar to C language. Bridge script does not have any built-in APIs in the interpreter. It provides mechanism to invoke external functions by defining a bridge (Library type) to invoke.
• Bromium A DSL/framework for running automated integration/end-to-end tests through the browser. It is especially effective for single page applications (SPA) and any front end that has a lot of dynamic stuff going on.
• Build-Your-Own-X A collection of links on how to build various things as a learning exercise.
• Byte Buddy A library for creating and modifying Java classes during the runtime of a Java application and without the help of a compiler.
• C A procedural language intended first as a replacement for assembly, later taking on a life of its own as a systems-level language.
• C-- (C-minus-minus) A subset of C specifically aimed to make it useful as a high-level assembly language.
• C# A statically-compiled, object-oriented language for the CLR.
• C++ An object-oriented flavor of C.
• C++/CLI An adaptation of C++ to the CLR platform; successor to "Managed C++".
• C++11 Language Features C++ 2011 version
• C++14 Language Features C++ 2014 version
• C++17 Language Features C++ 2017 version
• C++20 Language Features C++ 2020 version
• C++ FFI Some notes and details on how C++ can call native bindings.
• C2 Evolution of C.
• Cadl A language for describing cloud service APIs and generating other API description languages, client and service code, documentation, and other assets.
• Caja A JavaScript implementation for "virtual iframes" based on the principles of object-capabilities.
• CAL / OpenQuark A lazy functional programming framework and language for the JVM.
• Callisto A minimalist language on "versioned objects".
• Carp A statically-typed lisp, without a GC, for real-time applications.
• Cat A statically typed functional stack-based programming language inspired by Joy.
• Catala A programming language for the law.
• Cecil A library to generate and inspect programs and libraries in the ECMA CIL form.
• Cell Flexible entirely-structural type system, orthogonal persistence, transactions, integrating with primary language (C++, Java, C#).
• Cello (libcello) A library that brings higher level programming to C.
• Cesium A C compiler for the CLR.
• Ceylon An object-oriented, strongly statically typed programming language with an emphasis on immutability.
• CFML (Cold Fusion Markup Language) A scripting language for web development.
• ChaiScript An easy to use embedded scripting language for C++.
• Chapel A modern programming language that is parallel, productive, portable, scalable.
• Charity A categorical programming language.
• Charly Fully parallel dynamically typed programming language.
• Checked C An extension to C that adds checking to C to detect or prevent common programming errors such as buffer overruns, out-of-bounds memory accesses, and incorrect type casts.
• Cheerp C/C++ A C/C++ compiler for Web applications - compiles to WebAssembly and JavaScript.
• Chef A language where the programs produce magnificent meals.
• Chevrotain Parser buildint toolkit for JavaScript.
• ChocoPy A Programming Language for Compilers Courses.
• ChucK Strongly-timed, concurrent, and on-the-fly music programming language.
• Ciao General-purpose programming language which supports logic, constraint, functional, higher-order, and object-oriented programming styles. Its main design objectives are high expressive power, extensibility, safety, reliability, and efficient execution.
• CilTools A set of tools to work with CIL in .NET applications.
• Circle Metaprogram C++ in C++. It encourages a seamless mixing of compile-time and runtime capabilities that upends decades of language design.
• CircuitPython A fork of MicroPython, designed for API uniformity across many microcontrollers.
• Cito Automatically translates the Ć programming language to C, Java, C#, JavaScript, ActionScript, Perl and D. Ć is a new language, aimed at crafting portable programming libraries, with syntax akin to C#.
• Citron General purpose programming language (mainly for unix-like systems).
• clasp Bringing Common Lisp and C++ Together.
• Clean A general purpose, state-of-the-art, pure and lazy functional programming language designed for making real-world applications. Some of its most notable language features are uniqueness typing, dynamic typing, and generic functions.
• ClearScript A library for adding scripting to .NET applications.
• Clio A pure functional lazy-evaluated programming language targeting decentralized and distributed systems.
• clip (command-line illustration processor) An open-source software package for creating charts and other data-driven illustrations.
• Clipper (aka xBase) SQL-inspired language from dBase days.
• CLIPS A forward-chaining rule-based programming language written in C that also provides procedural and object-oriented programming facilities.
• Cloe The timeless functional programming language. It aims to be simple and practical.
• Clojure A Lisp for the JVM.
• Clyde A language for writing game dialogues, supporting branching dialogues, translations and interfacing with your game through variables and events.
• COBOL Legacy business language that refuses to die.
• Cobra Interesting mix of paradigms into a single CLR-hosted language.
• Coco A CoffeeScript dialect that aims to be more radical and practical.
• Coconut Simple, elegant, Pythonic functional programming.
• CocoR Parser generator toolkit.
• CoffeeScript Unfancy JavaScript.
• cola An ongoing project to create a springboard for investigating new computing paradigms. Everything in it is late-bound, the intention being that any paradigm (existing or yet to be invented, formal complexity notwithstanding) be easily and efficiently mapped to it and made available to the user.
• Colin S Gordon's Electronic References A loosely-categorized collection of links to CS textbooks in a variety of areas that are freely available online.
• Comet A domain-specific language for hybrid optimization, featuring solvers for constraint programming, mixed integer programming, and constraint-based local search.
• Compiler correctness reading A collection of links and resources on compiler correctness, certification, validation, verification.
• Compilers.NET (Website) A collection of language links 2007 and earlier.
• Compilers Implementation/Optimization Reading Collection of articles on implementing languages.
• Concurnas An open source JVM programming language designed for building reliable, scalable, high performance concurrent, distributed and parallel systems.
• Console
• Context An interesting take on a procedural/object language.
• Continuation-passing style Readings and links on CPS.
• Converge A dynamically typed object oriented programming language with compile-time meta-programming facilities.
• Cool A small language designed for use in an undergraduate compiler course project. While small enough for a one term project, Cool still has many of the features of modern programming languages, including objects, automatic memory management, and strong static typing.
• Coq 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.
• Cow Language designed with the bovine in mind.
• Coyote A statically-compiled research language from Microsoft around explicit state machine management.
• C-plus-Equality (or See-Equality) Feminist Software Foundation C+=, a new language for us feminists.
• CppNet Quick and dirty port of jcpp (tools/jcpp) to C#, with features to support Clang preprocessing.
• CPython The original, "standard", C-based implementation of the Python language/platform.
• CQL (Cassandra Query Language) Query language that's almost SQL that rides on top of the Cassandra storage system.
• Crack An imperative, object-oriented language along the lines of Java, Python and C++. It can be compiled in Just In Time and Ahead Of Time modes and has been tested on 32 and 64 bit x86 Linux Debian and Ubuntu systems.
• Create Your Own Programming Language Notes on the book "Create Your Own Programming Language"
• Crystal A Ruby-inspired statically-type-checked, native language.
• cT An easy to use graphics- and mouse-oriented programming environment
• Cub an interpreted, dynamically typed, scripting language inspired by Swift.
• CUE (Configure Unify Execute) Language Validate, define, and use dynamic and text-based data.
• Cuneiform Functional programming language (static type checking) for large-scale data analysis workflows.
• Curl Richer Internet Applications: the Curl language, development environment, runtime engine, and development libraries.
• Curry Haskell with Logic extensions.
• CWEB Literate programming in C.
• Cypher A graph database query language first popularized by Neo4j.
• D a general-purpose programming language with static typing, systems-level access, and C-like syntax.
• D (Tutorial D) D is a set of prescriptions for what Christopher J. Date and Hugh Darwen believe a relational database management system ought to be like.
• Dark A startup effort around a service-oriented language and web development environment.
• Dart An open-source, scalable programming language, with robust libraries and runtimes, for building web, server, and mobile apps.
• daScript A statically-typed performance-oriented scripting language.
• Datalog A declarative logic language using Horn clauses; a lightweight deductive database system where queries and updates are expressed in the logic language
• Dg A (technically) simple language that compiles to CPython bytecode.
• Dhall A statically-typed functional configuration language.
• Dialog A domain-specific language for creating works of interactive fiction.
• Dictu A high-level dynamically typed, multi-paradigm, interpreted programming language.
• Dolphin Smalltalk Dolphin Smalltalk language, vm, etc.
• DolphinVM Dolphin Smalltalk virtual machine.
• Domain Specific Languages A collection of reading and links on the implementation of DSLs.
• DotLisp A Lisp dialect for .NET.
• DotNext A collection of .NET libraries intended to fill in gaps left by the CLR and standard library.
• DPMN (Discrete Process Modeling Language) A graphical language to capture more than business processes.
• Draconic A scripting language based off Python to run user scripts on the server safely.
• DSLisp An interpreted language and host that integrates with .NET.
• DTrace A performance analysis and troubleshooting tool that is included by default with various operating systems, including Solaris, Mac OS X and FreeBSD.
• DWScript A statically typed Delphi/Free Pascal-like language.
• 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.
• Dynamic Analysis Sanitizers reading Readings on software sanitizers.
• Dynamic Binary Instrumentation (DBI) reading A collection of reading and resources on dynamic program analysis
• Dynamic Binary Translation (DBT) reading Reading on DBT
• Dynamic Language Runtime (DLR) Enables language developers to more easily create dynamic languages for the .NET platform. In addition to being a pluggable back-end for dynamic language compilers, the DLR provides language interop for dynamic operations on objects.
• Dyon A rusty, dynamically typed scripting language.
• E An object-oriented programming language for secure distributed computing.
• E4X (ECMAScript for XML) An early attempt to embed hierarchical data/XML syntax functionality within the ECMAScript language. Since deprecated.
• Earl Grey Programming language compiling to JavaScript.
• ECMAScript (aka Javascript) A dynamic, object-oriented script language.
• Ecstasy (XTC) An object-ish language designed to be cloud native from the ground up.
• Effective C++, 3rd Ed Third edition of Scott's classic.
• Eiffel Object-oriented language that also implies an environment and "method" of writing software (much like Smalltalk). One of the early OO environments.
• Elixir A dynamic, functional language designed for building scalable and maintainable applications
• Elm A functional language for reliable webapps.
• Emojicode World’s only programming language that’s bursting with emojis.
• Emscripten C++ compiler that generates Javascript "assembly" for execution by any JS engine.
• Enso (aka Luna) Hybrid visual and textual functional programming. Aimed at union of data scientists and developers.
• Enterprise A non-deterministic-unnecessarily-statically-typed™ Turing-complete-ish™, Quantum-out-of-the-box™ programming language.
• EO (Elegant Objects) An object-oriented language, 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.
• Erlang/OTP An actors-based message-passing functional language running on BEAM.
• Esoteric Programming Languages Languages that are silly, ridiculous, or out to punish innocent programmers.
• Essence# A Smalltalk-superset language for the CLR.
• Esterel A programming language, dedicated to programming reactive systems, and a compiler which translates programs into finite-state machines.
• Eta A pure, lazy, strongly typed functional programming language on the JVM.
• Event Processing Language (EPL) A language, compiler, and runtime for complex event processing (CEP) and streaming analytics.
• EverPARSE A framework that automatically produces high-performance, formally proven C code for parsing binary messages.
• Excel LAMBDA Define custom functions using Excel's formula language.
• F* (F-star) A general-purpose functional programming language with effects aimed at program verification.
• Fable A compiler that brings F# into the browser.
• Factor A concatenative, stack-based programming language with high-level features including dynamic types, extensible syntax, macros, and garbage collection.
• Falcon 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; provides six integrated programming paradigms: procedural, object oriented, prototype oriented, functional, tabular and message oriented.
• Fancy A pure dynamic object-oriented, self-hosted programming language for the Rubinius VM.
• Fantom General-purpose object-oriented language intended for use across multiple platforms.
• fasm (Flat Assembler) The Flat Assembler
• Fault A modeling language for building system dynamic models and checking them using a combination of first order logic and probability.
• Fay A proper subset of Haskell that compiles to JavaScript.
• Felix An advanced, statically typed, high performance scripting language with native C++ embedding.
• Feral Dynamically-typed, imperative, interpreted programming language revolving around minimalism.
• Fetlang Fetish-themed programming language.
• Finch A simple bytecode interpreted, purely object-oriented, prototype-based, dynamically-typed programming language. It's mostly inspired by Smalltalk, Self, and Javascript.
• FJ (Functional Java) Functional library for Java.
• Fjord F# for the JVM
• Flapjax A new programming language designed around the demands of modern, client-based Web applications.
• flex GNU implementation of the lex parser tool.
• Flix Next-generation reliable, safe, concise, and functional-first programming language.
• Flutter for Windows Collection of links and research around using Flutter to build Windows apps.
• Folders (esoteric language) A programming language where the program is encoded into a directory structure; all files within are ignored.
• Foreign Function Interfaces (FFI) A collection of links and research on how various languages/vms handle interoperability with their host environment.
• Forest Multi-syntax functional programming language that compiles to WebAssembly.
• Forpost An embeddable, interpreted stack-based language which has simple, compact and effective implementation in ANSI C. Main features: heterogeneous arrays, higher-order functions, program/data equivalence.
• Forth Entirely stack-oriented programming language.
• FORTRAN (FORmula TRANslator) An older language focused on mathematics.
• Fortress Discontinued research language from Sun around secure high-performance computing.
• Frawk An efficient awk-like language.
• FreeBASIC A set of cross-platform development tools, consisting of a (BASIC) compiler, GNU-based assembler, linker and archiver, and supporting runtime libraries, including a software-based graphics library.
• FreePascal A mature, versatile, open source Pascal compiler.
• Free Programming Books A collection of free learning resources (books).
• Frege A functional language heavily Haskell-inspired for the JVM.
• Frink A practical calculating tool and programming language designed to make physical calculations simple, to help ensure that answers come out right, and to make a tool that's really useful in the real world. It tracks units of measure (feet, meters, kilograms, watts, etc.) through all calculations, allowing you to mix units of measure transparently, and helps you easily verify that your answers make sense.
• Fun Programming language for the realtime web.
• Futhark A purely functional data-parallel programming language in the ML family.
• Gambas A free development environment and a full powerful development platform based on a Basic interpreter with object extensions, as easy as Visual Basic.
• GameMonkeyScript Similar to Lua, multithreaded.
• GDL (GNU Data Language) A domain-specific data analysis and visualization programming language and a data analysis environment.
• Gecode An open source C++ toolkit for developing constraint-based systems and applications. Gecode provides a constraint solver with state-of-the-art performance while being modular and extensible.
• Gentee Script programming language for automation.
• GENTLE Compiler Construction System This compiler construction tool purports to provide a uniform framework for language recognition, definition of abstract syntax trees, construction of tree walkers based on pattern recognition, smart traversal, simple unparsing for source to source translation and optimal code selection for microprocessors.
• Ghostly A GitHub notification client for Windows 10/11.
• GitQL A query-only language for exercising SQL-like read-only interrogation of Git repositories.
• Glass
• Gleam A statically typed functional programming language for building scalable concurrent systems.
• Glinda Combines live programming, GUIs, and a DSL for data science.
• Gluon Inspired by Lua, Haskell, and OCaml. Each executing gluon thread gets a separate heap.
• GNU MIX Development Kit (MDK) 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.
• GNU Smalltalk The FSF implementation of the Smalltalk language/platform.
• Go Programming language from Google emphasizing coroutines.
• GOAL (part of Jak-Project) Port Jak 1 (NTSC "black label" version) to PC; over 99% of this game is written in GOAL, a custom Lisp language developed by Naughty Dog.
• Goby An object-oriented interpreter language deeply inspired by Ruby as well as its core implementation by 100% pure Go.
• Golo A lightweight dynamic language for the JVM
• Gosu A scripting language capable of loading XML schema definition files and XML documents as native types.
• Grace The purpose of Grace is to allow novices to discover programming in the simplest possible way. Other famous languages such as Java or Python are widely used by professionals, but may be hard to assimilate for a beginner in programming. That is what the object-oriented Grace language is made for.
• Grain Grain is a new language that puts academic language features to work.
• Gravity A class-based concurrent scripting language with a Swift-like syntax; embeddable; no external dependencies; register-based virtual machine.
• Greenfoot Visual and interactive programming tutorial tool built on top of Java.
• Groovy 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.
• GUILE The GNU Ubiquitous Intelligent Language for Extensions.
• GWBasic Ancient predecessor to modern BASIC, for DOS.
• h A simple, fast, open-source, complete, (satirical) and safe language for developing modern software for the web.
• Hack An object-oriented application language influenced by PHP.
• Haka An open source security oriented language (based on Lua) which allows to describe protocols and apply security policies on (live) captured traffic.
• Handel A small procedural programming language for writing songs in the browser.
• Hare A systems programming language designed to be simple, stable, and robust. Hare uses a static type system, manual memory management, and a minimal runtime.
• Haskell Pure-functional language.
• Haste an implementation of the Haskell functional programming language, geared towards web applications; compiler generates JavaScript code from Haskell.
• Haxe A modern, high-level, strictly-typed programming language
• hdl (Hardware Description Language) A specialized language used to describe the structure/behavior of real world circuits. It is used by circuit designers to simulate circuits and logic prior to wiring and fabricating a hardware circuit.
• Hecl Mobile scripting language for the JVM.
• Heresy A functional Lisp/Scheme dialect implemented in Racket, with syntax inspired by the BASIC family of programming languages.
• Heron A pure functional type-inferred language based on JavaScript.
• Hetu A lightweight scripting language written in Dart for embedding in Flutter apps.
• Hexagony A two-dimensional, hexagonal programming language.
• HLA (High Level Assembler) A higher-level assembler for a variety of different targets. By Randall Hyde.
• Hope 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.
• How to Design Programs
• Hy A lisp dialect built on top of python. This is achieved by converting hy code to python’s abstract syntax tree (ast). This allows hy to call native python code or python to call native hy code as well.
• HyperCard Apple's original "low-code" environment
• Hyperscript A scripting language designed for modern front-end web development, inspired by Hypercard, and Hypertalk.
• Icon (and Unicon) Icon is a high-level, general-purpose programming language novel features including string scanning and goal-directed evaluation. Unicon is Icon with portable, platform-independent access to hardware and software features that have become ubiquitous in modern applications development, such as objects, networks, and databases.
• IDL (Interactive Data Language) A programming language used for data analysis.
• Idris A dependently typed functional programming language.
• Iguana A parsing framework based on context-dependent grammars and top-down general context-free parsing.
• IL2CPU An AOT compiler for .NET IL code to compile to assembly language for direct booting; creates NASM style assembly ready to assemble with NASM.
• Ilograph Diagramming Language (IDL) Ilograph diagrams are defined using a the Ilograph Diagramming Language (IDL). IDL is a powerful, declarative, YAML-based language. Each Ilograph diagram defines its resources and perspectives in IDL.
• ILSpy Open-source .NET assembly browser and decompiler.
• Imp Imp is a simple, incomplete, interpreted, imperative programming language.
• Implementation Patterns A collection of patterns around language atoms.
• Inform6 A natural-language interactive fiction game development language and platform.
• Inform7 A natural-language interactive fiction game development language and platform.
• Inger a simple imperative programming language, much like C (only somewhat cleaner). Inger was developed to illustrate the process of building a compiler from scratch.
• Ink Storytelling language behind some popular games.
• Inko A statically-typed, safe, object-oriented programming language for writing concurrent programs. Thanks to the use of lightweight processes, concurrency is easily achieved and data races are impossible.
• Intercal The first esoteric programming language.
• Inweb Literate programming language used for Inform7 development.
• Io Inspired by Self, Smalltalk and LISP.
• Ioke A dynamic, strongly typed, prototype-based programming language with a very simple homoiconic syntax somewhat similar to Io.
• IronJS An ECMAScript 3.0 implementation built on top of the Dynamic Language Runtime from Microsoft which allows you to embed a javascript runtime into your .NET applications.
• IVy Language and tool for specifying, modeling, implementing, and verifying protocols.
• J (programming language) A high-level, general-purpose programming language that is particularly suited to the mathematical, statistical, and logical analysis of data.
• Janet 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 A super-small, super-fast Java compiler. It 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 same JVM.
• Jasmin An assembler for the Java Virtual Machine. It takes ASCII descriptions of Java classes, written in a simple assembler-like syntax using the Java Virtual Machine instruction set. It converts them into binary Java class files, suitable for loading by a Java runtime system.
• Jason A fully-fledged interpreter for an extended version of AgentSpeak, a BDI agent-oriented logic programming language.
• Java A statically-compiled, object-oriented language for the JVM.
• Javascript.NET .Net bindings to the V8 JavaScript engine.
• Javassist Java bytecode engineering toolkit.
• jcpp A complete, compliant, standalone, pure Java implementation of the C preprocessor. It is intended to be of use to people writing C-style compilers in Java using tools like sablecc, antlr, JLex, CUP and so forth.
• Jelly XML based scripting and processing engine for turning XML into executable code, usually for performing some sort of processing action.
• JESS (Java Expert System Shell) Rule engine language for Java based closely on CLIPS.
• JFlex A lexical analyzer generator (also known as scanner generator) for Java, written in Java.
• Jikes (Java compiler) A compiler that translates JavaTM source files as defined in The Java Language Specification into the bytecoded instruction set and binary format defined in The Java Virtual Machine Specification.
• jint Javascript Interpreter for .NET.
• Jinx Designed for use in realtime applications such as video games.
• JLex A Lexical Analyzer Generator for Java.
• JMPLib
• Join Java Language based on the join-pattern of join-calculus.
• Jolie A microservice/SOA programming language.
• Joule A message-based concurrent dataflow programming language, designed for building distributed applications.
• Joy A purely functional programming language based on composition of functions rather than lambda calculus.
• Julia A flexible dynamic language, appropriate for scientific and numerical computing, with performance comparable to traditional statically-typed languages.
• June What ordinary Java would look like if it were simpler.
• Jurassic A .NET library to parse and execute JavaScript code.
• JVM-based languages A collection of JVM-based languages and material
• JWEB System of literate programming.
• Jx9 An embeddable scripting engine that implements a Turing complete programming language based on JSON.
• Jython Python implementation on the JVM.
• Kaitai Struct A declarative language used to describe various binary data structures, laid out in files or in memory: i.e. binary file formats, network stream packet formats, etc.
• Katahdin A programming language where the syntax and semantics are mutable at runtime.
• Kawa A Scheme for the JVM (and one of the first at that).
• Keystone (Assembler) A lightweight multi-platform, multi-architecture assembler framework.
• Ki A Lisp for your JavaScript
• Kind A modern proof language.
• Kitten A statically typed concatenative systems programming language.
• Koka A function-oriented programming language that seperates pure values from side-effecting computations, where the effect of every function is automatically inferred; Koka has many features that help programmers to easily change their data types and code organization correctly, while having a small language core with a familiar JavaScript like syntax.
• Kotlin An object language originally for JVM and later adopted for Android.
• Kusto (query language) Query language for use with Azure Data Explorer.
• Langium An open source language engineering tool with first-class support for the Language Server Protocol, written in TypeScript and running in Node.js.
• Languages reading A collection of links and articles on different programming languages.
• LDPL A free, powerful, compiled, open-source programming language designed from the ground up to be excessively expressive, readable, fast and easy to learn.
• Lean A functional programming language that makes it easy to write correct and maintainable code.
• Learn X in Y Minutes Website collection of numerous "Learn You" style tutorials.
• Lemon An LALR(1) parser generator maintained as part of the SQLite project.
• Let's Build a Compiler (Jack Crenshaw) A very good tutorial on writing a simple compiler in 16 articles. By Jack W. Crenshaw.
• Lever A language that has capabilities to absorb features from other languages. Otherwise it is very generic purpose programming system with a hint of inclination towards interactive graphics and audio programming.
• Lightscript A Concise Syntax for JavaScript. A close superset of ES7 with JSX and Flow, built with Babel.
• Light Table (IDE) A Chromium-based IDE tool.
• Lily A programming language focused on expressiveness and type safety.
• Limbo A concurrent programming language for the Inferno operating system that was also an ancestor to Go.
• Lioness A high-level, dynamic, programming language designed for mathematical purposes.
• Lisa (Lisp-based Intelligent Software Agents) A production-rule system implemented in the Common Lisp Object System (CLOS), and is heavily influenced by CLIPS and the Java Expert System Shell (JESS).
• Lisp The original dynamic functional(ish) homoiconic (consistent symbology) language.
• Lists: Languages Collection of articles, books I recommend around general compilers/interpreters topics.
• Literate programming The prose-combined-with-code concept started by Knuth.
• literateprogramming.com A website dedicated to literate programming and documentation/code tools.
• LiveCode Commercial open-source cross-platform low-code (natural language expression) platform.
• LiveScript A language which compiles to JavaScript that has a straightforward mapping to JavaScript and allows you to write expressive code devoid of repetitive boilerplate.
• LLVM (toolchain) A collection of tools and libraries for building languages (and language-related tools).
• Lobster 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. While it is a general purpose language, its current implementation is biased towards games and other graphical things, with plenty of “batteries included” functionality.
• Logica A logic programming language that compiles to StandardSQL and runs on Google BigQuery.
• Logo The classic "turtle" language.
• Logtalk 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.
• LOLCODE Programming in l33tsp33k
• LOLCODE Specification (1.2) The 1.2 version of the LOLCODE language
• LPS (Logic Production Systems) Aims to close the gap between logical and imperative computer languages, by performing actions to generate models to make goals of the logical form if antecedent then consequent true. Model generation serves as a global imperative, which generates commands to make consequents true whenever antecedents become true.
• Lua Scripting language often embedded into game engines for extensibility.
• Lua VM Implementation docs and notes for the Lua virtual machine.
• Lush An object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications; 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.
• Lux Meant to be a functional, statically-typed Lisp that will run on several platforms, such as the Java Virtual Machine and JavaScript interpreters.
• Lys A language that compiles to WebAssembly.
• M (MUMPS: Massachusetts General Hospital Utility Multi-Programming System) A procedural language with a built-in NoSQL database; or, it’s a database with an integrated language optimized for accessing and manipulating that database.
• m4 A general-purpose macro processor (a text-replacement tool, employed to re-use text templates).
• Magpie A toy language interpreter, written in Go. It has C-style syntax, and is largely inspired by Ruby, Python, Perl and c#.
• Malbolge A programming language designed to be difficult (or impossible) to program in.
• Mantra (Might be a TParr class assignment?)
• Marco Safe, Expressive Macros for Any Language
• Marvin A programming language that was designed with DCI in mind. It builds heavily on C#. The first versions of Marvin can be seen as extensions to C# where versions in the road map will most likely reshape some of the fundamentals to provide even better support for DCI.
• MDL A programming language, a descendant of the language Lisp whose initial purpose was to provide high level language support for the Dynamic Modeling Group at Massachusetts Institute of Technology's (MIT) Project MAC.
• Memory Management and Garbage Collection (reading and references) Papers, books, and thoughts around manual and automatic memory management (GC).
• Mercury A logic/functional programming language which combines the clarity and expressiveness of declarative programming with advanced static analysis and error detection features. Influences from Prolog, ML, and Haskell.
• Message passing (reading) A mechanism of communication or control flow in which a block of data is explicitly constructed and communicated to the recipient.
• Mewl Program in cats' language.
• MewMew /ᐠ｡ꞈ｡ᐟ\ MewMew Programming Language - Program in Cats' Language
• MicroPython Implements the Python 3.4 syntax and some of the core datatypes.
• Microsoft Open Specifications Site A single site with many of Microsoft's Open Specification documents
• Min A Prototype-based language with syntax inspired by Io and Ruby, topped with Python's indentation (but only when you want to).
• miniKanren An embedded Domain Specific Language for logic programming.
• Minsk A handwritten compiler in C#, illustrating basic concepts of compiler construction.
• Mint A refreshing programming language for the front-end web.
• MIPS Assembly A brief overview of MIPS assembly.
• Mirah A programming language based on Ruby language syntax, local type inference, hybrid static–dynamic type system, and a pluggable compiler toolchain.
• Miranda A pure, non-strict, polymorphic, higher order functional programming language that later inspired Haskell.
• Mirth a new concatenative programming language, inspired by Forth, Joy, Haskell, Idris, Rust, Lisp, ATS, and monoidal category theory.
• Mistral An experimental language for distributed programming, with an emphasis on the specification and maintenance of a virtual overlay network.
• ML A strictly-functional language that later inspired OCaML and others.
• mobl A mobile application language and framework.
• Modeling Languages A website about modeling languages.
• Modern Compiler Implementation This book covers compiler theory, design, and implementation.
• Mond A scripting language for .NET Core.
• Monte A nascent dynamic programming language reminiscent of Python and E; it is based upon The Principle of Least Authority (POLA), which governs interactions between objects, and a capability-based object model, which grants certain essential safety guarantees to all objects.
• Moonscript A dynamic scripting language that compiles to Lua.
• Mouse A small computer programming language developed by Dr. Peter Grogono in the late 1970s and early 1980s; originally intended as a small, efficient language for microcomputer systems with limited memory; illustrates some of the concepts involved in creating a simple interpreter for a programming language.
• MPS (Meta-Programming System) JetBrains' language-development workbench and environment.
• Mu (Autodesk Graphics DSL/Shader language) Principally targeted towards computer graphics applications; over the years its syntax and runtime has been refactored and evolved from a simple shading language to a nearly full featured general language. However Mu is still probably best suited for computer graphics than other computing tasks.
• Mu (Scripting language) A lightweight scripting language designed to be easily embedded into existing projects.
• Mun A programming language empowering creation through iteration.
• Nanopass An embedded domain-specific language for creating compilers that focuses on creating small passes and many intermediate representations; reduces the boilerplate required to create compilers making them easier to understand and maintain.
• nasm (Netwide Assembler) A portable-ish assembler.
• Natalie A (work-in-progress) Ruby implementation, compiled to C++ (native).
• Neat A "D-lite" (subset of D) language.
• Neko (Language) A high-level dynamically typed programming language and virtual machine.
• Nelua Minimal, simple, efficient, statically typed, compiled, meta programmable, safe and extensible systems programming language with a Lua flavor.
• Nemerle A general-purpose, multi-paradigm programming language for the .Net platform; metaprogramming is based on macros bearing some similarity to Lisp.
• NetLogo A programming language and IDE for agent-based modeling as a dialect of Logo and emphasizing the decentralized, interconnected nature of the phenomena you can model.
• Never A statically typed functional programming language.
• Newspeak A language in the tradition of Self and Smalltalk, dynamic and reflective, but designed to support modularity and security.
• Niall An array language, like APL, J, or K, but with a more english-like syntax.
• Nice A new programming language that extends the ideas behind object-orientation in order to better support modular programming and static type safety and incorporates features from functional programming.
• Nim A compiled, garbage-collected systems programming language with a design that focuses on efficiency, expressiveness, and elegance (in that order of priority).
• Nix/NixOS/nixpkgs A tool that takes a unique approach to package management and system configuration.
• Node-RED An open-source flow-based development tool for visual programming developed originally by IBM for wiring together hardware devices, APIs and online services as part of the Internet of Things. Node-RED provides a web browser-based flow editor, which can be used to create JavaScript functions.
• Noisecraft Browser-based visual programming language and platform for sound synthesis.
• Notable Design Patterns for Domain-Specific Languages We describe eight recurring patterns that we have identified as being used for DSL design and implementation.
• Noulith Browser-based visual programming language and platform for sound synthesis.
• NRefactory Currently unmaintained parser/compiler frontend for C#.
• Nu An interpreted Lisp that builds on the Objective-C runtime and Foundation framework.
• nuweb A Simple Literate Programming Tool.
• Nylo A declarative programming language that takes some constructs from functional and logic paradigms, aims to be simple and clear, but powerful.
• nyx Dynamically typed scripting language.
• Oberon Predecessor to Pascal and a lot of concepts: Oberon, Oberon-2, Active Oberon, Modula-2/3, Oberon-07, and Component Pascal (Blackbox Oberon).
• Oberon+
• Object-capability model A capability describes a transferable right to perform one (or more) operations on a given object.
• Objective-C The other object-oriented take on C, based much more directly on the message-passing principles of Smalltalk.
• Objective-S Objective-S is the first general purpose programming language. It makes creating well-architected and efficient programs not only straightforward, but easy, fun and fast.
• ObjectScript A general purpose object-oriented programming language for the JVM.
• OCaml An object-functional hybrid language and platform.
• occam-pi Occam-pi and KRoC are the result of on-going research extending the (CSP) ideas of occam by judicious inclusion of the mobility features of the pi-calculus. In the interests of proveability, we have been careful to preserve the distinction between the original simple static point-to-point synchronised communication of occam and the dynamic asynchronous multiplexed communication of the pi-calculus; in this we have been prepared to sacrifice the elegant sparsity of the pi-calculus. We conjecture that the extra complexity (and discipline) introduced will make the task of proving concurrent and distributed programs easier.
• Octave (GNU Octave) GNU Matlab replacement/supplement/version.
• Odin Designed with the intent of creating an alternative to C around simplicity, high performance, built for modern systems, and joy of programming.
• OMeta (OMeta/JS) An object-oriented language for pattern matching, based on a variant of Parsing Expression Grammars (PEGs) which we have extended to handle arbitrary data types; OMeta's general-purpose pattern matching facilities provide a natural and convenient way for programmers to implement tokenizers, parsers, visitors, and tree transformers, all of which can be extended in interesting ways using familiar object-oriented mechanisms.
• OOC A small programming language with a clear and concise syntax that compiles to C99.
• Ook! A programming language designed for orang-utans.
• Opa An attempt at an "all-in-one" presentation, middleware, and storage system.
• Opal Ruby (hearts) JavaScript.
• Open Smalltalk Cross-platform virtual machine for Squeak, Pharo, Cuis, and Newspeak.
• Oxide An interpreted scripting language with a Rust influenced syntax.
• Oz (language) and Mozart (programming system) 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. Oz is a multiparadigm programming language including logic, functional (both lazy evaluation and eager evaluation), imperative, object-oriented, constraint, distributed, and concurrent programming.
• P A statically-compiled research language from Microsoft around explicit state machine management.
• P# A statically-compiled research language from Microsoft around explicit state machine management.
• Paka A language designed to be everything that the author wants in a language.
• Papers We Love A collection of academic papers gathered by a popular "user group" dedicated to reading through them.
• Parser (programming language) Scripting language used for web development and server-side scripting.
• Parser Construction Kit (PCK) Multi-input parser generator toolkit.
• Parsix High level parsing to ensure input is in the right shape and satisfies all constraints that business logic requires.
• Pascal (and Object Pascal) A procedural language with added object extensions popularized by Borland as Delphi.
• Pawn A curly-brace language with a small-footprint VM. Represents data as 4/8-byte "cells". Compiles to CPU-specific bytecode.
• Pepper An interpreted programming toy language that with a focus on simplicity and verbosity; dynamically-typed, built-in garbage collection, it's basically a weird hybrid between C, JavaScript and Python.
• Perl A language inspired by regular expressions--and it got worse from there somehow.
• Pharo A dynamic reflective pure object-oriented language supporting live programming inspired by Smalltalk.
• Phix An open source, self-hosted, interpreted or compiled programming language with a strong emphasis on simplicity and plain human-readable error messages.
• PHP Language designed for building web page generators/servers.
• Picat A simple, and yet powerful, logic-based multi-paradigm programming language aimed for general-purpose applications. (Pattern-matching, Intuitive, Constraints, Actors, Tabling)
• Piet A language where the programs are works of modern art.
• Pikachu
• Pineapple Pineapple is a language that focus on maintainability.
• Pipelines An experimental programming language for data flow.
• Pixie A small, fast, native lisp with "magical" powers.
• Pizza One of the original extension-languages to Java. Historical interest only.
• PL/0 Language Tools An implementation of PL/0 including a tree-based interpreter and virtual machine.
• Plaid A radical new programming language designed for the nascent age of concurrent, component-based computing incorporating typestate-oriented programming, concurrency by default, object model, linear type system with access permissions and integrated structural and nominal typing, and gradual typing.
• PlantUML Language for defining UML diagrams.
• Pluvo A functional and imperative programming language intended to be highly practical for scripting and CGIs, interpreted using a just-in-time compiler. Its hybrid dynamic and strict typing is flexible enough to allow duck typing. Its functions are, more specifically, closures, and it allows object orientation using prototypes.
• PLZoo (Programming Languages Zoo) The Programming Languages Zoo is a collection of miniature programming languages which demonstrates various concepts and techniques used in programming language design and implementation.
• Pocketlang A lightweight, fast, embeddable scripting language.
• Pogo, Pogoscript Little language that emphasizes readability, DSLs, and asynchronous primitives.
• Poly A general-purpose language based on the idea of treating types as first-class values.
• Polyglot Extensible compiler front end framework for language implementation on the JVM.
• Polylith A software architecture that applies functional thinking at the system scale. It helps us build simple, maintainable, testable, and scalable backend systems.
• Pony A statically-compiled research language from Microsoft around actors and concurrency.
• Portable Document Format (PDF) A cross-platform format for rendering pixel-correct pages.
• PostScript A dynamically typed, concatenative programming language page description language in the electronic publishing and desktop publishing business.
• Potassco (clingo, gringo, clasp, clingcon, aspcud, asprin) Potassco, the Potsdam Answer Set Solving Collection, bundles tools for Answer Set Programming (ASP), which offers a simple and powerful modeling language to solve combinatorial problems. With our tools you can concentrate on an actual problem, rather than a smart way of implementing it.
• Potion An object- and mixin-oriented (traits) language by _why the lucky stiff.
• PowerFX Low-code language
• PowerShell A proposed replacement for shell languages like bash.
• Pragma Pragma generates a GraphQL API based on your data models, authorization rules, and custom Javascript functions.
• Program analysis A collection of links around program analysis
• Programming Dojo This site was designed to improve the awareness of different programming languages.
• Programming Languages: Application and Interpretation Notes on the book.
• Programming Language sites/links A collection of language sites and links
• Programming Paradigms for Dummies: What Every Programmer Should Know Notes from the VanRoy paper.
• Prolog A recursive-cut, declarative, logic programming language.
• Prompto Platform and differing-syntax languages for cloud development.
• Prose A simple language inspired by Io and Ioke that compiles to Clojure and ClojureScript.
• PROSE Framework A framework of technologies for programming by examples: automatic generation of programs from input-output examples.
• PRQL (Pipelined Relational Query Language) A modern language for transforming data — a simple, powerful, pipelined SQL replacement.
• Pug A little language that compiles into the HTML. It has cleaner syntax with additional features like if statements and loops. It can also be used as a server side templating language for server languages like NodeJS.
• Punk-C A hacked version of C (on top of Lua) for use in the Witchcraft tool set.
• Pure 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 a C-based FFI.
• PureScript A strongly-typed language that transpiles to JavaScript.
• PuzzleScript A language/environment for creating turn-based, keyboard-controlled games where you're moving a thing, or several things around.
• Pyodide Python with the scientific stack, compiled to WebAssembly; may be used in any context where you want to run Python inside a web browser.
• PyPy A replacement for CPython, built using the RPython language that was co-developed with it.
• Python A dynamic language and platform.
• Q (Scripting Language) Q is a scripting engine that implements C-like language, compiler, and bytecode interpreter.
• Qore a modular, multi-threaded, SQL-integrated dynamically typed scripting language with optional hard typing and procedural and object-oriented features, powerful and easy-to-use data types, structures, and operators, a clean and easy-to-lean/read syntax.
• QuakeC/VM The language from the game Quake.
• Quick.Ref Cheat Sheets A collection of "cheat sheets"/quick-reference-guides for various tools and platforms and languages and ....
• R A free software environment for statistical computing and graphics.
• Racket Racket language/platform is a Lisp, but has numerous language implementations built on it.
• Raku Perl-themed object and functional language.
• RascalMPL An experimental domain specific language for metaprogramming, such as static code analysis, program transformation, program generation and implementation of domain specific languages.
• Raven-Lang An experimental programming language built (using ANTLR) for the JVM platform; the main goal of this project is to create a fast jvm language that lacks the verbosity of java while maintaining interoperability.
• Ravenscript A scripting language for the first-person team shooter game Ravenfield based on Lua.
• ReasonML A syntax over OCaml that is easier to get started for programmers who are familiar with C-style syntax like JavaScript.
• Rebol A lean, extensible platform that operates over a variety of operating systems and devices.
• Red 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
• Redex A great way to experiment with semantics, including reduction relations (roughly, the part of the semantics that says how the program runs) and type systems.
• Redline Smalltalk Smalltalk implementation for the JVM.
• Reflow A language and runtime for distributed, incremental data processing in the cloud.
• Regent (Regent-Lang) A language for implicit dataflow parallelism.
• ReoScript Sn ECMAScript-like script language runner for .NET applications. By using ReoScript, the application would be able to run own extended script library.
• Rescript A robustly typed language that compiles to efficient and human-readable JavaScript. It comes with a lightning fast compiler toolchain that scales to any codebase size.
• Rexx A structured, high-level programming language designed for ease of learning and reading.
• Rhai An embedded scripting language for Rust inspired by ChaiScript.
• Rick Roll A rickroll based, process oriented, dynamic, strong, esoteric programming language.
• Ring A language supporting Imperative, Procedural, Object-Oriented, Functional, Meta programming, Declarative programming using nested structures, and Natural programming.
• RISC-V Assembly Assembly language for the RISC-V architecture.
• RISC-V Reading A collection of resources and reading around the RISC-V CPU/assembly platform.
• RISC-V Software A collection of links to software (tools, libraries, etc) around the RISC-V CPU/assembly specification.
• Rivescript A RiveScript interpreter for JavaScript. RiveScript is a scripting language for chatterbots.
• RobotWar Links to games in which one programs a robot to do battle in an arena.
• Roc A fast, friendly, functional language.
• Rockstar A dynamically typed computer programming language, designed for creating programs that are also song lyrics.
• ROFLKODE An imperative, block structured, statically-typed programming language that is very similar to Adam Lindsay's language LOLCODE.
• Roy An experimental programming language that targets JavaScript. It tries to meld JavaScript semantics with some features common in static functional languages.
• RPython A translation and support framework for producing implementations of dynamic languages, emphasizing a clean separation between language specification and implementation aspects.
• Ruby A dynamic language.
• RuleML A unifying system of families of languages for Web rules specified, in part, through schema languages (normatively, in Relax NG) for Web documents and data originally developed for XML and later transferred to other formats such as JSON.
• RuneScript An in-house language that is currently being used for RuneScape content development; aims to create a compiler for that language based on pictures given by mods, along with an IDE that can be used to modify scripts or configs written in RuneScript and compile them to bytecode.
• Rust Native language intended to supplement or replace C/C++ someday.
• SAL (Source code Annotation Language) By using source code annotations, you can make the intent behind your code explicit. These annotations also enable automated static analysis tools to analyze your code more accurately, with significantly fewer false positives and false negatives.
• SASM Simple crossplatform IDE for NASM, MASM, GAS, FASM assembly languages
• Sather An object oriented language that has garbage collection, statically-checked strong typing, multiple inheritance, separate implementation and type inheritance, parameterized classes, dynamic dispatch, iteration abstraction, higher-order routines and iters, exception handling, assertions, preconditions, postconditions, and class invariants. Sather code can be compiled into C code and can efficiently link with C object files.
• Scala A functional/object hybrid for the JVM.
• Scalable Vector Graphics (SVG) An XML-based vector image format for two-dimensional graphics with support for interactivity and animation.
• Scheme Homoiconic dynamic functional(ish) language derived from Lisp.
• Scion A suite of software for standard state machine support.
• Scratch A fork of Google's Blockly project that provides a design specification and codebase for building creative computing interfaces.
• ScratchJr an introductory programming language that enables young children (ages 5-7) to create their own interactive stories and games.
• Scratch VM Virtual Machine used to represent, run, and maintain the state of programs for Scratch 3.0.
• SCXML (State Chart XML) State Machine notation for control abstraction specification.
• SDL (Specification and Definition Language) A specification language targeted at the unambiguous specification and description of the behaviour of reactive and distributed systems
• Seed7 A general purpose programming language transpiling to C and higher-level compared to Ada, C/C++ and Java.
• Self An object-oriented programming language based on the concept of prototypes.
• Selfie An educational software system of a tiny self-compiling C compiler, a tiny self-executing RISC-V emulator, and a tiny self-hosting RISC-V hypervisor.
• Semmle QL A declarative, object-oriented query language designed for program analysis.
• Senegal A powerful, small-but-fast, concurrent, class-based, and dynamically-typed programming language with a modern syntax.
• S-Expressions Abstract representations of an AST (among other things).
• SGScript Features include a built-in data serialization format, coroutines, class-based OOP, sandboxed evaluation, a built-in debugger and profiler.
• Shakespeare (Programming Language) Prithee, thou art desiring to program using Shakespearean English, art thou not?
• SILK (Simple Interpreted Language Kit) A .NET class library that makes it easy to add scripting and automation to your .NET applications.
• Silq A high-level quantum language.
• Skip (or Skiplang) A general-purpose programming language that provides caching with features like reactive invalidation, safe parallelism, and efficient garbage collection.
• Slate A prototype-based, multi-dispatch object-oriented language that runs from a highly-customizable live environment. The implementation is highly portable and relatively lightweight.
• Sleep A Java-based scripting language heavily inspired by Perl.
• Sling A general-purpose, object oriented programming language that is meant to be used for all kinds of software development targeting multiple platforms and different execution environments.
• Small Basic A stripped-down/"lean" version of Basic for learning programming.
• Smalltalk The original object-oriented programming language, emphasizing multiple inheritance and message-passing.
• SmallVM A small, simulated virtual machine with a 32-bit instruction set. It also comes with a simple programming langauge called G, which has a modern Go language-like syntax (almost a strict subset), and a C-like semantics and runtime.
• SmashTest An open-source tool and language for rapidly generating tests.
• SML.NET A compiler for the functional programming language Standard ML that targets the .NET Common Language Runtime and which supports language interoperability features for easy access to .NET libraries.
• SML# A programming language in the ML-family; seamlessly integrates (currently a subset of) SQL. Instead of providing built-in primitives to access database servers, SML# integrate SQL expressions themselves as polymorphically-typed first-class citizens.
• Software reading A collection of reading about software.
• Sorbet A fast, powerful type checker designed for Ruby.
• Spec# A formal language for API contracts, which extends C# with constructs for non-null types, preconditions, postconditions, and object invariants.
• Spider A programming language that compiles to JavaScript (ES5 and ES6 targets).
• Spoofax Language Workbench A platform for developing textual (domain-specific) programming languages.
• SPOON A metaprogramming library to analyze and transform Java source code; it parses source files to build a well-designed AST with powerful analysis and transformation API.
• Spry A Smalltalk and Rebol inspired language implemented as an AST interpreter in Nim.
• SQL (Structured Query Language) Standard language for querying (and updating) a relational database, originally intended for ad-hoc usage from an interactive prompt.
• SQLglot A no dependency Python SQL parser, transpiler, optimizer, and engine.
• Squeak Open-source Smalltalk system.
• Squirrel A high level imperative, object-oriented programming language, designed to be a light-weight scripting language that fits in the size, memory bandwidth, and real-time requirements of applications like video games.
• Stark A a safe and efficient system programming language seeking to be inspired by C# but not compatible.
• Starlark (formerly Skylark) A language intended for use as a configuration language, based on Python syntax.
• Static Program Analysis A collection of resources and readings on static program analysis
• Stencil A compiler that generates Web Components (more specifically, Custom Elements). Stencil combines the best concepts of the most popular frameworks into a simple build-time tool.
• Storyscript Magical coding language for tomorrow’s developer; the other 1 billion people not in GitHub.
• Storyteller Solutions for creating robust, human readable acceptance tests for your .Net or CoreCLR system and a means to create "living" technical documentation.
• Structure and Interpretation of Computer Programs (SICP) The classic treatise on the tiny barrier between code and data.
• Sugar A language to make JavaScript programming sweeter.
• Swift A second-generation object-oriented language with functional overtones.
• Swift FFI Swift Foreign Function Interface notes.
• Swift Playgrounds Swift Playgrounds are a combination of documentation and code in a interactive format (inside of XCode) or documentation (HTML).
• SwiftWasm Write Swift, compile to WASM/WebAssembly bytecode.
• Tabloid A minimal programming language inspired by clickbait headlines.
• TADS Authoring system for writing Interactive Fiction.
• Taichi Langauge for high-performance, sparse & differentiable graphics computing.
• tasm (Turbo Assembler) Borland's assembler for x86.
• Taxi A language for describing API's and their models.
• Taxi: The Programming Language Let's be honest here, what does a programmer fundamentally do? A programmer moves data from one memory location to another. In this respect, a programmer is not unlike a taxi driver, who moves people from place to place all day long. Introducting the Taxi Programming Languge!
• Tcl/Java Implementation of Tcl on the JVM.
• Tcl (Tool Control Language) A high-level scripting language vaguely object-like.
• TDL A prototype-based event-driven language with influences from ooc, Ruby, and Ioke.
• Teach Yourself Computer Science A collection of links for learning CS for those who didn't study it at school.
• Terra A low-level system programming language that is embedded in and meta-programmed by the Lua programming language.
• The Essence of Compiling with Continuations A paper on compilation using continuations as a key element.
• The Grand Unified Programming Theory: The Pure Function Pipeline Data Flow with Principle-based Warehouse/Workshop Model The Pure Function Pipeline Data Flow with Principle-based Warehouse/Workshop Model.
• The Witchcraft Compiler Collection A collection of compilation tools to perform binary black magic on the GNU/Linux and other POSIX platforms.
• Thyrd An experimental, reflective, visual programming language and environment. In Thyrd, both data and code are stored in cells situated in nested two-dimensional grids. The user interface animates the transition from a cell to its subordinate or superordinate grid to help keep the user oriented in the hierarchical grid structure. All operations the user can perform to edit the structure are implemented as operators in the Thyrd language, thus a Thyrd program can inspect and modify itself or other programs in the same space.
• Tidal (TidalCycles) A free/OSS that allows you to make (musical) patterns with code, whether live coding music at algoraves or composing in the studio.
• TinyBasic A family of dialects of the BASIC programming language that can fit into 4 or fewer KBs of memory.
• TinyC A considerably stripped down version of C and it is meant as a pedagogical tool for learning about compilers.
• TIScript A language that is a gentle extension of Javascript.
• Toit Python-inspired language for ESP32 microcontrollers.
• TopazRuby A high performance Ruby, written in RPython
• Tovie An Advanced Programming Language (Compiler + Interpreter + Transpiler ).
• Triton A language and compiler for writing highly efficient custom Deep-Learning primitives. The aim is to provide an open-source environment to write fast code at higher productivity than CUDA, but also with higher flexibility than other existing DSLs.
• Trygve Building a DCI-centric language from the ground up.
• Trylon Language which looks like a cross between Python and Smalltalk -- indentation is significant, expressions are like Smalltalk (but with operator precedence); object-oriented, garbage collected, compiles down to binaries via C.
• Turin A language built "for fun".
• TUTOR (programming language) Designed for use in computer assisted instruction (CAI) and computer managed instruction (CMI).
• Twine A language/platform for creating interactive fiction.
• Tycho A dynamically-typed language for the CLR designed for language-oriented programming.
• Types and type systems (reading) Reading and notes about types and type systems in programming languages (and related).
• TypeScript A superset of JavaScript with strong compile-time typechecking that transpiles to clean JavaScript output.
• Typhon A virtual machine for the Monte programming language.
• Umka A statically typed embeddable scripting language.
• Umple A modeling tool and programming language family for Model-Oriented Programming.
• Unison A modern, statically-typed purely functional language with the ability to describe entire distributed systems using a single program.
• Unlambda A programming language. Nothing remarkable there. The originality of Unlambda is that it stands as the unexpected intersection of two marginal families of languages: functional programming languages (like Scheme) and obfuscated programming languages (like Intercal). Unlambda uses a functional approach to programming: the only form of objects it manipulates are functions. Each function takes a function as argument and returns a function.
• Ur (Ur/Web) 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.
• V Simple, fast, safe, compiled language for developing maintainable software.
• Vala 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 (aka VLang, GelLLVM) An AOT compiled language that uses an entirely new approach to memory management: generational references, which have zero aliasing costs and no garbage collection pauses.
• VALE (Verified Assembly for Everest) A tool for constructing formally verified high-performance assembly language code, with an emphasis on cryptographic code.
• VAST A comprehensive integrated development environment (IDE) that works with a Smalltalk language runtime. Because it's Smalltalk-based, the IDE and the runtime are essentially a development 'image' that's executed by a virtual machine (VM).
• Verse Statically typed, concise syntax, classes, templates, const correctness, semi-functional style.
• Visual Basic (.NET) A largely-deprecated object-oriented programming language for the CLR.
• VMIR (Virtual Machine for Intermediate Representation) A standalone library written in C that can parse and execute WebAssembly (.wasm) files and LLVM Bitcode (.bc) files; optionally it can generate machine code (JIT) to speed up execution significantly.
• W A tiny procedural C-inspired compiler, built around machine word-size values.
• Wasp A programming language that understands what a web app is.
• Wasp Lisp A member of the Lisp-1 family, borrowing principles from R5RS Scheme, Python and Erlang. It is a pragmatic language, designed to provide developers with tools to rapidly build network applications that require sophisticated logic and quick turnarounds between prototype and production.
• WebC A serializer that generates markup for web components.
• WebDSL A DSL for building Web applications.
• Whenever A programming language which has no sense of urgency--it does things whenever it feels like it, not in any sequence specified by the programmer.
• Whiley An experimental programming language that combines features from the functional and imperative paradigms, and supports formal specification through function preconditions, postconditions and loop invariants.
• Whip Haskell-flavoured LISPish language thingy.
• Wing A cloud-oriented programming language that elevates the developer experience by combining infrastructure and runtime code, minimizing the complexity of the cloud.
• Wolfram Language A "knowledge-based" programming language.
• Wren Think Smalltalk in a Lua-sized package with a dash of Erlang and wrapped up in a modern syntax.
• Wu An expression oriented, gradually typed and mission-critical programming language.
• WyldCard A clone of Apple's HyperCard and HyperTalk scripting language.
• Wyvern A new programming language designed from the ground up to support highly productive development of secure software systems.
• X# xBase-based language for the CLR.
• X# (XSharp) A HLA (High Level Assembler) for X86/X64 (ARM coming) assembly language.
• X10 A statically-typed object-oriented language, extending a sequential core language with places, activities, clocks, (distributed, multi-dimensional) arrays and struct types; all this is motivated by the desire to use the new language for high-end, high-performance, high-productivity computing.
• x86/x64 Assembly The native assembly language of the Intel x86 family.
• x86 Talks A collection of links of talks/videos on x86 assembly.
• xlang A project from Microsoft enabling cross-language/platform API consumption
• Xtend A flexible and expressive dialect of Java, which compiles into readable Java 8 compatible source code.
• Xtext A framework for development of programming languages and domain-specific languages.
• YantraJS JavaScript Engine for .NET
• Yarnspinner A tool for creating interactive dialogue for games.
• Yarr A Lisp-based scripting language for .NET with many features borrowed from Common Lisp. It has numerous extensibility features, and can serve as the basis for domain-specific languages. Includes sample console and WPF applications showing how to host the Yarr runtime.
• YASL (Yet Another Scripting Language)
• Yasm Modular Assembler Project A complete rewrite of the NASM assembler.
• Yeti An ML-style functional language for the JVM.
• Ylang A universal dynamic tracing language that targets various dynamic tracing frameworks and toolchains.
• Yo A compiled programming language with strong static typing.
• Yoix A high-level, general-purpose, interpreted, dynamic programming language.
• Yorick An interactive programming language for scientific computing that includes scientific visualization functions, and text and binary I/O functions geared to millions of numbers.
• Zetavm Multi-Language Platform for Dynamic Programming Languages.
• Zhi# (ZhiSharp) An extension of C# with compiler and runtime support for XSD data types and Web Ontology Language (OWL).
• Zig Another C replacement nominee, that aims to have "no hidden functions".
• Zimbu Language experiment around wide-scope system-to-application programming.
• Zoem An interpretive macro/programming language.
• ZOMBIE A programming language designed for Necromancers, particularly evil ones. ZOMBIE is an acronym, and stands for Zombie-Oriented Machine-Being Interface Engine.

Last modified 14 April 2023

---

© 2020 Ted Neward | Mixed with Bootstrap v3.1.1 | Baked with JBake v2.6.5