A | B | C | D | E | F | G | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

_hyperscript: Small scripting language for the web. ("The underscore is silent.") (22 May 2024)

.NET Multi-platform App UI (MAUI): Build native apps using a .NET cross-platform UI toolkit that targets the mobile and desktop form factors on Android, iOS, macOS, Windows, and Tizen. (17 December 2022)

"/e/" OS: A mobile operating system that describes itself as being “forked from Android and completely ‘ungoogled.’” (03 October 2022)

"Auctions and bidding: A guide for computer scientists": A paper/slides/video on the different kinds of auctions. (06 April 2022)

"Grow Your Own BaaS": In this paper, the concepts of growing your own Backend-as-a-Service (BaaS) platform using vendor agnostic concepts are explored. The proposal is to define, architect, and design a heterogeneous micro-applications based platform. (31 December 2022)

"Old Agile vs New Agile": “When people say Agile today, they mean something different today than they did in 2001…it’s come to mean something else.” (09 December 2022)

"Serverless": The serverless architecture, usually implying smaller atoms of functionality executing on cloud servers. (01 July 2021)

0MQ (Zero-MQ): An open-source universal messaging library. (16 May 2020)

11 Promises From a Manager: Threads: Twitter threads of "11 promises" (22 December 2022)

3BC-Lang: Low-level language, tiny virtual machine, intermediate representation, embeddable, easy for beginners. (03 November 2022)

4: A completely emoji-based programming language. (05 February 2024)

49 Habits for Public Speaking Success: Collection of tips for public speaking. (25 November 2020)

4store: RDF database (01 July 2021)

50 Big Ideas: A collection of ideas that define our world. (26 April 2022)

50 Philosophy Ideas: A collection of philosophy ideas. (26 April 2022)

50 Psychology Ideas: A collection of ideas from psychology. (02 June 2023)

8Base: A Serverless GraphQL Backend-as-a-Service. (06 April 2022)

8 Pillars of Greek Philosophy: 8 core greek philosophies. (02 June 2023)

A+: A powerful and efficient programming language, embodying a rich set of functions and operators, a modern graphical user interface with many widgets and automatic synchronization of widgets and variables, asynchronous execution of functions associated with variables and events, dynamic loading of user compiled subroutines, and many other features. (30 May 2024)

aamachine: A virtual machine for delivering interactive stories. (01 July 2021)

ABC: An interactive programming language and environment for personal computing, originally intended as a good replacement for BASIC. (30 May 2024)

ABCL: An Object-Oriented Concurrent System, looking to exploit both parallelism and object orientation. (30 May 2024)

About: A page describing what this site contains and a little about how it is organized. (29 April 2020)

ABS: Programming language that works best when you're scripting on your terminal. (30 May 2024)

Accelerate: Embedded language for high-performance array computations. (30 May 2024)

Accento: An amazing combination of high-caliber conference and well-founded, hands-on trainings for experienced Java/web developers. (14 March 2023)

ACCEPT: An approximate compiler for C and C++ programs based on Clang. (30 May 2024)

A Compiler Writing Journey: Learn network programming and data structures by coding from scratch. (30 May 2024)

Acorn: A small, fast, JavaScript-based JavaScript parser. (17 January 2023)

Actian: Actian NoSQL (formerly Versant) object technology enables software developers to handle database requirements for extremely complex object models with ease and is used by the world’s largest companies for applications with very large scale data management requirements. Actian NoSQL doesn’t need mapping code to store or retrieve objects, so schema modifications can be handled without application downtime. Fault tolerance, synchronous and asynchronous replication, high availability and excellent scalability make Actian NoSQL ready for the enterprise. (06 April 2022)

Actionable Gamification: Beyond points, badges, and leaderboards. (20 December 2020)

ActionScript: Programming language for the Adobe Flash plugin for web browsers. (30 May 2024)

ActionScript VM: Actionscript virtual machine. (27 July 2021)

ActiveMQ: The most popular open source, multi-protocol, Java-based message broker. (06 April 2022)

ActivityPub: A decentralized social networking protocol based upon the ActivityStreams 2.0 data format; it provides a client to server API for creating, updating and deleting content, as well as a federated server to server API for delivering notifications and content. (21 December 2022)

ActivityStreams: Details a model for representing potential and completed activities using the JSON format; it is intended to be used with vocabularies that detail the structure of activities, and define specific types of activities. (21 December 2022)

Acton: A fault tolerant distributed programming platform for building mission critical systems. (30 May 2024)

Ada: General-purpose, strongly typed, performant, readable and safe language. (22 May 2024)

Ada++: An open source programming language aimed at making Ada more accessible. (26 May 2022)

Adalo: Mobile app-builder tool. (25 July 2021)

Adama: RDF database (09 December 2022)

Adaptable: GitHub-based cloud deployment. (01 February 2023)

Adept: A blazing fast language for general purpose programming. (30 May 2024)

adventurelib: Basic functionality for writing text-based adventure games, with the aim of making it easy enough for young teenagers to do. (10 May 2022)

Adversaries Into Allies: Win people over without manipulation or coercion (03 May 2022)

AdvSys: A Language for Writing Text Adventure Games (22 May 2024)

Aephea: Effective and adaptable HTML authoring. (06 April 2022)

Aeron: Efficient reliable UDP unicast, UDP multicast, and IPC message transport. (16 May 2020)

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. (30 May 2024)

Agda: Dependently typed functional programming language. (30 May 2024)

Agena: A procedural programming language suited to be used in scientific, mathematical, scripting, networking, and many other applications. (30 May 2024)

Agile Reading: A collection of links and articles on agile processes and mindset. (09 December 2022)

AIR: A cross-platform framework used by a wide range of applications and games. (26 February 2023)

Aith: Low level functional programming language with linear types, Generalized Inline Functions, levity polymorphism and regions. (30 May 2024)

Akavache: An asynchronous, persistent key-value store created for writing desktop and mobile applications, based on SQLite3. (30 May 2020)

Akihabara: A set of libraries, tools and presets to create pixelated indie-style 8/16-bit era games in Javascript that runs in your browser without any Flash plugin, making use of a small small small subset of the HTML5 features, that are actually available on many modern browsers. (06 April 2022)

Akka: A toolkit and runtime for building highly concurrent, distributed, and fault tolerant event-driven applications. (16 May 2020)

Akka.NET: A port of the Akka framework to the CLR. (23 December 2020)

Alan: Programming language that does concurrency for you and can thus separate how the software is written from how it runs. (30 May 2024)

Albatross: A Programming Language with Static Verification, a Proof Assistant, and a Theorem Prover. (30 May 2024)

Alda: A text-based programming language for music composition. (30 May 2024)

Alef: A concurrent programming language designed for the Plan 9 operating system from Bell Labs. (30 May 2024)

Aleo: Full-stack, secure applications with zero knowledge on layer 1. (22 May 2024)

Alice: Introductory programming language. (02 June 2021)

Alice (AliceML): A functional programming language based on Standard ML, extended with rich support for concurrent, distributed, and constraint programming. (30 May 2024)

Allegro: A cross-platform library mainly aimed at video game and multimedia programming. It handles common, low-level tasks such as creating windows, accepting user input, loading data, drawing images, playing sounds, etc. and generally abstracting away the underlying platform. (06 April 2022)

AlloyTools: Open source language and analyzer for software modeling. (02 January 2024)

Alore: Explores optional typing in a Python-like programming language. (30 May 2024)

Alpaca: Functional programming inspired by ML for the Erlang VM. (30 May 2024)

Alumina: An imperative, general-purpose, statically typed, compiled system programming language. (30 May 2024)

Amazon Dynamo: A fully managed NoSQL database service that provides fast and predictable performance with seamless scalability. DynamoDB lets you offload the administrative burdens of operating and scaling a distributed database so that you don't have to worry about hardware provisioning, setup and configuration, replication, software patching, or cluster scaling. (06 April 2022)

Amazon Ion: A richly-typed, self-describing, hierarchical data serialization format offering interchangeable binary and text representations. (30 May 2020)

Amazon Lumberyard: Amazon's game development engine. (30 November 2022)

Amazon S3 (and Glacier): Storage for the internet. (06 April 2022)

Amazon Web Services (AWS): Huge collection of cloud-hosted services. (03 October 2022)

Amethyst: Data-driven game engine written in Rust. (26 February 2023)

Amiga E: An object-oriented/procedural/unpure functional/whatever language with quite a popular implementation on the amiga. (30 May 2024)

AMPL: The most powerful and intuitive tool for developing and deploying complex optimization solutions in business & scientific applications. (30 May 2024)

Amplication: Open-source application development tool. (06 April 2022)

Amsterdam Compiler Kit: A cross-platform compiler and toolchain suite that is small, portable, extremely fast, and extremely flexible. It targets a number of low-end machines including the Z80, 8086 and 80386, but there are many other code generators available. It supports several languages, including ANSI C, Pascal and Modula-2, and contains integrated runtime libraries including a libc. The toolchain is mainly known as being the default toolchain for Minix 1 and 2. (19 May 2023)

Amulet: Simple functional programming language in the ML tradition, with support for higher-rank parametric polymorphic types and row-polymorphic records, pattern matching with algebraic data types, and tail recursion elimination. (30 May 2024)

Android: The Android mobile platform. (06 April 2022)

Android and Windows: A collection of links/articles on Android support in Windows (11). (06 April 2022)

Android Device Bus (adb): The Swiss-Army knife command-line tool for Android development against either emulator AVD or physical device. (04 January 2024)

Android Jetpack: Collection of Kotlin-based libraries for making Android development easier/faster/etc. (06 April 2022)

Android Jetpack Compose: The functional-composition way to build UIs in Android; "Jetpack Compose is Android’s modern toolkit for building native UI. It simplifies and accelerates UI development on Android". (08 March 2024)

Android OSS: A collection of Android OSS links. (06 April 2022)

Android Performance: Tools and practices for Android performance testing and tuning. (06 April 2022)

Android platform testing: Links and notes on how to unit- (and other) test on Android. (06 April 2022)

Android Security: Tools and practices for Android app security. (06 April 2022)

AngelScript: AngelScript is an extremely flexible cross-platform scripting library designed to allow applications to extend their functionality through external scripts. It has been designed from the beginning to be an easy to use component. (22 May 2024)

AngleSharp: A .NET library that gives you the ability to parse angle bracket based hyper-texts like HTML, SVG, and MathML. (01 January 2023)

Angular: Single-Page Application component-centric MVC-patterned framework for the browser. (06 April 2022)

ANI: Concurrent-by-default programming language. (30 May 2024)

Anko: Scriptable interpreter with syntax similar to Go. (18 November 2020)

Ant: A Java library and command-line tool whose mission is to drive processes described in build files as targets and extension points dependent upon each other. The main known usage of Ant is the build of Java applications. Ant supplies a number of built-in tasks allowing to compile, assemble, test and run Java applications. Ant can also be used effectively to build non Java applications, for instance C or C++ applications. More generally, Ant can be used to pilot any type of process which can be described in terms of targets and tasks. (01 July 2021)

Ant Design: A design system for enterprise-level products. (01 November 2020)

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. (22 May 2024)

Antimony: Language that gets out of your way. (30 May 2024)

ANTLR: Code-generating parser tool (01 November 2022)

Anvil: Build web applications using nothing but Python. (25 April 2022)

Anytype: A next-generation software that breaks down barriers between applications, gives back privacy and data ownership to users. (27 July 2021)

Apache.org: The Apache site is a collection of numerous open-source projects, in all stages of life (incubating, maintained, archived). (08 March 2024)

Apache Cordova: Mobile apps with HTML, CSS and JS (06 April 2022)

Apache Derby: Full SQL-compliant RDBMS written in Java. (14 March 2023)

Apache Isis: Provides apps with a standard, automatically generated UI. (01 July 2021)

Apache Jena: A free and open source Java framework for building Semantic Web and Linked Data applications. (01 July 2021)

Apache Polygene: (Retired) Composite Oriented Programming implementation. (06 April 2022)

Apache Pulsar: An open-source distributed pub-sub messaging system. (01 July 2021)

Apache Royale: A productive, open-source frontend application technology that lets you code in MXML and ActionScript3 and output to different formats. (05 July 2021)

Apache Thrift: The Apache Thrift software framework, for scalable cross-language services development, combines a software stack with a code generation engine to build services that work efficiently and seamlessly between C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, OCaml and Delphi and other languages. (11 July 2021)

Apache TinkerPop: A graph computing framework for both graph databases (OLTP) and graph analytic systems (OLAP). (30 May 2020)

Apache Usergrid: an open-source Backend-as-a-Service (“BaaS” or “mBaaS”) composed of an integrated distributed NoSQL database, application layer and client tier with SDKs for developers looking to rapidly build web and/or mobile applications. (19 May 2023)

Apache Wicket: An open source, component oriented, serverside, Java web application framework. (06 April 2022)

Apache XMLBeans: A technology for accessing XML by binding it to Java types. (19 May 2023)

Ape: Ape is an easy to use programming language and library written in C. It's an offspring of Monkey language, but it evolved to be more procedural with variables, loops, operator overloading, modules, and more. (24 May 2024)

Apeji PX: An object-oriented programming language extension for Java, intended to facilliate parallel computing on multi-core processors, GPU, Grid and Cloud. (02 June 2021)

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. (03 May 2022)

Apexlang: An interface definition language (IDL) for modeling software. Generate source code, documentation, integration, everything automatically. (30 May 2024)

APL: An array language, and one of the oldest programming languages still in use today, next to FORTRAN, Lisp and COBOL. (30 May 2024)

appery.io: A low-code tool for building presentation tiers. (16 May 2020)

AppGameKit: A game development engine, ideal for Beginners, Hobbyists & Indie developers. (11 May 2023)

AppHarbor: A fully hosted .NET Platform as a Service. (16 May 2020)

Appian: Enables developers to rapidly build solutions for enterprise business needs, such as defining applications that support a customer journey, optimize business operations, and enforce compliance with policies and regulations. (05 July 2021)

Application (mobile, web, desktop, whatever) ideas: A collection of collections of application development ideas. (18 May 2022)

AppSmith: An open source web framework for building internal tools, admin panels, dashboards, and workflows. Appsmith lets you drag-and-drop components to build dashboards, write logic with JavaScript objects and connect to any API, database or GraphQL source. (11 August 2021)

Appwrite: An open-source platform that provides web and mobile developers with a set of easy-to-use and integrate REST APIs to manage their core backend needs. (11 August 2021)

April: The APL programming language (a subset thereof) compiling to Common Lisp. (30 May 2024)

Aqua: An open-source language for distributed workflow coordination in p2p networks; Aqua programs are executed on many peers, sequentially or in parallel, forming a single-use coordination network. (30 May 2024)

AquaVM: Executes compiled Aqua, i.e., Aqua Intermediate Representation (AIR) scripts, and plays an integral role in the implementation of the Fluence peer-to-peer compute protocol; specifically, AquaVM allows expressing network choreography in scripts and composing distributed, peer-to-peer hosted services. (13 July 2023)

ArangoDB: Multi-model database (07 June 2021)

Arc: A new dialect of Lisp. (01 July 2021)

Arc (browser): Browser challenger to Chrome, Edge, etc. (15 January 2024)

Arcade: a modern Python framework for crafting games with compelling graphics and sound. (10 May 2022)

ArcadeDB: a conceptual fork of OrientDB, a multi-model database, one DBMS that supports SQL, Cypher, Gremlin, HTTP/JSON, MongoDB and Redis; also supports Vector Embeddings. (20 March 2024)

Archimate DSL: A DSL for generating Archimate diagrams from source. (06 April 2022)

Architectural Decision Records (ADR): An Architectural Decision Record captures a single Architectural Decision, such as often done when writing personal notes or meeting minutes; the collection of ADRs created and maintained in a project constitute its decision log. All of these are within the topic of Architectural Knowledge Management. (01 July 2021)

ARchive (file format): An early executable file format. (06 April 2022)

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. (02 June 2021)

Arend: Arend is a theorem prover and a programming language based on Homotopy Type Theory. (30 May 2024)

Argo: Pragmatic functional programming language. (30 May 2024)

Argon: An interpreted multi-paradigm dynamically typed programming language, with syntax is mainly influenced by Python, Go and Rust. (30 May 2024)

Argus: An extension of the CLU language, utilizing most of the same syntax and semantics, designed to support the creation of distributed programs, by encapsulating related procedures within objects called guardians, and by supporting atomic operations called actions. (12 June 2024)

Aria: Expressive, noiseless, interpreted, toy programming language. (30 May 2024)

Ark: Ark is a tiny, fast, and **somewhat** useful programming language focused on runtime stability and simple code syntax. (30 May 2024)

Ark: Systems programming language; goal is to a cleaner C without deviating from C's original goals of simplicity. (04 May 2020)

ArkScript: A small, fast, functional and scripting language for C++ projects. (18 November 2020)

ARM Assembly: ARM and AArch64 Assembly links (12 July 2023)

Armeria: Microservice framework for building any type of microservice leveraging your favorite technologies (gRPC, Thrift, Kotlin, Retrofit, Reactive Streams, Spring Boot and Dropwizard). (17 December 2022)

ART (Android RunTime): The VM engine for the Android platform that replaced Dalvik around Android 5/6. (06 April 2022)

Art of Game Design: An introduction to game design. (20 December 2020)

Art of the Start: Startup bible for many folks. (02 December 2022)

Art of UNIX Programming: How to build programs in the UNIX way. (06 April 2022)

Arturo: A "no-syntax" language running on top of a bytecode-VM. (22 January 2024)

as (GNU assembler): The GNU assembler. (06 April 2022)

ASCIIdoc: An authoring language for documentation that leverages "just" ASCII characters. (06 April 2022)

Aseba: Event-driven programming language for driving robots in an educational environment. (06 April 2022)

ASM.js: An extraordinarily optimizable, low-level subset of JavaScript. (06 April 2022)

AsmL: Abstract State Machine Language, an executable specification language based on the theory of Abstract State Machines. (24 August 2021)

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. (04 May 2020)

ASP.NET/ASP.NET Core: Microsoft's HTML/HTTP server-side framework. (06 April 2022)

AspectC++: A strongly-typed aspect-oriented programming language starting from C++. (01 November 2020)

AspectJ: A strongly-typed aspect-oriented programming language starting from Java. (01 November 2020)

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. (06 April 2022)

Assembly language (generic): Collection of assembly language resources that don't fit in one of the other categories. (06 April 2022)

AssemblyScript: A TypeScript-like language for WebAssembly. (06 April 2022)

Asteria: A procedural, dynamically typed programming language that is highly inspired by JavaScript but has been designed to address its issues. (05 February 2024)

Astro: Fun safe language for rapid prototyping and high performance applications. (22 May 2024)

Astro: The web framework for content-driven websites. (08 March 2024)

Astro: Multiparadigm language with Python syntax compiling to WASM and native code (06 April 2022)

Asymptote: Descriptive vector graphics language that provides a natural coordinate-based framework for technical drawing. (04 May 2020)

AsyncAPI.NET: A useful object model for AsyncAPI documents in .NET (24 February 2023)

Async API (standard): Open source tools to easily build and maintain your event-driven architecture, powered by the AsyncAPI specification, the industry standard for defining ascychronous APIs. (01 July 2021)

Asynchronous Javascript And XML (AJAX): A term coined that describes an approach to using HTML or XHTML, CSS, JavaScript, DOM, XML, XSLT, and most importantly the XMLHttpRequest object to make quick, incremental updates to the UI without reloading the entire browser page. (30 May 2020)

Atom: A programmable, register based virtual machine for Win32 computers. (30 May 2024)

Atom (text editor): The hackable text editor. (15 December 2022)

Atomic Game Engine: A multi-platform 2D and 3D engine with a consistent API in C++, C#, JavaScript, and TypeScript. (30 December 2022)

Atomic Habits: Notes from the book. (02 June 2023)

ATS: Statically typed programming language that unifies implementation with formal specification. (30 May 2024)

Atto: Insanely simple self-hosted functional programming language. (30 May 2024)

Aucoda: A "meta-compiler" that can take Au source and transpile to a different application language/platform. (11 August 2021)

Aurora: A language that can accept not only text but symbols (formulae, etc) as input. (06 April 2022)

Austral: Systems language with linear types. (30 May 2024)

Authelia: Single Sign-On Multi-Factor portal for web apps. (24 May 2024)

AutoHotKey: The ultimate automation scripting language for Windows. (06 April 2022)

AutoIt: A freeware BASIC-like scripting language designed for automating the Windows GUI and general scripting. (30 May 2024)

Autotools: Portable build system used extensively in the GNU software suite. (30 May 2021)

Avail Programming Language: Multi-paradigmatic general purpose programming language (and environment) emphasizing support for articulate programming. (24 August 2021)

Avalonia: A cross-platform .NET UI framework that supports all the major platforms. (06 April 2022)

Avatar-2: An open source framework for dynamic instrumentation and analysis of binary firmware (01 July 2021)

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. (06 April 2022)

Awesome (lists) (Project Awesome): A curated collection of lists. (06 April 2022)

Awesome Programming Language Articles: (11 May 2024)

Awk: Tool for text processing and manipulation. (24 May 2024)

Axum: Discontinued MSR project to explore concurrency and channels as a direct part of the language. (06 April 2022)

Azure: Huge collection of cloud services. (06 April 2022)

Azure DevOps: A collection of Azure tools for managing software development pipelines. (18 May 2022)

Azure Messaging: A collection of Azure messaging-related links. (03 October 2022)

B4X: A modern version of Visual Basic for multiple platforms. (24 August 2021)

Babel: A transpiler for writing next generation JavaScript. (17 January 2023)

BabylonJS: Open-source Web-centric game engine. (12 October 2023)

Back4App: Parse backend hosting. (06 April 2022)

Backdoor Factory (BDF): Patch PE, ELF, Mach-O binaries with shellcode (16 May 2020)

Backlang: A new Rust, C# inspired Language for .Net (24 May 2024)

Backstage: An open platform for building developer portals. (01 January 2023)

Bagel: Statically typed, reactive language with pure and impure functions. (22 May 2024)

BAIK: BAIK is a scripting language which syntax is in Indonesian for Windows and Linux on Server, Desktop, Laptop and Embedded Computer, including IoT. It supports GPIO, Animation, PDF, UTF8, Printer, OOP, GUI, CGI, Databases, Graphics and TCP/IP. (24 May 2024)

Bait: Bait is a compiled general purpose programming language with a simple syntax but still powerful feature set and standard library for building reliable software. (24 May 2024)

Ballerina: A service-oriented programming language. (21 December 2022)

Barb: A small dynamic scripting language for .NET. (07 June 2021)

Barn: Barn is a simple programming language written in GoLang and compiled to C++. Syntax is very simple, and Barn can call C/C++ functions natively so creating new bindings should be easy. Barn was written with the goal of being as fast and easy to use as possible. Barn is just a little project with which I can chill and just code. (24 May 2024)

Baserow: Open source no-code database and Airtable alternative. (24 November 2023)

bash (command-line shell): Command-line shell and associated shell-scripting language. (08 July 2023)

Basic (and variants): Various notes and implementations of the BASIC programming language. (30 May 2024)

Basic Computer Games: A collection of simple games from a book published in the early 80s. (17 December 2022)

Basil: Fast and flexible language exploring partial evaluation, context-sensitive parsing, and metaprogramming. Compiles JIT or AOT to native code. (22 May 2024)

Bastard Operator From Hell (BOFH): Darkly humorous tales of truly evil sysadmins. (06 April 2022)

Batakjava: Implementation of Java with multi-versioned classes. (11 May 2024)

Batsh: A language that cross-compiles to bash and Windows batch command-line shell-scripting languages. (24 August 2021)

Battlesnake: A multi-player programming game played by developers all over the world. All you need to play is a live web server that implements the Battlesnake API. (06 April 2022)

Bazel: A fast, scalable, multi-language, extensible build system. (01 July 2021)

BBolt: An embedded key/value database for Go. (11 May 2024)

BBytes: An interesting collection of links, which partly served to inspire this website itself. (10 May 2020)

BCPL: BCPL ("Basic Combined Programming Language") is a procedural, imperative, and structured programming language. A stripped down and syntactically changed version of BCPL, called B, was the language on which the C programming language was based. BCPL introduced several features of many modern programming languages, including using curly braces to delimit code blocks. (24 May 2024)

BDE Verify: A Static Checker for C++ (01 July 2021)

Beads: The Beads project is a daring attempt to generate a new language that will replace the current popular toolchain stack of HTML/CSS/JS/+Frameworks+Database, with a single language. (24 May 2024)

BEAM (Erlang platform): Platform and virtual machine for Erlang and other languages. (10 May 2020)

BEAM VM: Erlang virtual machine low-level details (06 April 2022)

BeanShell: Object-ish scripting language early to the JVM. (01 November 2020)

Beef: An open source performance-oriented compiled programming language which has been built hand-in-hand with its IDE environment. (06 April 2022)

Beehive: An open source event and agent system, which allows you to create your own agents that perform automated tasks triggered by events and filters. It has modules to interface with, talk to, or retrieve information from Twitter, Tumblr, Email, IRC, Jabber, RSS, Jenkins, Hue etc. (24 August 2021)

Beej's Guide to Network Programming: Intro to C-level sockets (TCP/IP, UDP/IP) programming. (30 March 2021)

Behind Closed Doors: The Secrets of Great Leadership. (06 April 2022)

Beluga: Functional programming language designed for reasoning about formal systems. (22 May 2024)

Bend: A massively parallel, high-level programming language. (22 May 2024)

BerkeleyDB: Embedded file-based storage system. Sort of a SQLite before SQLite was popular. (06 April 2022)

Berry: A ultra-lightweight embedded scripting language optimized for microcontrollers. (24 May 2024)

Beryl: Beryl is a small, interpreted, embeddable scripting language with value semantics and first class functions. The main feature of Beryl is that the core interpreter can run without any dynamic memory allocation*, and it does not need to parse or compile scripts beforehand. It can also be built without any external dependencies, excluding some typedefines and constants needed from stddef.h and limits.h; however these could be provived from a custom header if needed. (24 May 2024)

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. (06 April 2022)

Bevy: A refreshingly simple data-driven game engine built in Rust. (06 April 2022)

Bflat: A native compiler for C# that comes with everything you need to build C# apps for any of the supported platforms. (03 January 2023)

Bhl: BeHavior Language is a strictly typed programming language specifically tailored for gameplay logic scripting. (24 May 2024)

Bicep: A domain-specific language (DSL) that uses declarative syntax to deploy Azure resources. (06 April 2022)

Bigbone: BigBone - A Mastodon Client Library for Java and Kotlin. (29 June 2023)

Bildr: All-in-one platform for visual web app development. The full stack is handled so you can focus on building with all the powers of a seasoned developer at hand. (01 July 2021)

bingrep: Greps through binaries from various OSs and architectures, and colors them (ELF, Mach-O, PE) (16 May 2020)

binwalk: A fast, easy to use tool for analyzing, reverse engineering, and extracting firmware images. (24 February 2023)

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. (03 November 2022)

bison: Classic implementation (of yacc) for language development (06 April 2022)

Bit: An open-source standard infrastructure for web components. (01 July 2021)

Bite: Bite is a dynamically typed, object oriented programming language. Dynamically typed, because the type of the content of a variable can change during runtime of the program. Object-oriented, because you can define classes to encapsulate your code and data. Bite uses modules, classes and functions to separate code. (24 May 2024)

Bitsy: the best language to implement when writing your first compiler or interpreter. (13 June 2023)

B-Juliet: β-Juliet is a fairly minimal event-oriented language. In β-Juliet, the world is modelled as a set of events which have no inherent organization or order. Each event can be denoted with a symbol, such as DominoFalls, CatMeows, or SunSets, or (in version 2.0) a string of symbols, such as Address Line Six Goes High or Greengrocer Falls Asleep on Subway. Each event can cause other events to occur — these are termed consequences of the event. In addition, this causation may be conditional, but the only condition that is possible to check is: given two events, which one happened more recently? (24 May 2024)

BL: The Biscuit Language (BL) is simple imperative programming language using LLVM backend implemented in C. Biscuit is designed to be simple, fast and explicit. Language syntax is inspired by JAI. (24 May 2024)

Bla: We investigate an (unpure) functional language whose concept of environment is not implicit as in traditional languages, but made available explicitly as a first class value. This results in a semantics for environments that is best known from the object oriented paradigm, and gives us a united function/class concept in a very orthogonal way. We also look at the language as a real-world general purpose language, considering semantics (of type-inference, for example), implementation issues, and practical experience in using the compiler. (24 May 2024)

Blade: A simple, fast, clean, and dynamic language that allows you to develop applications quickly. (12 July 2023)

BlazeX: AOT compiled object oriented programming language. (22 May 2024)

Blech: Blech is a language for developing reactive, real-time critical embedded software. (24 May 2024)

BlitzJS: A zero-API approach to connecting your Next.js front end to the back-end datastore. (26 February 2023)

BlitzMax: BlitzMax is a fast cross-platform, open-source programming language. (24 May 2024)

Bloaty McBloatface: A size profiler for binaries (ELF, Mach-O) (16 May 2020)

Blockchain reading: A collection of resources on blockchain. Mostly for pedagogical purposes; thus far I have found no practical use for one. (29 June 2023)

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. (01 July 2021)

Blocs: Component-based visual website builder. (05 July 2021)

BLOG: A probabilistic modeling language, designed for representing relations and uncertainties among real world objects. (05 February 2024)

Bloodshed Compilers: Collection of compilers resources (06 April 2022)

Blue: The Blue Programming Language, A powerful, V E R Y Easy to use language, that can compile to eight of your favourite languages. A compiled, dynamically typed, object oriented programming language. Coming in at only 30 keywords, this is an easy to use language with unseen compiler speed. Blue is extremely powerful thanks to it's small, compact, file size. It was written in only 3200 lines of Haxe code. (24 May 2024)

Boardgame.io: An engine for creating turn-based games using JavaScript. (06 April 2022)

Bob: Bob is a simple object-oriented scripting language. Bob’s syntax is similar to C or C++ but it is dynamically typed and has automatic memory management. (24 May 2024)

Bob2: Revised version of Bob derived from the Nuon work at VM Labs (24 May 2024)

Boba: A general purpose statically-typed concatenative programming language. Key features include: Expressive, mostly implicit static types and kinds. Language-incorporated unit and property tests + runners. Algebraic effects via scoped effect handlers. Algebraic data types and pattern matching on constructors. Compile-time resolved function overloading. Structurally typed tuples, records and variants. Byte-code VM-in-Go backend with straight-forward first-order FFI access. Familiar looping, branching, and variable definition syntax constructs (24 May 2024)

Bochs: A portable IA-32 and x86-64 IBM PC compatible emulator and debugger mostly written in C++; it supports emulation of the processor, memory, disks, display, Ethernet, BIOS and common hardware peripherals of PCs. (01 July 2021)

Bog: Small, strongly typed, embeddable language. Written in Zig. (22 May 2024)

Bolin: A general purpose language that is: Designed to be readable; Automatic memory management (no gc, no rc); Has features not found in any other language (See a few on the highlights page); Matches C execution speed, occasionally Bolin is faster; Has a more optimal standard library; Compiles 2.5 million lines per second on a laptop (MacBook Air with an M2 chip). (24 May 2024)

Bolt: Research language with finer-grained concurrency than Rust. (22 May 2024)

Bolt: An embedded key/value database for Go. (11 May 2024)

Bolt protocol: A highly efficient, lightweight client-server protocol designed for database applications. (30 May 2020)

Bolts Framework(s): A collection of low-level libraries designed to make developing mobile apps easier. (01 July 2021)

Bond: An open-source, cross-platform framework for working with schematized data, supporting cross-language serialization/deserialization and powerful generic mechanisms for efficiently manipulating data. (11 May 2024)

BondLayer: Visual website and mobile app builder. (05 July 2021)

BonitaSoft: Reinvent and automate your business processes with the Bonita open source Digital Process Automation platform. Deliver automation projects rapidly and continuously and increase visibility for insights to improve your processes. (06 April 2022)

Boo: Object-oriented language for the CLR incorporating Python-style syntax. (24 August 2021)

Boomerang: A general, open source, retargetable decompiler of machine code programs. (06 April 2022)

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. (04 May 2020)

Boomi Flow: Caters to automation use cases, mobile applications, embedded workflows, and organizational collaboration. (05 July 2021)

Boost: Wide-ranging collection of C++ templates and tools. (16 May 2020)

Boost.Build: Build system first used in C++ Boost library. (01 July 2021)

bore: bore is a simple CLI tool for making tunnels to localhost. (04 May 2022)

Borealis: Borealis is a small, elegant and consistent scripting language. Includes a C-like syntax that's easy to implement. (24 May 2024)

Boron: An embeddable scripting language similar to Rebol. (24 May 2024)

BorrowScript: Combining TypeScript with Rust's borrow-checker (therefore requiring no GC). (06 April 2022)

Bosatsu: Python-ish pure and total functional programming language. (22 May 2024)

Boson: A hybrid programming language written in Rust. (13 July 2023)

Bosque: A language rethinking intermediate representation/bytecode to be more tool-friendly. (30 May 2024)

Bottles: An application that allows you to easily manage windows prefixes on your favorite Linux distribution. (06 April 2022)

Box2D: Classic physics engine developed by Erin Catto and ported almost everywhere. (06 April 2022)

BoxyHQ: Collection of security APIs/services for security and privacy. (29 December 2023)

BoxyHQ: Security building blocks for developers. (29 December 2023)

BQN: An APL-like programming language. Self-hosted! (24 May 2024)

Braid: Functional language with Reason-like syntax that compiles to Go. (22 May 2024)

Brain: Brain is a high-level, purely object-oriented, prototype based scripting language, mostly similar to the Self language. (24 May 2024)

Brainfuck: The classic esoteric programming language. (13 July 2023)

Brain Rules: Rules for how the brain works. (02 June 2023)

Breeze (BreezeJS, Breeze#): Rich data for Javascript apps. (01 July 2021)

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. (06 April 2022)

Bright ML: Statically-typed programming language based on "F-ing modules". (30 May 2024)

BrightstarDB: A native RDF database for the .NET platform. (07 June 2021)

BRL: The Beautiful Report Language. A language designed for server-side WWW-based applications, particularly database applications. It is based on Scheme, which makes the syntax extremely simple yet powerful. This implementation is a Java Servlet using the Kawa Scheme compiler. (24 May 2024)

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. (01 July 2021)

Browsers (Web): Standardized web browser programming. (05 July 2022)

Brython: A Python 3 implementation for client-side web programming. (24 May 2024)

bsdutils: Alternative to GNU coreutils using software from FreeBSD. (29 June 2023)

Bubble: Web application builder. (05 July 2021)

Budibase: An open-source low code platform that helps you build and self-host internal tools in minutes. (06 April 2022)

Buffalo: A Go web development eco-system, designed to make your life easier. (24 November 2023)

Build2: C++ build toolchain. (01 July 2021)

Builder: Drag and drop page builder and CMS. (06 April 2022)

Build tools and research: A collection of links around building, build systems, and build performance optimization (01 July 2021)

Build Your Own redis: Learn network programming and data structures by coding from scratch. (30 December 2023)

Build-Your-Own-X: A collection of links on how to build various things as a learning exercise. (08 July 2023)

Bulfinch: Just a little toy language to learn about register-based VMs. (24 May 2024)

Business metrics: Some concepts/ideas/links around metrics for businesses. (08 January 2023)

Business Reading: A collection of articles and links on the business side of life. (29 June 2023)

Butler: A virtual operating system (written in Haskell) that runs multi-players applications on the web. (22 January 2024)

Butter: Aims to be a concise and friendly language for building efficient software. (22 May 2024)

buzz: Small/lightweight typed scripting language written in Zig. (22 May 2024)

Buzz2: A small/lightweight statically typed scripting language written in Zig. (24 May 2024)

Byte Buddy: A library for creating and modifying Java classes during the runtime of a Java application and without the help of a compiler. (01 July 2021)

Bytecode Alliance: A nonprofit organization dedicated to creating secure new software foundations, building on standards such as WebAssembly and WebAssembly System Interface (WASI). (27 September 2022)

Byzer: A low-code open-source programming language for data pipeline, analytics and AI. (05 February 2024)

C: General-purpose, imperative, supporting structured programming, lexical variable scope and recursion, while a static type system prevents many unintended operations. (22 May 2024)

C-- (C-minus-minus): A subset of C specifically aimed to make it useful as a high-level assembly language. (26 May 2022)

C#: A statically-compiled, object-oriented language for the CLR. (06 April 2022)

C++: An object-oriented flavor of C. (01 January 2023)

C++/CLI: An adaptation of C++ to the CLR platform; successor to "Managed C++". (24 August 2021)

C++11 Language Features: C++ 2011 version (30 March 2021)

C++14 Language Features: C++ 2014 version (30 March 2021)

C++17 Language Features: C++ 2017 version (30 March 2021)

C++20 Language Features: C++ 2020 version (30 March 2021)

C++ atomics, lock-free libraries and tools, and the memory model: A collection of readings and research on C++ memory model and related concurrency/synchronization concepts. (15 May 2020)

C++ Error handling: A collection of links and reading on the specific ways C/C++ do error-handling. (09 December 2022)

C++ FFI: Some notes and details on how C++ can call native bindings. (06 April 2022)

C++ Standards: C++ Standards links (30 March 2021)

C2: Evolution of C. (30 May 2024)

C3: Clipper Compatible Compiler: An xBase language compiler for 16, 32 and 64 bits. (30 May 2024)

c3c: A C-like language trying to be "an incremental improvement over C" rather than a whole new language. (30 May 2024)

Cadence: Fault-Tolerant Stateful Code Platform (06 April 2022)

Cadl: A language for describing cloud service APIs and generating other API description languages, client and service code, documentation, and other assets. (15 December 2022)

CafeOBJ: A language for writing formal (i.e. mathematical) specifications of models for wide varieties of software and systems, and verifying properties of them. (30 May 2024)

Cairo: A programming language designed for a virtual CPU of the same name, which presents a unique aspect, that it was not created for the physical constraints of our world but for cryptographic ones, making it capable of efficiently proving the execution of any program running on it. (05 February 2024)

Caja: A JavaScript implementation for "virtual iframes" based on the principles of object-capabilities. (01 July 2021)

Cake (C# Make): A free and open source cross-platform build automation system with a C# DSL for tasks such as compiling code, copying files and folders, running unit tests, compressing files and building NuGet packages. (06 April 2022)

Cakelisp: A metaprogrammable, hot-reloadable, non-garbage-collected language ideal for high performance, iteratively-developed programs (especially games). (30 May 2024)

CakeML: CakeML is a verified implementation of a significant subset of Standard ML. (30 May 2024)

Cal: Scheduling infrastructure for everyone. (29 December 2023)

CAL / OpenQuark: A lazy functional programming framework and language for the JVM. (01 November 2020)

Calcit: Calcit is an interpreter built with Rust, and also a JavaScript code emitter. It's inspired mostly by ClojureScript. Calcit-js emits JavaScript in ES Modules syntax. (24 May 2024)

CalDAV: Defines extensions to the Web Distributed Authoring and Versioning (WebDAV) protocol to specify a standard way of accessing, managing, and sharing calendaring and scheduling information based on the iCalendar format. (06 April 2022)

Caledon: Dependently typed, polymorphic, higher order logic programming language. (22 May 2024)

Callisto: A minimalist language on "versioned objects". (30 March 2021)

Calypso: Mostly imperative language with some functional influences that is focused on flexibility and simplicity. (22 May 2024)

Camelot: Camelot is a language of the ML family. It is strict, first-order but allows for use-only higher-order functions. It includes object-oriented extensions, mainly for creating and using objects in an existing class hierarchy. Programmers familiar with ML or Ocaml should have no problems understanding the basic language promitives. ` (30 May 2024)

Cane: A small vector language designed for making beats with realtime MIDI. (22 May 2024)

Canopy: A PEG parser compiler. (30 May 2024)

Cant: Programming language descended mainly from E and Scheme. (22 May 2024)

Capacitor: An open source native runtime for building Web Native apps. (25 February 2023)

CapacitorJS: Capacitor turns any web app into a native app so you can run one app across iOS, Android, and the Web with the same code. (01 July 2021)

Capstone (Disassembler): A disassembly/disassembler framework. (06 April 2022)

Capsule: A fast and lean implementation of a family of hash-trie-based collections (sets, maps). (10 May 2020)

Carbon: An experimental successor to C++. (03 October 2022)

Carp: A statically-typed lisp, without a GC, for real-time applications. (15 November 2020)

Casanova: A declarative programming language for games, derived from F# and has full Unity integration. (01 July 2021)

Cascading StyleSheets (CSS): Collections of reading and links on the second triad of the HTML/CSS/JS browser layer. (19 May 2022)

Caspio: Helps businesses build custom applications by optimizing customer experiences and internal workflows. (05 July 2021)

Cassandra: An open source NoSQL distributed database trusted by thousands of companies for scalability and high availability without compromising performance. Linear scalability and proven fault-tolerance on commodity hardware or cloud infrastructure make it the perfect platform for mission-critical data. (06 April 2022)

Cassette: A new evolutionary highlevel and readable tape language (unlike brainf), with pattern matching, arity overloading, modules, lambdas (rather quotes) and much more; All topped on with a simple and aesthetic syntax. (24 May 2024)

Castile: A simple imperative language with union types (and a compiler for same, with multiple targets) (24 May 2024)

Castled: Data synchronization framework focused on external apps. (06 April 2022)

Cat: A statically typed functional stack-based programming language inspired by Joy. (01 July 2021)

Cat9: Cat9 is a user shell script for LASH - a command-line shell that discriminates against terminal emulators, written in Lua. You probably have not heard of LASH before. If you really must know, check the Backstory section below. LASH just provides some basic shared infrastructure and a recovery shell. It then runs a user provided script that actually provides most of the rules for how the command line is supposed to look and behave. (24 May 2024)

Catala: A programming language for the law. (06 April 2022)

Category Theory: A collection of links on category theory. (09 December 2022)

cave_miner: Search for code cave in binaries (ELF, Mach-O, PE), and inject code in them (16 May 2020)

Cayley: An open-source database for Linked Data inspired by the graph database behind Google's Knowledge Graph (formerly Freebase). (30 May 2020)

CaylixOS: A mobile operating system with greater emphasis on security. (03 October 2022)

Cecil: A library to generate and inspect programs and libraries in the ECMA CIL form. (17 December 2022)

Cedar: A language for defining permissions as policies, which describe who should have access to what, and a specification for evaluating those policies. (22 January 2024)

Cell: Flexible entirely-structural type system, orthogonal persistence, transactions, integrating with primary language (C++, Java, C#). (04 May 2020)

Cello (libcello): A library that brings higher level programming to C. (06 April 2022)

Cellular Architecture: Utilizing cellular principles in an architecture. (?) (11 May 2024)

Cerbos: Authorization as a service (or library), decoupled from actual code. (07 February 2023)

Cesium: A C compiler for the CLR. (06 April 2022)

Ceu: Reactive language that aims to offer a higher-level and safer alternative to C. (22 May 2024)

Céu: Céu is a reactive language that aims to offer a higher-level and safer alternative to C. (24 May 2024)

Ceylon: An object-oriented, strongly statically typed programming language with an emphasis on immutability. (01 November 2020)

CFML (Cold Fusion Markup Language): A scripting language for web development. (10 May 2020)

CGLib: high level API to generate and transform Java byte code. It is used by AOP, testing, data access frameworks to generate dynamic proxy objects and intercept field access. (06 April 2022)

ChaiScript: An easy to use embedded scripting language for C++. (01 July 2021)

Challenges for Game Developers: A collection of thinking and approaches to game design, wrapped in some challenges. (06 April 2022)

Chaos: Strongly typed, dynamic yet compilable, test-oriented procedural programming language that achieves zero cyclomatic complexity. (22 May 2024)

Chapel: A modern programming language that is parallel, productive, portable, scalable. (06 April 2022)

Charity: A categorical programming language. (06 October 2022)

Charly: Fully parallel dynamically typed programming language. (30 May 2024)

Charm: Charm is a data-oriented scripting language. (24 May 2024)

Chart.js: Simple yet flexible JavaScript charting for designers & developers. (30 May 2020)

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. (01 November 2020)

Cheerp C/C++: A C/C++ compiler for Web applications - compiles to WebAssembly and JavaScript. (06 April 2022)

Cheetah3d: A powerful and easy to learn 3D modeling, rendering and animation software which was developed from the ground up for Mac. (06 April 2022)

Chef: A language where the programs produce magnificent meals. (30 May 2024)

Cherow: A fast, Typescript-based Javascript parser. (17 January 2023)

Cherrybomb: A CLI tool that helps you avoid undefined user behaviour by validating your API specifications. (26 April 2022)

Chess (Variants): A collection of links and ideas for chess variants. (24 February 2023)

Chevrotain: Parser buildint toolkit for JavaScript. (16 December 2022)

Chickadee: A game development toolkit for Guile Scheme. (06 April 2022)

Chicory: Native JVM WebAssembly runtime. (11 May 2024)

CHM (Computer History Museum): Great collection of historical archives around computers, computing, software, and the people and places that built it all. (19 May 2023)

ChocoPy: A Programming Language for Compilers Courses. (01 July 2021)

Choreo: Low-code cloud native engineering for API developers. Engineer in low-code and pro-code simultaneously. (11 August 2021)

Chrome (browser): (Chrome) Extensions are software programs that customize the browsing experience. They enable users to tailor Chrome functionality and behavior to individual needs or preferences. They are built on web technologies such as HTML, JavaScript, and CSS. (06 April 2022)

Chromium: An open-source browser project that aims to build a safer, faster, and more stable way for all Internet users to experience the web. (03 May 2022)

Chromium OS: An open-source project that aims to build an operating system that provides a fast, simple, and more secure computing experience for people who spend most of their time on the web. (03 May 2022)

ChucK: Strongly-timed, concurrent, and on-the-fly music programming language. (01 July 2021)

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. (22 May 2024)

Cicada: Cicada language is a dependently typed programming language and an interactive theorem prover. The aim of cicada project is to help people understand that developing software and developing mathematics are increasingly the same kind of activity, and people who practices these developments, can learn from each other, and help each other in very good ways. (24 May 2024)

CilTools: A set of tools to work with CIL in .NET applications. (17 December 2022)

Cinder: A creative library and toolkit for C++ development across platforms. (10 May 2020)

Circle: Metaprogram C++ in C++. It encourages a seamless mixing of compile-time and runtime capabilities that upends decades of language design. (24 May 2024)

CircuitPython: A fork of MicroPython, designed for API uniformity across many microcontrollers. (18 November 2020)

Circuits: A Lightweight Event driven and Asynchronous Application Framework for the Python Programming Language with a strong Component Architecture. (07 June 2021)

Cish: A minimal, performant, strongly-typed, and multi-paradigm programming language focused on being practical and pragmatic, yet powerful enough to create readable, performant and concise code for any problem. While Cish has as much to do with Forth as Javascript has with Java, it shares the same minimalist, performance oriented approach and philosophy. (24 May 2024)

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#. (01 July 2021)

Citron: General purpose programming language (mainly for unix-like systems). (06 April 2022)

Citus: All the greatness of Postgres, plus the superpower of distributed tables. 100% open source. (03 October 2022)

CLAIRE4: Claire is a general-purpose programming language, best suited to application software requiring sophisticated data modeling, rule processing or problem solving. WebClaire adds extensions for fuller integration with the operating system and for programming web applications. (24 May 2024)

Clamshell: A repl shell for using python as an interactive shell (like bash, fish, zsh etc). (26 February 2023)

Clang static analysis reading: Collections of projects and articles around Clang static analysis. (01 July 2021)

clasp: Bringing Common Lisp and C++ Together. (06 April 2022)

Clawn: Statically typed, simple, native language. (05 February 2024)

Clay: Programming language designed for Generic Programming. (22 May 2024)

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. (01 July 2021)

Clean Architecture: Bob Martin's screed on architecture. Captured for pedagogical analysis. (19 December 2022)

Clean Code: Robert Martin's screed on writing "clean" code. Captured for pedagogical analysis. (24 November 2023)

ClearScript: A library for adding scripting to .NET applications. (06 April 2022)

Clemens Vasters' Messaging Repo: Clemens' collection of messaging material and terminology. (03 October 2022)

Clickteam: Game creation software. (06 April 2022)

Clickvote: Upvotes, links, and reviews. (29 December 2023)

Clio: A pure functional lazy-evaluated programming language targeting decentralized and distributed systems. (15 November 2020)

clip (command-line illustration processor): An open-source software package for creating charts and other data-driven illustrations. (06 April 2022)

Clip2: Clip is CA-Clipper 5.3 compatible compiler for Linux-UNIX and Cygwin with new OO-model, FiveWin and GTK compatible GUI and many other useful features. (24 May 2024)

Clipper (aka xBase): SQL-inspired language from dBase days. (06 April 2022)

CLIPS: A forward-chaining rule-based programming language/platform/engine written in C that also provides procedural and object-oriented programming facilities. (12 July 2023)

Cloe: The timeless functional programming language. (Basically, a Lisp.) (05 February 2024)

Cloe: The timeless functional programming language. It aims to be simple and practical. (15 November 2020)

Clojure: A Lisp for the JVM. (06 April 2022)

Cloud Adoption Patterns: Collection of patterns for adopting cloud. (01 August 2023)

Cloudboost: Cloud platform for your app; similar to Parse + Firebase + Algolia + Iron.io all combined into one. (31 December 2022)

Cloud Design Patterns: A pattern catalog from Microsoft about how to architect cloud applications. (02 June 2021)

Cloud Events: A common information model for events. (03 October 2022)

Cloudflare Durable Objects (D1): Serverless SQL databases to query from your Workers and Pages projects. (08 March 2024)

CloudFoundry: An open source project with an open contribution and open governance model that gives users maximum flexibility to avoid vendor lock-in. (16 May 2020)

CloudMorph: Decentralize and self-host cloud gaming/application. (26 February 2023)

CLR: A stack-based bytecode virtual machine. (09 February 2023)

CLR FFI: A collection of notes and links on .NET/CLR platform interop and native bindings. (29 April 2022)

CLR Interoperability: Links for the interoperability between the Common Language Runtime (CLR) and other platforms. (06 April 2022)

CLR Specifications: Specification links for the Common Language Runtime (CLR). (06 April 2022)

CLR virtual machine/execution engine specifications: A collection of the specifications for the runtime of the CLR platform. (06 April 2022)

CLU: Programming language created at MIT. (22 May 2024)

Clue: Clue is a programming language that compiles into Lua code with a syntax similar to languages like C or Rust. Clue tries to be almost as simple as Lua (with only a slightly more advanced syntax) but adds many optional features that can make code look better or make some things (like metatables) easier to code. Clue does not compile to a specfic version of Lua: flags can be toggled to alter the output to allow most if not all versions or modifications of Lua to be compiled to with Clue. (24 May 2024)

Clutch: Component-based web application designer/builder. (05 July 2021)

Clyde: A language for writing game dialogues, supporting branching dialogues, translations and interfacing with your game through variables and events. (03 November 2022)

Cmajor: Cmajor is an experimental programming language strongly influenced by C++ and C#. It is semantically closer to C++ than C# and syntactically closer to C# than C++. (24 May 2024)

Cmajor2: Cmajor is a programming language for writing fast, portable audio software. Cmajor specifically designed for writing DSP signal processing code. (24 May 2024)

CMake: Cross-platform build tool. (07 June 2022)

cmdpixl: Totally practical command-line image editor. (24 August 2021)

coala: Command-line utility for linting and fixing code for all languages. (30 May 2024)

COBOL: Legacy business language that refuses to die. (22 January 2024)

Cobra: Interesting mix of paradigms into a single CLR-hosted language. (06 April 2022)

CockroachDB: A prime example of NewSQL with ACID guarantee of SQL and the scale of NoSQL. CockroachDB is open source and freely available for cloud-native and hybrid deployments. SQL. Geo-location of data. Horizonatal Scale. ACID transactions. (12 May 2020)

Coco: A CoffeeScript dialect that aims to be more radical and practical. (01 July 2021)

CoCo: A virtual machine based on the Python virtual machine. (20 December 2022)

Coconut: Simple, elegant, Pythonic functional programming. (01 July 2021)

CocoR: Parser generator toolkit. (16 May 2020)

Cocos (Cocos2d-x): A cross-platform game development framework that supports 2D and 3D game creation; provides graphics rendering, GUI, audio, network, physics, user input, etc. (30 May 2020)

Cod: Cod is an opensource concatenative stack-based general purpose programming language. Its transpiled to C and then compiled further to a native executable using external compilers like GCC. (24 May 2024)

CodeChecker: An analyzer tooling, defect database and viewer extension for the Clang Static Analyzer and Clang Tidy (01 July 2021)

Code Contracts: Library for expressing coding assumptions and preconditions/postconditions/invariants. (10 May 2020)

Codenameone: A Write Once Run Anywhere mobile development platform for Java/Kotlin developers. (06 April 2022)

codesize: Code size visualization tool with PDB/ELF/Mach-O support (24 May 2020)

Coding katas locations/sources: A collection of sites that have coding katas for practice. (11 May 2024)

CoffeeScript: Unfancy JavaScript. (06 April 2022)

Cogent: A restricted, polymorphic, higher-order, purely functional language with uniqueness types and without the need for a trusted runtime or GC. (13 January 2024)

Cognate: Quasi-concatenative stack language that uses embedded comments to read like English prose. (22 May 2024)

Coherence: A scalable, fault-tolerant, cloud-ready, distributed platform for building grid-based applications and reliably storing data. (01 July 2021)

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. (01 July 2021)

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. (03 May 2022)

Colm: A programming language designed for the analysis and transformation of computer languages. (05 February 2024)

Colyseus: An open-source multiplayer solution that empowers game devs to Get To Fun Faster. (06 April 2022)

Comet: A domain-specific language for hybrid optimization, featuring solvers for constraint programming, mixed integer programming, and constraint-based local search. (06 April 2022)

Common Expression Language: The Common Expression Language (CEL) implements common semantics for expression evaluation, enabling different applications to more easily interoperate. (30 May 2024)

Common Language Runtime (CLR): The execution engine and supporting structure for .NET programs. (14 January 2024)

Common Object File Format (COFF): Executable file format. (24 May 2020)

Competing on Analytics: TBD (02 June 2021)

Compiler correctness reading: A collection of links and resources on compiler correctness, certification, validation, verification. (30 May 2024)

Compilers.NET (Website): A collection of language links 2007 and earlier. (06 April 2022)

Compilers Implementation/Optimization Reading: Collection of articles on implementing languages. (30 May 2024)

Compis: Contemporary systems programming language in the spirit of C. (24 May 2024)

ComponentPascal: Component Pascal is a programming language in the tradition of Niklaus Wirth's Pascal, Modula-2, Oberon and Oberon-2. It bears the name of the language Pascal and preserves its heritage, but is incompatible with Pascal. Instead, it is a minor variant and refinement of Oberon-2 with a more expressive type system and built-in string support. (24 May 2024)

Compose: Experimental programming language. It aims to be teachable, scalable, modern, powerful & precise. (22 May 2024)

Compost.js: A data visualization library that lets you compose rich interactive data visualizations from a small number of basic primitives. The library is based on the functional programming idea of composable domain-specific languages. (01 July 2021)

Computer Architecture: Microarchitectural channels: A collection of reading materials on computer microarchitectural channels. (01 July 2021)

Computer Hardware and Architecture: A collection of links to various things computer hardware and architecture-related: cmmunities, competitions, conferences, courses, emulation & simulation, journals & publications. (25 November 2020)

Conan: C++ package manager (31 May 2022)

Concept Maps: A page of resources for Concept Maps. (06 April 2022)

Concrete: CMS for teams. (06 April 2022)

Concurnas: An open source JVM programming language designed for building reliable, scalable, high performance concurrent, distributed and parallel systems. (11 August 2021)

Cone: Fast, fit, friendly, and safe systems programming language. (22 May 2024)

Console: A DSL for a network service programming language. (29 June 2023)

Context: An interesting take on a procedural/object language. (06 April 2022)

Continuation-passing style: Readings and links on CPS. (06 April 2022)

Converge: A dynamically typed object oriented programming language with compile-time meta-programming facilities. (01 July 2021)

Convox: Deploy, scale, and manage your applications with ease on a Kubernetes-based open source platform. (15 May 2020)

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. (03 November 2022)

Coolify: Self-hostable Heroku alternative. (24 November 2023)

Copper: Experimental programming language that can be used as a replacement to C and C++. (22 May 2024)

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. (22 January 2024)

CORBA (Common Object Request Broker Architecture): A Java/.NET interoperability-via-distribution platform. (11 May 2023)

CORBA (Common Object Request Broker Architecture): A distributed-objects platform, architecture, and specifications popular in the late 90s and early 2000s. (11 May 2023)

Core: A modern, minimal programming language. In a world in which languages add features until they collapse under their own weight, build a language that is content with itself. (24 May 2024)

Corecalc: A research prototype implementation of core spreadsheet functionality in C#, intended as a platform for experiments with technology and novel functionality. (08 March 2024)

CoreCLR: The VM implementation of .NET Core (06 April 2022)

Core J2EE Patterns: Patterns around enterprise Java circa 2000 (20 March 2024)

CoreNLP: One stop shop for natural language processing in Java; enables users to derive linguistic annotations for text, including token and sentence boundaries, parts of speech, named entities, numeric and time values, dependency and constituency parses, coreference, sentiment, quote attributions, and relations. (03 May 2022)

Core War: A reproduction of the Core War game. Assembly compiler, Virtual Machine and GUI. (27 July 2021)

Corewars: A game of warrior vs warrior, programmed by two opponents, and placed into a virtual 'ring' to fight to the death. (01 July 2021)

CoronaSDK: Cross-platform framework ideal for rapidly creating apps and games for mobile devices and desktop systems. (06 April 2022)

Cosmos: A new logic programming language. (13 July 2023)

Cosmos: Cosmos is an operating system "construction kit". Build your own OS using managed languages such as C#, VB.NET, and more! (06 April 2022)

CosmosDB: Microsoft's proprietary globally-distributed, multi-model database service "for managing data at planet-scale" launched in May 2017. It is schema-agnostic, horizontally scalable and generally classified as a NoSQL database. (12 May 2020)

Cotowali: Statically typed scripting language that transpile into POSIX sh. (24 May 2024)

Couchbase: A full-featured, multi-service, multimodel database. (11 May 2023)

CouchDB: Seamless multi-master sync documented-oriented native HTTP/JSON API with emphasis on reliability and concurrency. (06 April 2022)

CovariantScript: Covariant Script is an open source, cross-platform programming language. High-performance runtime environment. Self-developed efficient compilation system. Powerful and bloat-free extension system (24 May 2024)

Cow: Language designed with the bovine in mind. (04 May 2020)

Cowgol: A self-hosted Ada-inspired programming language for very small systems. Cowgol is an experimental, Ada-inspired language for very small systems (6502, Z80, etc). It's different because it's intended to be self-hosted on these devices: the end goal is to be able to rebuild the entire compiler on an 8-bit micro, although we're not there yet. (24 May 2024)

Coyote: A statically-compiled research language from Microsoft around explicit state machine management. (07 June 2021)

CPL: An implementation of "A Categorical Programing Language" (CPL for short)[1][2] written in Haskell. (12 July 2023)

C-plus-Equality (or See-Equality): Feminist Software Foundation C+=, a new language for us feminists. (07 June 2021)

Cppcheck: A tool for static C/C++ code analysis (01 July 2021)

Cppfront: Cppfront is an experimental compiler from a potential C++ 'syntax 2' (Cpp2) to today's 'syntax 1' (Cpp1), to learn some things, prove out some concepts, and share some ideas. This compiler is a work in progress and currently hilariously incomplete... basic functions work, classes will be next, then metaclasses and lightweight exceptions. (24 May 2024)

CppNet: Quick and dirty port of jcpp (tools/jcpp) to C#, with features to support Clang preprocessing. (01 July 2021)

CPython: The original, "standard", C-based implementation of the Python language/platform. (11 May 2024)

CPython VM: The CPython virtual machine. (20 December 2022)

CQL (Cassandra Query Language): Query language that's almost SQL that rides on top of the Cassandra storage system. (24 August 2021)

Crab: A Language-Agnostic Library for Static Analysis (01 July 2021)

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. (01 July 2021)

CreateDB: Open-source, distributed SQL database. (26 April 2022)

CreateJS: A suite of modular libraries and tools which work together or independently to enable rich interactive content on open web technologies via HTML5. (06 April 2022)

Create Your Own Programming Language: Notes on the book "Create Your Own Programming Language" (30 May 2024)

Crow: - Crow programs can be run directly from source. You can also build your program to a standalone executable. In either case, you don't need a build system. You can directly call C functions. Data is garbage collected. Don't worry about what's by-reference or by-value. Crow is statically typed. There's no subtyping or implicit conversion. There are no null references. Overload resolution is unambiguous. I/O is controlled. Normal functions can't do I/O except by invoking a lambda from a parameter. You can launch parallel tasks and get the result as a future. Mutability is controlled. The type system tracks whether a type allows access to mutable data. This ensures that mutable data is not shared across threads. Syntax is expression-based. Function bodies are expressions with no return needed. Even if and for are expressions. Code is flat. Most declarations are not nested inside of anything. Expressions are type-checked with an expected type. The same syntax like (1, 2) could be a list, tuple, vector, etc. This saves you from having to write new Foo(). There are discriminated unions, including option types. There are templates; these are type-checked abstractly, not at each instantiation. All crow code goes in modules. There are no global declarations. (24 May 2024)

Crucial Conversations: How to have important emotional conversations with people (when opinions vary, stakes are high, and emotions run strong). (02 June 2023)

Crumb: Crumb is a high level, functional, interpreted, dynamically typed, general-purpose programming language, with a terse syntax, and a verbose standard library. It features: Strictly no side effects* to help you write functional code; The ability to localize the effects of imported Crumb files.; Dynamic typing and garbage collection.; 0 keywords, everything is a function. (24 May 2024)

Crunch: Strongly & statically typed systems level language focused on ease of use, portability and speed. (22 May 2024)

Crust: Open-Source Low-Code Platform and Salesforce Alternative (05 July 2021)

CryEngine: Full-featured multi-platform AAA game engine. (30 November 2022)

Cryptocurrency reading: A collection of reading and links on why cryptocurrency is a crock. (29 June 2023)

Crystal: A Ruby-inspired statically-type-checked, native language. (06 April 2022)

CSCS: Customized Scripting in C# (29 June 2023)

CSL: CSL is a simple lisp-like macro language for scripting high-level logic and data structures in a way that interfaces easily to the C programming language (24 May 2024)

CSL2: The C Scripting Language (CSL) is a programming language available for Windows, OS/2 and UNIX systems. CSL follows the C syntax very closely. It is used like an interpreter: a program written with an editor can be run directly like any shell script. The CSL scripting engine can be integrated into own applications as a macro language. CSL offers two programming interfaces: A "C" API for 32-bit C compilers, and C++ class interface for selected compilers. (24 May 2024)

CSPLib: A library of test problems for constraint solvers. (06 April 2022)

CSS snippets: Cool CSS snippets I find along the way. (19 May 2022)

CSS Specifications: All the specification docs that make up CSS. (25 April 2022)

cT: An easy to use graphics- and mouse-oriented programming environment (07 May 2021)

CTO Links: Curated and opinionated collection of resources around CTO/VP-ness. (25 February 2023)

Cub: an interpreted, dynamically typed, scripting language inspired by Swift. (06 October 2022)

Cubiml: Cubiml is a simple ML-like programming language with subtyping and full type inference. You can try it out online in your browser [here](https://storyyeller.github.io/cubiml-demo/demo.html). (30 May 2024)

CUE (Configure Unify Execute) Language: Validate, define, and use dynamic and text-based data. (06 April 2022)

Cuis-Smalltalk: A free Smalltalk-80 environment with a specific set of goals: being simple and powerful. (05 July 2022)

Cuneiform: Functional programming language (static type checking) for large-scale data analysis workflows. (04 May 2020)

CUP: Simple, C-like programming language. (22 May 2024)

cur: Powerful meta-programming for powerful types. (22 May 2024)

curl: A command line tool and library for transferring data with URLs. (20 March 2024)

Curl: Richer Internet Applications: the Curl language, development environment, runtime engine, and development libraries. (01 July 2021)

Curry: Haskell with Logic extensions. (04 May 2020)

CWEB: Literate programming in C. (23 December 2022)

Cyber: Cyber is a fast, efficient, and concurrent scripting language. You can embed it into your applications, games, or engines on desktop or web. Cyber also comes with a CLI, so you can do scripting on your computer. (24 May 2024)

Cygwin: An implementation of POSIX APIs on Win32, with accompanying *nix applications and libraries. (06 April 2022)

Cynefin: A framework for making decisions. (24 November 2023)

Cypher: A graph database query language first popularized by Neo4j. (19 May 2023)

C∀: C? (Cforall) is a language design extending ISO C. The purpose of the project is to engineer modern language features into C in an evolutionary rather than revolutionary way. Java is an example of the revolutionary approach of modernizing C/C++, resulting in a new language rather than an extension of its descendents. C++, Fortran 95 and Cobol 9X are examples of the evolutionary approach where modern language features are added and problems fixed within the framework of an existing language. (30 May 2024)

D: General-purpose programming language with static typing, systems-level access, and C-like syntax. (22 May 2024)

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. (26 May 2022)

DaCE: Data-Centric Parallel Programming. (22 May 2024)

Dachs: Dachs is a general-purpose programming language designed to be enjoyable, statically-typed and dog-friendly. Dachs is intended to be used for efficient applications and tools development, not for system programming. (24 May 2024)

Dafny: A verification=ready programming language. (13 January 2024)

Dagger: A portable devkit for CI/CD pipelines. (06 April 2022)

Dale: Dale is a system (no GC) programming language that uses S-expressions for syntax and supports syntactic macros. The basic language is similar to C, with the following additional features: local type deduction; overloaded functions; anonymous functions; reference parameters; initializers and destructors; variants; namespaces; modules; concepts; and compiler introspection. (24 May 2024)

Dalvik: The virtual machine created for execution on Android devices. (06 April 2022)

Dapper: A simple object mapper for .NET. (18 May 2020)

Dapr: A portable, event-driven runtime that makes it easy for any developer to build resilient, stateless and stateful applications that run on the cloud and edge and embraces the diversity of languages and developer frameworks. (11 May 2024)

Dark: A startup effort around a service-oriented language and web development environment. (23 December 2022)

DarkBasicPro: Dark Basic Pro is an open source BASIC programming language for creating Windows applications and games. (24 May 2024)

DarlingJS: Entity-Component-System based javascript game engine with dependency injections and modules. Create flexible architecture of a game. (01 July 2021)

Dart: An open-source, scalable programming language, with robust libraries and runtimes, for building web, server, and mobile apps. (06 April 2022)

daScript: High-performance statically strong typed scripting language. (22 May 2024)

Data, context, and interaction (DCI): A paradigm used in architecture to program systems of communicating objects; it separates the domain model (data) from use cases (context) and roles that objects play (interaction). (01 July 2021)

Data concurrency and parallel programming: Links about different ways to store data at high levels of concurrency (06 April 2022)

Data Format Description Language (DFDL): A language for describing text and binary data formats. (24 August 2021)

Datalog: A declarative logic language using Horn clauses; a lightweight deductive database system where queries and updates are expressed in the logic language (18 November 2020)

Data-Oriented Design: A data-centric design approach, typically guided by low-level performance concerns in game development scenarios. (05 July 2022)

Datasets: A collection of data sets to use for teaching purposes. (29 June 2023)

db4o: An object-oriented database using "native queries" (queries in the source language). (18 December 2022)

DBeaver: Free universal database tool and SQL client. (14 March 2023)

DBOS: A Typescript framework built on the database that helps you develop transactional backend applications. (11 January 2024)

DBOS: A Database-Oriented Operating System. (24 November 2023)

ddbug: Display debugging information. (16 May 2020)

Death by Meeting: Running effective meetings. (06 April 2022)

Debugging reading: A collection of reading links and resources on debugging (09 February 2023)

Defold: 2D-focused, 3D-capable, cross-platform (iOS, Android, HTML 5, macOS, Windows, Linux) game engine. (19 May 2020)

Delinker: Unlinks a binary executable to get back a set of .o object files for further transformation and re-linking. (16 May 2020)

Deno: A NodeJS-esque platform using V8 seeking to fix some of Node's quirks. (26 May 2020)

deployd: A tool that makes building APIs simple by providing important ready-made functionality out of the box that meet the demands of complex applications. (06 April 2022)

DerbyJS: MVC framework for writing realtime, collaborative applications that run i both NodeJS and browsers. (30 May 2020)

Derecho: An open-source C++ distributed computing toolkit that provides strong forms of distributed coordination and consistency at RDMA speeds. (16 May 2020)

Derw: Elm-inspired language that transpiles to TypeScript. (22 May 2024)

Design Docs (Google): How Google does design docs (06 April 2022)

Designing Data-Intensive Applications: How to think about building data-centric applications. (06 April 2022)

Designing Distributed Systems: A relatively short distributed patterns book. (20 March 2024)

Design Patterns (GOF): The "original" patterns book. (26 February 2023)

Detect-It-Easy: Program for determining types of files for Windows, Linux and MacOS (16 May 2020)

DevBCN: Barcelona Developer's Conference (formerly jBCNConf). (14 March 2023)

Developer Advocacy Handbook: Notes from the book. (30 December 2022)

Developer Marketing Does Not Exist: The Authentic Guide to Reach a Technical Audience: Notes from the book. (22 December 2022)

Developer Relations: How to Build and Grow a Successful Developer Program (Notes from the book). (30 December 2022)

Developer Relations: The Essential Guide: Notes from the book. (30 December 2022)

Developer Relations for Beginners: Notes from the book. (22 December 2022)

Developer relations reading: Collection of thoughts/essays/etc on developer relations (DevRel). (29 June 2023)

Development process-related reading (Scrum, XP, Kanban): A collection of links to papers about the process of building software (09 December 2022)

devenv.sh: Build, share, and run your local development environments with a single command. (26 February 2023)

DeviceScript: TypeScript subset intended for embedded/hardware use. (08 March 2024)

DEVIntersection: The other major Microsoft conference not hosted by Microsoft. (14 March 2023)

DevNexus: Atlanta JUG gone and created a conference. (14 March 2023)

DevOps: Collection of blogs, articles, etc around "DevOps" (05 July 2022)

Devoxx: Collection of "big" shows in Europe loosely around JVM topics. (14 March 2023)

DevReach: Bulgarian developer conference. (14 March 2023)

DevRelCon: A conference on DevRel. (24 February 2023)

DevRelX Summit: A conference on DevRel. (24 February 2023)

DFlex: A Drag-and-Drop library for all JavaScript frameworks implementing an enhanced transformation mechanism to manipulate DOM elements. (10 May 2022)

Dg: A (technically) simple language that compiles to CPython bytecode. (15 November 2020)

DGraph: Native GraphQL Database with graph backend. (31 December 2022)

Dhall: A statically-typed functional configuration language. (18 November 2020)

Diagrams: Build architectural diagrams. (01 August 2023)

Diagrams As Code: Generate valid diagrams from source code. (24 August 2021)

Dialect: Dialect is an interpreted programming language with GUI, networking, and object oriented capabilities. The Dialect language (a.k.a. Aristar Dialect Pro) source code has been released to the public under an Apache style Open Source license. The source code is available on sourceforge.net directly from the CVS repository and also as a separate zip package file. (24 May 2024)

Dialog: A domain-specific language for creating works of interactive fiction. (01 July 2021)

Diataxis: A way of thinking about and doing (organizing) documentation. (22 January 2024)

Dictu: A high-level dynamically typed, multi-paradigm, interpreted programming language. (01 November 2022)

Dino: High-Level scripting object-oriented language: Multi-precision integers; Heterogeneous extensible arrays, array slices; Associative tables with possibility to delete elements; Powerful and safe class composition operation for (multiple) inheritance and traits description; First class functions, classes, and fibers with closures, anonymous functions, classes, fibers; Exception handling; Concurrency; Pattern matching; Unicode 8 support (24 May 2024)

Dip: Dynamically typed interpreted programming language written in Python, which gives emphasis to readability and ease of use, while also providing the power of all of python’s libraries. (22 May 2024)

Directus: Headless CMS & API for Custom Databases. (06 April 2022)

Dis: The virtual machine behind the Limbo programming language for the Inferno operating system. (06 April 2022)

Disco: Functional teaching language for use in a discrete mathematics course. (22 May 2024)

Discourse: A platform for community discussion. (06 April 2022)

Discus: Experimental dialect of Haskell which investigates static typing and program transformation in the presence of computational effects. (22 May 2024)

Disqus: Cloud-based discussion/threads system suitable for use by any static HTML-based site. (16 May 2020)

Distribution (networking, distributed systems, etc) reading: Generalized reading topics about spreading code around the network. (26 April 2022)

Ditto: Super Kawaii Dependently Typed Programming Language. (22 May 2024)

Ditto: Functional, statically typed, and pure. (22 May 2024)

Dittytoy: Create your generative music online using a simple Javascript API. (25 February 2023)

DML: DML is a simple templating language designed for managing web sites based in static HTML files (no CGI, SSI, etc.). It has been obsoleted by DML2 which has in turn been obsoleted by XSLT. (24 May 2024)

DML2: DML2 is an object-oriented content storage and document formatting framework. Using a fairly simple, object-oriented language and a few templates, generating different types of media from the same source content is made easy. This tool has been obsoleted by XSLT. (24 May 2024)

DocBook: Collection of XML/XSLT tags for publishing articles, books, and other forms of content. (30 May 2020)

Docker: Virtualization tool for containerizing code, configuration, and sometimes data as part of a deployment. (11 May 2023)

Docker-Compose: Running multiple Docker images collectively. (11 May 2023)

Dolphin Smalltalk: Dolphin Smalltalk language, vm, etc. (05 July 2022)

DolphinVM: Dolphin Smalltalk virtual machine. (27 July 2021)

Dolt: It's Git for Data. (08 March 2024)

Domain Specific Languages: A collection of reading and links on the implementation of DSLs. (12 May 2022)

Dora: JIT-compiler for the programming language Dora implemented in Rust. (22 May 2024)

DotLisp: A Lisp dialect for .NET. (24 August 2021)

Dotnet Core CLR: Open-source implementation of the CLR. (06 April 2022)

dotNET Foundation: The .NET Foundation is an independent, non-profit organization established to support an innovative, commercially friendly, open-source ecosystem around the .NET platform. (06 April 2022)

DotNetMQ: A new and independent Open Source Message Queue system that is entirely built in C# and .NET framework 3.5. (05 July 2022)

dotnetRDF: An open-source CLR library for RDF. (01 July 2021)

dotnetReleaser: Easily cross-compile, package and publish your .NET application to NuGet and GitHub. (06 April 2022)

DotNext: A collection of .NET libraries intended to fill in gaps left by the CLR and standard library. (07 June 2021)

DotVVM: An open-source framework for ASP.NET to build interactive webapps with just C# and HTML (MVVM pattern). (06 April 2022)

DPMN (Discrete Process Modeling Language): A graphical language to capture more than business processes. (24 February 2023)

Draak: Draak is a Multilanguage Macro compiler. What does that mean? Draak is a compiler that has the ablity to compile any language for any platform by being a generic compiler. It reads in a language description file and uses it to compile a program. It has two parts: parser and macros. The parser replaces Yacc and Lex, and the macros replaces the code generation for traditional compilers. (24 May 2024)

Draco: a new .NET programming language under development. If you want further details on the language itself or want to contribute ideas, head over to the [language suggestions repository](https://github.com/Draco-lang/Language-suggestions). (24 May 2024)

Draconic: A scripting language based off Python to run user scripts on the server safely. (01 November 2022)

Draftbit: Visual mobile app builder. (05 July 2021)

Dragon: The Dragon is an innovative and practical general-purpose language. The supported programming paradigms are imperative, object-oriented, declarative using nested structures, functional and natural programming. The language is portable (Windows, Linux, macOS, etc.) and can be used to create Console and GUI. The language is designed to be simple, small, flexible and fast. (24 May 2024)

DragonflyDB: An in-memory datastore. (25 January 2024)

Dragonruby: A zero dependency, cross platform, Ruby runtime built on top of mRuby, libSDL, and LLVM. (25 January 2024)

Draw.io: Diagramming tool that integrates with Confluence and Github. (24 August 2021)

DreamBerd: A perfect programming language. (05 February 2024)

Dream Maker: The DM (Dream Maker) language uses a syntax similar to C/C++ to build networked multi-user worlds. This reference and the accompanying guide discuss the structure and function of DM. (24 May 2024)

Dr Memory: Memory Debugger (01 July 2021)

Drools: Drools is a rule engine, DMN (Decision Model Notation) engine and complex event processing (CEP) engine for Java. (30 March 2021)

DropboxMQ: Filesystem-based JMS implementation. (02 June 2023)

Dropwizard: A Java framework for developing ops-friendly, high-performance, RESTful web services. (08 March 2024)

DSL Evaluation Checklist: A collection of questions for evaluating DSLS. (14 June 2024)

DSLisp: An interpreted language and host that integrates with .NET. (24 August 2021)

DTrace: A performance analysis and troubleshooting tool that is included by default with various operating systems, including Solaris, Mac OS X and FreeBSD. (06 April 2022)

Dub: Open-source link management infrastructure. (29 December 2023)

DuckDB: An in-process SQL OLAP database management system. (14 March 2023)

Duckscript: A simple, extendable and embeddable scripting language. (12 July 2023)

Duelyst: Source and assets for CCG game. (24 February 2023)

Durable Task Framework: A library that allows users to write long running persistent workflows (referred to as orchestrations) in C# using simple async/await coding constructs. It is used heavily within various teams at Microsoft to reliably orchestrate long running provisioning, monitoring, and management operations. (06 April 2022)

DustyScript: The intent of this project is to write a programming language powerful enough to retain a 8/9-yr old's interest but simple enough... that the syntax can be grasped by them (24 May 2024)

DWARF: Debugging format for ELF excutables (06 April 2022)

DWScript: A statically typed Delphi/Free Pascal-like language. (24 May 2024)

Dyalect: Dyalect is a dynamic programming language for .NET platform. It is lightweight, fast and modern. Dyalect (or Dy for short) supports Windows, MacOS and Linux. Dy runs on the top of its own high performance virtual machine. It compiles fast and can be used as an embeddable language or as a scripting language of your choice. It is also a good language to learn programming. Dyalect offers modern syntax, inspired by such languages as C#, Swift, Go and Rust, first class functions, coroutines, expressive modules, a dynamic type system with an ability to extend existing types with new methods and much more. (24 May 2024)

DyBase: A very simple object oriented embedded database for languages with dynamic type checking. (06 April 2022)

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. (24 May 2024)

Dynamic Analysis Sanitizers reading: Readings on software sanitizers. (06 April 2022)

Dynamic Binary Instrumentation (DBI) reading: A collection of reading and resources on dynamic program analysis (06 April 2022)

Dynamic Binary Translation (DBT) reading: Reading on DBT (06 April 2022)

Dynamic instrumentation tools: Tools for binary instrumentation, analysis, and modification. (06 April 2022)

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. (01 January 2023)

DynamoRIO: Dynamic Instrumentation Tool Platform (01 July 2021)

Dynasty: Interpreted, dynamically-typed, lazily evaluated, purely functional programming language. (22 May 2024)

dynomite: A generic dynamo implementation for different k-v storage engines. (30 May 2020)

Dyon: A rusty, dynamically typed scripting language. (19 June 2021)

DZSlides: A one-file HTML template to build slides in HTML5 and CSS3. (09 February 2023)

E: An object-oriented programming language for secure distributed computing. (01 July 2021)

E4X (ECMAScript for XML): An early attempt to embed hierarchical data/XML syntax functionality within the ECMAScript language. Since deprecated. (06 April 2022)

Earl Grey: Programming language compiling to JavaScript. (02 June 2021)

Easylang: An easy programming language that runs in the browser. Easylang is a rather minimalistic simple programming language. Because of the clear syntax and semantics it is well suited as a teaching and learning language. Functions for graphic output and mouse input are built into the language. The language is written in C and is open source. Main target platform is the web browser using WASM. However, it also runs natively in Windows and Linux. The one-pass parser and compiler is quite fast. In the Web IDE, each time the Enter key is pressed, the program is parsed and formatted up to the current line. (24 May 2024)

eC: An Expressive and Intuitive, C Style Object-Oriented Programming Language. eC comes bundled with the [Ecere SDK](https://ecere.org/), providing a comprehensive API for building apps ranging from games to business, for desktop, mobile and web platforms. (24 May 2024)

ECMA: European Computer Manufacturers Association (ECMA) website of standards and technical reports. (24 August 2021)

ECMAScript (aka Javascript): A dynamic, object-oriented script language. (22 May 2024)

ECMAScript example of code as data: An example of using code as data in ECMAScript (01 November 2020)

Economics: Collections of articles and books on economics. (03 October 2022)

Economist: International Relations A to Z: Geopolitics terms, from “Abraham accords” to “zero-sum game”, explained in plain English. (11 May 2024)

Ecstasy (XTC): An object-ish language designed to be cloud native from the ground up. (24 May 2024)

ECSY: A highly experimental Entity Component System framework implemented in javascript, aiming to be lightweight, easy to use and with good performance. (01 July 2021)

EdgeDB: Open source, graph-relational database. (06 April 2022)

Edina: Edina - A simple stack-oriented compiled programming language. Edina is a simple multi-paradigm programming language. It currently features a JVM compiler, a REPL and an ever expanding standard library. Edina is mostly a hobby project. Due to its stack-oriented design it's a little restrictive and hard to program in, but that's what makes it fun in my opinion. (24 May 2024)

edn (Extensible Data Notation): A format for serializing data. (06 April 2022)

Edward: Probabilistic programming library/language for modeling, inference, and criticism. It is a testbed for fast experimentation and research with probabilistic models, ranging from classical hierarchical models on small data sets to complex deep probabilistic models on large data sets. (05 February 2024)

Edward: A library for probabilistic modeling, inference, and criticism. (13 June 2023)

Edward2: Edward2 is a simple probabilistic programming language. It provides core utilities in deep learning ecosystems so that one can write models as probabilistic programs and manipulate a model's computation for flexible training and inference. (24 May 2024)

EEL: EEL is a scripting and programming language, designed specifically for hard real time applications. The primary target areas of application are control engineering and audio synthesis, but EEL should also be suitable for game scripting and for adding scripting capabilities to real time multimedia applications. The syntax is C-like, but the language is higher level than C, and "safe" in the sense that EEL programs should not be able to crash the virtual machine or the host application. EEL has dynamic typing, automatic memory management, exception handling and built-in high level data types such as vectors, arrays and tables. New such data types can be added at run time by host applications. EEL compiles into byte-code that runs on a virtual machine, which means that no explicit support for specific architectures is needed for portability. The implementation is deliberately very self contained and has few dependencies, so that it can be easily integrated into "strange" environments, such as embedded devices running real time operating systems. (24 May 2024)

Eff: Functional language with handlers of not only exceptions, but also of other computational effects such as state or I/O. (22 May 2024)

Effective C++, 3rd Ed: Third edition of Scott's classic. (06 April 2022)

Effective Enterprise Java: A collection of topics for effective enterprise systems. (03 May 2022)

Effective Java (1st Ed): A collection of items describing how to best design/write Java code. (26 November 2020)

Effective Java (2nd Ed): A collection of items describing how to best design/write Java code. (06 April 2022)

Effective Python, 2nd Edition: 90 Specific Ways to Write Better Python (26 November 2020)

Effekt: Research language with effect handlers and lightweight effect polymorphism. (24 May 2024)

EFI (Executable Firmware Interface): The specification (describing PE files as the standard) for executable format in EFI environments. (01 July 2021)

Egel: An untyped concurrent functional scripting language based on eager combinator rewriting with a concise but remarkably powerful syntax. (24 May 2024)

Egison: A programming language that features extensible efficient non-linear pattern matching with backtracking for non-free data types. (24 May 2024)

Egret: An open mobile game and application engine which allows you to quickly build mobile games and apps on Android,iOS and Windows. (30 December 2022)

Eiffel: Object-oriented language that also implies an environment and "method" of writing software (much like Smalltalk). One of the early OO environments. (24 May 2024)

Ein: Functional programming language for scalable development. (22 May 2024)

elastiC: elastiC is a portable high-level object-oriented interpreted language with a C like syntax. (24 May 2024)

Electra: Electra is an esolang where you code like an electrician. Electra is inspired by AsciiDots. It uses instruction pointers that acts like currents in electricity. [eso] (24 May 2024)

ElectronJS: A framework for building desktop applications using JavaScript, HTML, and CSS, by embedding Chromium and Node.js into its binary, thus allowing one to maintain one JavaScript codebase and create cross-platform apps that work on Windows, macOS, and Linux. (06 April 2022)

Elegant Puzzle: Systems of engineering management. (06 April 2022)

Elemental low-code platform: A standards based, open low-code development platform built on nodejs with the ability to fallback to writing raw nodejs code when the provided tools cannot solve your problems. (06 April 2022)

Elena: ELENA is a general-purpose language with late binding. It is multi-paradigm, combining features of functional and object-oriented programming. Rich set of tools are provided to deal with message dispatching : multi-methods, message qualifying, generic message handlers, run-time interfaces. (24 May 2024)

Eleventy: A simpler static site generator. (10 May 2022)

Eleventy (11ty): A JavaScript alternative to Jekyll. (01 July 2021)

ELFE: ELFE (Extensible Language for Everyday (and the Internet of Things)) is a very simple and small programming language specifcally designed for everyday programming, notably for the Internet of Things. While ELFE is a general-purpose programming language, it is designed to facilitate the configuration and control of swarms of small devices such as sensors or actuators. It can also be used as a powerful, remotely-accessible extension language for larger applications. (24 May 2024)

Elixir: A dynamic, functional language designed for building scalable and maintainable applications (24 May 2024)

Elkhound: A parser generator, similar to Bison. The parsers it generates use the Generalized LR (GLR) parsing algorithm. GLR works with any context-free grammar, whereas LR parsers (such as Bison) require grammars to be LALR(1). (02 August 2021)

Ella: Computer programming language interpreter written in Rust. (22 May 2024)

Elm: A functional language for reliable webapps. (24 May 2024)

Elmish: (Nothing yet) (05 July 2021)

ELSA: An open source .NET Standard workflows library. (06 April 2022)

Elvish: An expressive programming language and a versatile interactive shell, combined into one seamless package. (24 May 2024)

EML: Extended ML (EML) is a framework for specification and formal development of Standard ML (SML) programs. EML specifications look just like SML programs except that axioms are allowed in signatures and in place of code in structures and functors. Some EML specifications are executable, since SML function definitions are just axioms of a certain special form. This makes EML a "wide-spectrum" language which can be used to express every stage in the development of a SML program from the initial high-level specification to the final program itself and including intermediate stages in which specification and program are intermingled. (30 May 2024)

Emojicode: World’s only programming language that’s bursting with emojis. (15 November 2020)

Emscripten: C++ compiler that generates Javascript "assembly" for execution by any JS engine. (06 April 2022)

Emu (The EMbeddable Utility Language): A clean, fast, flexible and free programming language. (30 May 2024)

Emulators written in JavaScript: A list of emulators written in the JavaScript programming language. (05 February 2024)

Enchilada: Enchilada is optimized to efficiently and consistently share huge amounts of data (and code) in a distributed environment. Possible use cases: Distributed and authenticated computation/code; Distributed and authenticated dependency management. (24 May 2024)

Endless OS: Laptop, key, and OS, all for humanitarian purposes. (24 February 2023)

EngineYard: Easy Ruby on Rails deployment to AWS (06 April 2022)

Enki: Intended to be a logic language for teaching programming to people with no programming experience. (22 May 2024)

Enso (aka Luna): Hybrid visual and textual functional programming. Aimed at union of data scientists and developers. (27 July 2021)

Enterprise: A non-deterministic-unnecessarily-statically-typed™ Turing-complete-ish™, Quantum-out-of-the-box™ programming language. (15 November 2020)

Enterprise Integration Patterns: Hohpe/Woolf's classic messaging text. (11 May 2024)

Entity Component Systems (ECS): A common architecture/design pattern for building games. (06 April 2022)

Entity Framework: A framework for retrieving and storing data to relational systems. (26 April 2022)

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. (05 February 2024)

Eolang: An object-oriented programming language based on 𝜑-calculus. (30 May 2024)

EPIC stack: Javascript/Web project starter stack. (22 January 2024)

Erasmatazz: Chris Crawford's home for his thoughts on games and such. (19 April 2022)

Erg: A statically typed language that can deeply improve the Python ecosystem. (24 May 2024)

Erlang/OTP: An actors-based message-passing functional language running on BEAM. (30 May 2024)

Esoteric Programming Languages: Languages that are silly, ridiculous, or out to punish innocent programmers. (22 May 2024)

Espree: An Esprima-compatible JavaScript parser. (17 January 2023)

Esprima: ECMAScript parsing infrastructure for multipurpose analysis. (17 January 2023)

esProc SPL: A scripting language for data processing, executed in a Java progrma through JDBC. (24 November 2023)

Essays on distribution and networking: A collection of links to essays. (11 May 2024)

Essays on People: A collection of essays on people. (11 May 2024)

Essays on Programming: Random collection of long-form thoughts. (11 May 2024)

Essence#: A Smalltalk-superset language for the CLR. (02 August 2021)

Essential Drucker: Selections from the management works of Peter F Drucker (06 April 2022)

Esterel: A programming language, dedicated to programming reactive systems, and a compiler which translates programs into finite-state machines. Synchronous reactive language that allows simple expression of parallelism and preemption and is based on logical instants and zero time hypothesis. (22 May 2024)

ESTree: The format that caught on as a lingua franca for tools that manipulate JavaScript source code. (17 January 2023)

Eta: A pure, lazy, strongly typed functional programming language on the JVM. (05 February 2024)

etalk: A Simple Object-Oriented Language (24 May 2024)

Euphoria: A powerful but easy-to-learn and easy-to-use programming language. (30 May 2024)

Eval: A lightweight interpreter framework written in Swift, evaluating expressions at runtime, with operators and data types you define. (30 May 2024)

Eve: Programming language based on years of research into building a human-first programming platform. (22 May 2024)

Event-Driven .NET: An Event Driven Microservices Platform for .NET. (06 April 2022)

Event Processing Language (EPL): A language, compiler, and runtime for complex event processing (CEP) and streaming analytics. (10 May 2020)

Event Sourcing: An approach to building storage systems that tracks events rather than "truth". (01 August 2023)

EventStoreDB: Persist your application data as streams of events with an open-source database, the best data storage solution for event-sourced systems. (06 April 2022)

Evergine: The graphics development engine for business and industry. Build high-quality 3D solutions and deploy to any platform. (06 April 2022)

EverPARSE: A framework that automatically produces high-performance, formally proven C code for parsing binary messages. (06 April 2022)

Evlan: A programming language and a virtual machine, similar to Java/JVM or C#/.NET, but with many advantages. (30 May 2024)

Evolving Frameworks: A paattern language for evolving object-oriented frameworks. (20 March 2024)

Evrete: A lightweight Java rule engine. (23 February 2023)

exa: A modern replacement for "ls". (06 April 2022)

Excel LAMBDA: Define custom functions using Excel's formula language. (06 April 2022)

execline: A (non-interactive) scripting language, like sh - but its syntax is quite different from a traditional shell syntax. (30 May 2024)

Executable and Linkable Format (ELF): Executable file format. (06 April 2022)

Executable and object file format reading: Resources and reading around executable and object file formats. (06 April 2022)

Executables linking and loading reading: A collection of links and resources on the linking and loading of executables. (24 November 2023)

Expr: Expression language and expression evaluation for Go. (24 May 2024)

Expresso: Simple expressions language with polymorphic extensible row types. (22 May 2024)

Extensible Markup Language (XML): Data or presentation format inspired by HTML and SGML, used extensively in software development. (30 May 2020)

Extensible-Storage-Engine (ESE, aka "Jet"): An embedded/ISAM-based database engine, that provides rudimentary table and indexed access. (30 March 2021)

eXtremeDB: Hybrid Persistent & In-memory Highly Scalable Distributed Client / Server (06 April 2022)

eXtreme Programming Explained: The book describing the predecessor to agile. (11 May 2024)

F: F is a pure functional concatenative language originally designed as an extension of False. F contains the list-operations of K3 and the dip combinator of Joy. Floating-point and symbolic datatypes are supported. One-time assignment is enforced in syntax. A theory of function-valence and -charge is outlined. F also contains a general continuation primitive $, and the pattern sublanguage of XY. G is a variant of F in which the K3 adverbs are implemented as primitives. (24 May 2024)

F--: Uncurried minimal functional programming language. (22 May 2024)

F* (F-star): A general-purpose functional programming language with effects aimed at program verification. (30 May 2024)

F#: An object/functional hybrid language. (08 January 2023)

Fable: A compiler that brings F# into the browser. (05 July 2021)

Fabulous: F# Functional App Development, using declarative dynamic UI. (06 April 2022)

Facet: Call-by-value functional language with algebraic effects, quantitative type theory, and staging. (22 May 2024)

FaCT: Flexible and Constant Time Programming Language. (22 May 2024)

Factor: A concatenative, stack-based programming language with high-level features including dynamic types, extensible syntax, macros, and garbage collection. (24 May 2024)

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. (24 May 2024)

FALSE: I designed this language in ‘93 with two particular objectives: confusing everyone with an obfuscated syntax, and designing an as powerful language as possible with a tiny implementation: in this case a compiler executable of just 1024 bytes (!), written in pure 68000 assembler. (24 May 2024)

Fancy: A pure dynamic object-oriented, self-hosted programming language for the Rubinius VM. (30 March 2021)

Fantom: General-purpose object-oriented language intended for use across multiple platforms. (24 May 2024)

Fanx: Fanx is a full-stack programming language base on Fantom. It is an object oriented and static typing language with elegant libraries. (24 May 2024)

Farmer: F-sharp bindings to Azure management APIs? (03 October 2022)

Farnam Street Blog: (No summary) (22 January 2024)

fasm (Flat Assembler): The Flat Assembler (06 April 2022)

FAST: FAST is a new programming language, which combines the advantages of other programming languages: FAST supports functions as data types FAST is fully object-oriented and knows multiple inheritance FAST has dynamical memory management and garbage collection FAST includes library units on its own FAST speaks Assembler FAST knows macros FAST has a clear and consequent syntax FAST compiles within tenths of seconds and creates efficient code FAST has lots of useful features such as e.g. the prevention of the Division by Zero error. FAST programs are written as plain text and then sent thru the FAST compiler. Small and efficient code is created and a COM-File results. Up to now, FAST only compiles for MS-DOS (I just have not yet found out how to assemble a binary executable for WINDOWS). (24 May 2024)

FASTBuild: A high performance, open-source build system for Windows, Linux, and OS X. (01 July 2021)

Fault: A modeling language for building system dynamic models and checking them using a combination of first order logic and probability. (06 April 2022)

FaunaDB: A global serverless database that gives you ubiquitous, low latency access to app data, without sacrificing data correctness and scale. (08 March 2024)

Faust: Faust (Functional Audio Stream) is a functional programming language for sound synthesis and audio processing with a strong focus on the design of synthesizers, musical instruments, audio effects, etc. (24 May 2024)

Fay: A proper subset of Haskell that compiles to JavaScript. (01 July 2021)

FBSL: Freestyle Basic Script Language (FBSL) is a programming language. It's powerful. It's easy to learn. It can produce GUI or console-based applications. It can produce standalone executables. It's free for non-commercial use. (24 May 2024)

fe: Tiny, embeddable language implemented in ANSI C. (24 May 2024)

Feedback Fallacy: "Radical candor" feedback doesn't actually work; instead, prefer to accentuate what the individual already does well and build on that. (06 April 2022)

Felix: An advanced, statically typed, high performance scripting language with native C++ embedding. (24 May 2024)

Fennel: Fennel is a lisp that compiles to Lua. It aims to be easy to use, expressive, and has almost zero overhead compared to writing Lua directly. (24 May 2024)

Feral: Dynamically-typed, imperative, interpreted programming language revolving around minimalism. (03 November 2022)

ferite: ferite is a scripting language and engine all in one managable chunk. It is designed to be easily extended in terms of API, and to be used within other applications making them more configurable and useful to the end user. It has a syntax similiar to a number of other langauges but remains clean and it's own language. (24 May 2024)

ferite: ferite is a scripting language and engine all in one managable chunk. It is designed to be easily extended in terms of API, and to be used within other applications making them more configurable and useful to the end user. It has a syntax similiar to a number of other langauges but remains clean and it's own language. It's origins are from one of those "it seems like a good idea", the good idea was provoked by finding perl a real pain in the arse to embed (from what I gather it's easier nowadays). It started in the summer of 2000 (with various tries and fails within the pre-ceding two years). It is slowly maturing and should be fit for general consumption by the first quarter of 2003, by which point we start to add more exotic features. (24 May 2024)

Fermat: Fermat is a computer algebra system for Macintosh, Windows, Linux, and Unix by me, Robert H. Lewis of Fordham University, that does arithmetic of arbitrarily long integers and fractions, multivariate polynomials, symbolic calculations, matrices over polynomial rings, graphics, and other numerical calculations. It is extremely fast and extremely economical of space. (24 May 2024)

FermaT: The FermaT Transformation System is a powerful industrial-strength program transformation system based on the WSL language. FermaT has been used sucessfully in several major assembler to C and assembler to COBOL migration projects involving the conversion of millions of lines of hand-written assembler code to efficient and maintainable C or COBOL code. (24 May 2024)

Fetlang: Fetish-themed programming language. (15 November 2020)

Ficl: Ficl is an acronym for "Forth Inspired Command Language". Ficl is a programming language interpreter designed to be embedded into other systems as a command, macro, and development prototyping language. (24 May 2024)

FIDO2 .NET: .NET library for FIDO2 / WebAuthn Attestation and Assertion. (01 January 2023)

FIDO Authentication: "The answer to the world's password problem." (24 August 2021)

FIFE (Flexible Isometric Free Engine): A free, open-source cross-platform game engine. It features hardware-accelerated 2D graphics, integrated GUI, audio support, lighting, map editor supporting top-down and isometric maps, pathfinding, virtual filesystem and more! (06 April 2022)

Figaro: Figaro is a probabilistic programming language that supports development of very rich probabilistic models and provides reasoning algorithms that can be applied to models to draw useful conclusions from evidence. Both model representation and reasoning algorithm development can be challenging tasks. Figaro makes it possible to express probabilistic models using the power of programming languages, giving the modeler the expressive tools to create a wide variety of models. Figaro comes with a number of built-in reasoning algorithms that can be applied automatically to new models. In addition, Figaro models are data structures in the Scala programming language, which is interoperable with Java, and can be constructed, manipulated, and used directly within any Scala or Java program. (24 May 2024)

FIJI: FIJI the ForthIsh Java Interpreter is an interactive environment with a procedural syntax similar to the Forth programming language. FIJI can load, introspect, and execute Java classes and methods. FIJI's main use is for unit and component testing of Java, or for an interpreter in an all-Java environment. (24 May 2024)

Fika: Statically typed functional programming language for the web, running on BEAM VM. (22 May 2024)

FileBytes: Library to read and edit files in the executable formats (16 May 2020)

Fileformat: A set of libraries and tools for representation, manipulation, and analysis of binary files in various object file formats (16 May 2020)

Filestash: A file manager that let you manage your data anywhere it is located. (06 April 2022)

Finch: A simple bytecode interpreted, purely object-oriented, prototype-based, dynamically-typed programming language. It's mostly inspired by Smalltalk, Self, and Javascript. (24 May 2024)

Finite and Infinite Games: A Vision of Life and Possibility (26 April 2022)

Finite State Machines: Collection of articles on finite state machines. (26 April 2022)

Firebase: A (pseudo)real-time NoSQL that also has platform capabilities. (30 July 2021)

Firefox (browser): The Firefox browser as a platform. (06 April 2022)

FiveTran: Fivetran, a FORTRAN language targeting Mako. Mako is an extremely simple stack-based virtual machine intended for the creation of video games. (24 May 2024)

FixScript: FixScript is an extensible scripting language designed for simple implementation and strong support for both backward and forward compatibility. You can use FixScript both as a standalone and embedded programming language. You can build standalone native executables for any supported platform from every platform. The best results are obtained when combined with the C language to get a very powerful tool. This way you can use the best of the two worlds, using the language for the high-level stuff and C doing the interoperability and fast stuff while having a good integration between both languages. (24 May 2024)

FJ (Functional Java): Functional library for Java. (06 April 2022)

Fjord: F# for the JVM (01 November 2020)

Flagsmith: Open source, fully featured, Feature Flag and Remote Config service. (29 December 2023)

Flapjax: A new programming language designed around the demands of modern, client-based Web applications. (01 July 2021)

FlatBuffers: An efficient OSS cross platform serialization library for a lot of mainstream programming languages. It was originally created at Google for game development and other performance-critical applications. (06 April 2022)

Flavor: Flavor (Formal Language for Audio-Visual Object Representation) is an object-oriented media representation language designed for simplifying the development of applications that involve a significant media processing component (encoding, decoding, editing, manipulation, etc.). It provides a formal way for describing any coded audio-visual or general multimedia bitstream, and it comes with a translator that can automatically generate C++/Java code from the Flavor description. The generated code can readily be used as a bitstream parser, generator or tracing tool. (24 May 2024)

Flax: Level, general-purpose language with high level syntax and expressibility. (22 May 2024)

flex: GNU implementation of the lex parser tool. (06 April 2022)

Flexmark-Java: A Markdown-to-AST parser library (04 May 2020)

Flint: Low-code development platform based on kubernetes. (07 June 2021)

Flix: Next-generation reliable, safe, concise, and functional-first programming language. Flix is a principled functional, imperative, and logic programming language developed at Aarhus University, at the University of Waterloo, and by a community of open source contributors. Flix is inspired by OCaml and Haskell with ideas from Rust and Scala. Flix looks like Scala, but its type system is based on Hindley-Milner. Two unique features of Flix are its polymorphic effect system and its support for first-class Datalog constraints. Flix compiles JVM bytecode, runs on the Java Virtual Machine, and supports full tail call elimination. A VSCode plugin for Flix is available. (24 May 2024)

Flix: Next-generation reliable, safe, concise, and functional-first programming language. (27 July 2021)

Flogo: An open source, resource efficient, Go-based ecosystem for building event-driven apps. It is designed to abstract the event processing paradigm from event consumption enabling devs to build once, consume from anywhere and process using any of the supported actions. (24 August 2021)

Flow: a safe, functional strongly-typed programming language. (24 May 2024)

FlubuCore: A cross platform build and deployment automation system. You can define your build and deployment scripts in C# using an intuitive fluent interface. (01 July 2021)

Fluent Validation: A .NET validation library for building strongly-typed validation rules. (12 July 2023)

Fluid: Create a Real Mac App (or "Fluid App") out of any website or web application, effectively turning your favorite web apps into OS X desktop apps. (16 December 2022)

Fluid Framework: A collection of client libraries for distributing and synchronizing shared state, allowing multiple clients to simultaneously create and operate on shared data structures using coding patterns similar to those used to work with local data. (24 August 2021)

Flutter: A functional/reactive cross-platform mobile framework. (01 January 2023)

Flutter Articles: A functional/reactive cross-platform mobile framework. (29 June 2023)

Flutter Examples: A functional/reactive cross-platform mobile framework. (20 January 2023)

Flutter for Windows: Collection of links and research around using Flutter to build Windows apps. (06 April 2022)

Fly (Fly.io): Run your full stack apps (and databases!) all over the world. No ops required. (14 June 2023)

Flyway: Relational(ish) database evolution and migration tool. (11 May 2023)

Folders (esoteric language): A programming language where the program is encoded into a directory structure; all files within are ignored. (29 May 2020)

Fonoster: APIs for SMS, voice and video. (06 April 2022)

Foolang: Smalltalk-inspired language. (22 May 2024)

Force.com: The Salesforce programming platform behind their CRM. (06 April 2022)

Foreign Function Interfaces (FFI): A collection of links and research on how various languages/vms handle interoperability with their host environment. (06 April 2022)

Forem: An open source platform for building modern, independent, and safe communities. (22 December 2022)

Forest: Multi-syntax functional programming language that compiles to WebAssembly. (06 April 2022)

Formality: Formality is an efficient proof language. An lightweight proof-gramming language. It aims to be: Fast: no garbage-collection, optimal beta-reduction, massively parallel compilers. Secure: a powerful type system capable of proving mathematical theorems. Portable: the entire language desugars to a 500 lines core type-theory. (24 May 2024)

Formbricks: Experience Management Suite built on the largest open source survey stack worldwide. (29 December 2023)

FormTools: A powerful, flexible, free and open source PHP/MySQL script you install on your website for managing your forms and data. (06 April 2022)

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. (06 April 2022)

Forscape: Scientific computing language. Forscape solves engineering problems with an unprecedented level of abstraction so you get reliable results quickly. This high-level approach starts with intuitive syntax. Program with the same notation you use to write equations thanks to our innovative math rendering with semantic formatting. Matrices, fractions, symbols- write code using the same notation you use to think through problems on the whiteboard. (24 May 2024)

Forth: Entirely stack-oriented programming language. (24 May 2024)

FORTRAN (FORmula TRANslator): An older language focused on mathematics. (24 May 2024)

Fortress: Discontinued research language from Sun around secure high-performance computing. (10 May 2020)

FPGA hardware architecture: A collection of reading materials on computer FPGA hardware and architecture: articles, courses, communities, HDL (Hardware Description Language), Open Source Hardware FPGA Projects, software, talks & videos. (25 November 2020)

Fractran: Turing-complete esoteric programming language invented by the mathematician John Conway. (22 May 2024)

Framework Laptops: Modular laptop, shipping, with swappable/upgradable components. (24 August 2021)

Franc: Natural language detection--infer the language from the text passed. (10 May 2020)

Frappe: Open source, metadata driven, full stack framework in Python and Javascript; comes with Admin UI, Roles and Permissions and much more. (07 June 2021)

Frawk: An efficient awk-like language. (06 April 2022)

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. (24 May 2024)

FreeOberon: Cross-platform IDE for development in Oberon programming language made in the classical FreePascal-like pseudo-graphic style. (24 May 2024)

FreePascal: A mature, versatile, open source Pascal compiler. (24 May 2024)

Free programming books: A collection of links to free/online reading about different languages and frameworks. (26 April 2022)

Free Programming Books: A collection of free learning resources (books). (29 September 2022)

Frege: Frege is a Haskell for the JVM. It brings purely functional programing to the Java platform. Like any Haskell, it is purely functional, enjoys a strong static type system with global type inference and non-strict - also known as lazy - evaluation. Frege compiles to Java, runs on the JVM, and uses any Java library you want. It can be used inside any Java project. (24 May 2024)

Frege: A functional language heavily Haskell-inspired for the JVM. (17 December 2022)

Frenetic: An open-source Software Defined Network (SDN) controller platform designed to make SDN programming easy, modular, and semantically correct, based on programming languages. (09 February 2024)

Frida: Dynamic instrumentation toolkit (01 July 2021)

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. (11 May 2024)

Froebel: A strictly typed utility library. (27 May 2022)

FScript: FScript is an extremely simple scripting language. Its intended use is as an embedded language in other Java programs. It is very simple to embed - it can be as simple as sub-classing one class to add your own functionality. However is not a complete programming language, as it has no library of standard functions (such as IO and string processing). FScript supplies a base functionality (such as flow control, variable handling and basic math operations) that can extended by the host application. (24 May 2024)

FSNotesApp: Modern notes manager for macOS and iOS. App respects open formats like GitHub Flavored Markdown, so you can easily write documents on iPhone and MacBook. (03 May 2022)

Ftwalk: Ftwalk is a general purpose script programming language. It is based on the concepts of Awk, but has been extended to support features such as are found in languages like Perl, Python, and Ruby. (24 May 2024)

FTXUI: C++ Functional Terminal User Interface. (11 May 2024)

fuite: A tool for finding memory leaks in web apps. (06 April 2022)

Fun: Programming language for the realtime web. (01 July 2021)

FuncSug: Language for GUI programming that allows program codes to follow the same order as the scenario. (22 May 2024)

Functa: Flexible, fully functional dynamic programming language. (22 May 2024)

FunctionalJ: A library which makes it easy to use functional programming constructs in Java code. (06 April 2022)

Functional reading: Ideas and concepts around functional programming. (26 February 2023)

FunctionSimSearch: Example C++ code to demonstrate how to do SimHash-based similarity search over CFGs extracted from disassemblies (16 May 2020)

Funnel: Funnel is a programming language based on Functional Nets. Functional Nets combine key ideas of functional programming and Petri nets to yield a simple and general programming notation. They have their theoretical foundation in Join calculus. (24 May 2024)

Fusion: Fusion is a programming language which can be translated automatically to C, C++, C#, D, Java, JavaScript, Python, Swift, TypeScript and OpenCL C. Instead of writing code in all these languages, you can write it once in Fusion. [Transpiler] (24 May 2024)

Futhark: A purely functional data-parallel programming language in the ML family. (30 May 2024)

Fux: Flawless Unambiguous Programming - A Modern, Flexible Programming Language for All. Fux is a modern and flexible programming language, perfect for use in a variety of domains by both novice and expert developers. With its efficient use of LLVM, it provides performance similar to C++, while being portable and running on a wide range of platforms. (24 May 2024)

Fuzion: A language with a focus on safety and performance. It unifies concepts found in other programming languages to improve productivity and shall provide tools for performance and correctness. (24 May 2024)

Fuzzing (as part of testing): A collection of reading and links on "fuzzing" during testing. (19 May 2022)

Fuzzy logic: Readings and links on fuzzy logic. (26 February 2023)

FX: Command-line tool and terminal JSON viewer. (06 April 2022)

Fyrox: A feature-rich, production-ready, general purpose 2D/3D game engine written in Rust with a scene editor. (26 February 2023)

fzf: A command-line fuzzy (search) finder. (19 May 2022)

Gaia: Build powerful pipelines in any programming language. (05 February 2024)

Gambas: A free development environment and a full powerful development platform based on a Basic interpreter with object extensions, as easy as Visual Basic. (30 May 2024)

Game Boy (Emulator/VM): A collection of links and articles on the Game Boy handheld game device. (06 April 2022)

GameBoy Development: Links and resources on building games for the GameBoy. (06 April 2022)

Game Development Ideas: Collection of links and ideas for games. (29 June 2023)

Game Frame: Using games as strategy for success. (27 November 2020)

GameMonkeyScript: Similar to Lua, multithreaded. (30 May 2024)

Game Programming Patterns: Source repo for the book. (30 December 2022)

Gamification and Game Mechanics Made Simple: Notes on the book. (06 April 2022)

GAML: GAML is an agent-oriented language dedicated to the definition of agent-based simulations. It takes its roots in object-oriented languages like Java or Smalltalk, but extends the object-oriented programming approach with powerful concepts (like skills, declarative definitions or agent migration) to allow for a better expressivity in models. (24 May 2024)

Garnet: what if Rust was small? (24 May 2024)

Gatsby (GatsbyJS): React-based static site generator. (01 July 2021)

GCC: A C/C++ (and other languages) compiler toolchain. g++, gcc, objdump, nm (19 December 2022)

GCC static analyzer options: GCC static analysis options and readings. (19 December 2022)

gdb (GNU debugger): Links and resources for using the GNU debugger. (06 April 2022)

GDL (GNU Data Language): A domain-specific data analysis and visualization programming language and a data analysis environment. (04 May 2020)

GDScript: Scripting language built into the Godot game engine. GDScript is a high-level, dynamically typed programming language used to create content. It uses a syntax similar to Python (blocks are indent-based and many keywords are similar). Its goal is to be optimized for and tightly integrated with Godot Engine, allowing great flexibility for content creation and integration. (24 May 2024)

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. (06 April 2022)

GeeCon: Java conferences in eastern Europe. (14 March 2023)

GeneralScript: GeneralScript is a lightweight general purpose scripting engine which provides Scheme like syntax. (24 May 2024)

Genesis: Genesis is an interpreted, procedural, and Turing-complete Paleo-Hebrew programming language. Diacritical signs are forgone for simplification, though maybe Nikud can be used in prospect as a means for more reserved keywords. (24 May 2024)

Genesis: God's actual programming language. (05 February 2024)

Gentee: Script programming language for automation. (06 April 2022)

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. (06 April 2022)

Geode: Apache Geode is a data management platform that provides real-time, consistent access to data-intensive applications throughout widely distributed cloud architectures. (Formerly GemStone GemFire.) (07 June 2021)

gh (Github CLI): The official GitHub CLI tool. (10 April 2022)

gh (Github CLI) command reference: Output from the "gh reference" command (on 8 April 2022). (10 April 2022)

Ghost: Small, class-based scripting language. (22 May 2024)

Ghost: A powerful app for new-media creators to publish, share, and grow a business around their content. It comes with modern tools to build a website, publish content, send newsletters & offer paid subscriptions to members. (06 April 2022)

Ghostly: A GitHub notification client for Windows 10/11. (06 April 2022)

Gideros: Open-source multi-platform Lua-scripted game engine. (30 November 2022)

GIMI: This is GIMI, the Graphical Interfaced Multitasking Interpreter. One of the few GUIs made in QuickBASIC featuring multitasking. This one has its own script language for making programs, damm fast SVGA modes, lots of programs, and more! (24 May 2024)

Giml: A functional programming language with emphasis on structural typing. (24 May 2024)

Giraffe: A functional ASP.NET Core micro web framework for building rich web applications. (06 April 2022)

Git: Distributed version-control system. (11 May 2024)

Gitea: Private, Fast, Reliable DevOps Platform. (05 February 2024)

Github: Popular open-source cloud repository built around Git. (26 February 2023)

Github Actions: Server-side pipeline execution on the GitHub platform. (26 April 2022)

GitHub Apps: Applications for execution as part of a GitHub pipeline. (06 April 2022)

GitHub Tools: A collection of Git/GitHub-flavored tools. (19 May 2022)

GitQL: A query-only language for exercising SQL-like read-only interrogation of Git repositories. (10 May 2020)

Glass: A powerful, general-purpose, OOP language capable to handle massive GUI and game rendering, yet it will be easy enough so any application could be written as quick as possible. (02 June 2023)

Gleam: A statically typed functional programming language for building scalable concurrent systems. (24 May 2024)

Glee: The Glee Programming Language is a new vector oriented interpretive computer programming tool. It is inspired by array oriented languages like APL, J, and K. It attempts to deliver many of the useful and powerful features of those languages for manipulating numeric data. Further, it strives to provide new functionality for consistent and powerful manipulation of character data. It is targeted at applications where languages like PERL, Python, and Java have found secure homes. These are all scalar languages so Glee has something new to bring to the party ... vector processing. (24 May 2024)

GLFW: Open Source, multi-platform library for OpenGL, OpenGL ES and Vulkan development on the desktop; provides API for creating windows, contexts and surfaces, receiving input and events. (04 May 2020)

GLICOL: Graph-oriented live coding language written in Rust. Make music with code. (22 May 2024)

Glide: Glide is a statically (and dynamically) typed language designed to make reading and writing data transformations easier. [refinement types] (24 May 2024)

Glimesh: Live streaming platform. (06 April 2022)

Glinda: Combines live programming, GUIs, and a DSL for data science. (06 April 2022)

GLMS: A scripting language focused on linear algebra, heavily inspired by GLSL and JavaScript. [algebra, shaders] (24 May 2024)

Global Software Architecture Summit (GSAS): Barcelona, Architecture, October. (24 February 2023)

Glulx: An interpreter for interactive fiction games written in Inform7. (01 July 2021)

Gluon: Static, type inferred and embeddable language written in Rust, inspired by Lua, Haskell, and OCaml, where each executing gluon thread gets a separate heap. (24 May 2024)

Gluon: A new framework for creating desktop apps from websites, using system installed browsers and NodeJS. (25 February 2023)

GluonJ: An extension to Java for supporting revisers, a language construct like Ruby's open class. (05 February 2024)

Glush: A new parser compiler based on Glushkov’s construction algorithm. (30 May 2024)

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. (06 April 2022)

GNU Smalltalk: The FSF implementation of the Smalltalk language/platform. (03 May 2021)

GNUStep: A foundation for a portable desktop environment (inspired by NeXTStep), seeking to be code-compatible with Apple's Cocoa. (06 April 2022)

Go: Compiled, statically typed in the tradition of Algol and C, with garbage collection, limited structural typing, memory safety features and CSP-style concurrent programming features added. (22 May 2024)

Go+: Designed for engineering, STEM education, and data science. (30 May 2024)

Goal: Goal is an embeddable array programming language with a bytecode interpreter, written in Go. It provides both a command line intepreter (that can be used in the REPL), and a library interface. The core features are mostly there and tested, so Goal is usable both for writing useful short scripts and playing with the REPL. User testing and bug reports are welcome! Like in most array programming languages, Goal's builtins vectorize operations on immutable arrays, and encourage a functional style for control and data transformations, supported by a simple dynamic type system with little abstraction, and mutable variables (but no mutable values). (24 May 2024)

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. (06 April 2022)

Goblin.tools: A collection of small, simple, single-task tools, mostly designed to help neurodivergent people with tasks they find overwhelming or difficult. (22 January 2024)

Goby: An object-oriented interpreter language deeply inspired by Ruby as well as its core implementation by 100% pure Go. (24 May 2024)

Gödel: Gödel is a declarative, general-purpose programming language in the family of logic programming languages. It is a strongly typed language, the type system being based on many-sorted logic with parametric polymorphism. It has a module system. Gödel supports infinite precision integers, infinite precision rationals, and also floating-point numbers. It can solve constraints over finite domains of integers and also linear rational constraints. It supports processing of finite sets. It also has a flexible computation rule and a pruning operator which generalises the commit of the concurrent logic programming languages. Considerable emphasis is placed on Gödel's meta- logical facilities which provide significant support for meta-programs that do analysis, transformation, compilation, verification, debugging, and so on (24 May 2024)

Godot Engine: A free and open source community-driven 2D and 3D game engine. (06 April 2022)

Gofra: Concatenative programming language (24 May 2024)

Gogs: A painless self-hosted Git service. (05 February 2024)

Golang Example: A collection of links to projects writing in the Go language. (06 April 2022)

Golo: A lightweight dynamic language for the JVM (01 November 2020)

Good Strategy Bad Strategy: A book on how to differentiate good strategy from bad strategy. (06 April 2022)

Google Cloud Platform (GCP): Huge collection of cloud services. (06 April 2022)

Google OSS: Google's collection of OSS projects. (06 April 2022)

Google re:Work Guides: Practices, research, and tools from Google to improve your people processes. (06 April 2022)

Gosu: Gosu is a pragmatic programming language for the JVM. It has been designed with Java developers in mind by providing a set of features that allow them to be more productive without sacrificing the benefits of Java's simple syntax and type-safety. Gosu is an object oriented language with a sprinkle of functional programming features. (24 May 2024)

Gosu: A 2D game development library for Ruby and C++. (06 April 2022)

Gosu: A scripting language capable of loading XML schema definition files and XML documents as native types. (11 August 2021)

GPP: GPP is a general-purpose preprocessor with customizable syntax, suitable for a wide range of preprocessing tasks. Its independence from any one programming language makes it much more versatile than the C preprocessor (cpp), while its syntax is lighter and more flexible than that of GNU m4. There are built-in macros for use with C/C++, LaTeX, HTML, XHTML, and Prolog files. (24 May 2024)

gptlang: A new programming language implemented by GPT-4. (13 January 2024)

GPU hardware Architecture: A collection of reading materials on computer GPU hardware and architecture: articles & papers, CUDA, open source hardware GPU projects, software, talks. (25 November 2020)

GraalVM: Polyglot VM from Oracle with support for a number of languages/platforms. (05 July 2022)

Grace: Ready-to-fork interpreted, typed, and functional language. (22 May 2024)

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. (03 May 2022)

Gradle: Build tool for JVM and Android environments using Groovy (later Kotlin) as build language. (06 April 2022)

Grain: Grain is a new language that puts academic language features to work. (15 November 2020)

Granule: Statically typed functional language with graded modal types for fine-grained program reasoning via types. (22 May 2024)

GraphDB(Lite): Fully Featured RDF Database for Massive Data and Moderate Query Loads. (02 June 2023)

GrapheneOS: A mobile operating system (03 October 2022)

GraphEngine: A distributed in-memory data processing engine, underpinned by a strongly-typed RAM store and a general distributed computation engine. (07 June 2021)

Graphics and Animation: A collection of links and pages around graphics (but not UI) programming. (06 April 2022)

GraphQL: A query language APIs can support to enable SQL-like behavior across APIs; supports both query and mutation, and can define complex entity descriptions. (06 April 2022)

GraphQL Mesh: Allows use of GraphQL query language to access data in remote APIs that don't run GraphQL (and also ones that do run GraphQL); can be used as a gateway to other services, or run as a local GraphQL schema that aggregates data from remote APIs. (01 July 2021)

Graphviz: The Graphviz layout programs take descriptions of graphs in a simple text language, and make diagrams in useful formats, such as images and SVG for web pages; PDF or Postscript for inclusion in other documents; or display in an interactive graph browser. (29 June 2023)

Gravity: A class-based concurrent scripting language with a Swift-like syntax; embeddable; no external dependencies; register-based virtual machine. (24 May 2024)

Great International Developer Summit: What used to be the Great Indian Developer Summit. (14 March 2023)

Greenfoot: Visual and interactive programming tutorial tool built on top of Java. (06 April 2022)

Gren: Gren is a pure functional programming language that is easy to learn, but powerful in use. (24 May 2024)

Gri: Gri is a language for scientific graphics programming. The word "language" is important: Gri is command-driven, not point/click. Gri can make x-y graphs, contour graphs, and image graphs, in PostScript and (someday) SVG formats. Control is provided over all aspects of drawing, e.g. line widths, colors, and fonts. A TeX-like syntax provides common mathematical symbols. (24 May 2024)

Groovy: Groovy is a powerful, optionally typed and dynamic language, with static-typing and static compilation capabilities, for the Java platform aimed at improving developer productivity thanks to a concise, familiar and easy to learn syntax. It integrates smoothly with any Java program, and immediately delivers to your application powerful features, including scripting capabilities, Domain-Specific Language authoring, runtime and compile-time meta-programming and functional programming. (24 May 2024)

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. (03 October 2022)

Grouparoo: Data synchronization framework. (06 April 2022)

gRPC: A high-performance, open source universal RPC framework (17 December 2022)

Gui4Cli: An interpreted, untyped, procedural programming language for easily creating Windows apps. (30 May 2024)

Guile: Guile is designed to help programmers create flexible applications that can be extended by users or other programmers with plug-ins, modules, or scripts. With Guile you can create applications and games for the [desktop](https://www.gnu.org/software/guile/#apps-using-guile), the [Web](https://www.gnu.org/software/guile/#apps-using-guile), the [command-line](https://www.gnu.org/software/guile/#apps-using-guile), and more. (24 May 2024)

GUILE: The GNU Ubiquitous Intelligent Language for Extensions. (29 June 2023)

Guix: An advanced distribution of the GNU operating system supporting transactional upgrades and roll-backs, unprivileged package management, and more. When used as a standalone distribution, Guix supports declarative system configuration for transparent and reproducible operating systems. It provides Guile Scheme APIs, including high-level embedded domain-specific languages (EDSLs) to define packages and whole-system configurations. (30 December 2022)

gute: Simple web games library. (12 May 2022)

GWBasic: Ancient predecessor to modern BASIC, for DOS. (11 July 2021)

Gwion: A strongly timed programming language for making music. (30 May 2024)

GYS: the scripting engine which helps to create the embedded interpreter of your own language. (30 May 2024)

Hack: An object-oriented application language influenced by PHP. (24 May 2024)

Haiku: The open-source flag-bearer for the now-defunct Be operating system. (24 February 2023)

Haka: An open source security oriented language (based on Lua) which allows to describe protocols and apply security policies on (live) captured traffic. (27 July 2021)

Hakaru: A simply-typed probabilistic programming language, designed for easy specification of probabilistic models and inference algorithms. (05 February 2024)

Halide: A language for fast, portable data-parallel computation. (30 May 2024)

Hamler: Haskell-style functional programming language running on Erlang VM. (30 May 2024)

Handbook of Software Architecture: Grady Booch's "thoughts" site. (24 August 2021)

Handel: A small procedural programming language for writing songs in the browser. (30 May 2024)

Hangfire: Background processing in .NET/.NET Core applications, backed by persistent storage. (24 February 2023)

Harbour: A multi-platform, multi-threading, object-oriented, scriptable programming language, backward compatible with Clipper/xBase. (30 May 2024)

Harbour: Portable, xBase compatible programming language and environment. (11 May 2024)

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. (24 May 2024)

Hascal: General purpose and open source programming language designed to build optimal, maintainable, reliable and efficient software. (30 May 2024)

HashLink: Virtual machine target for the Haxe programming language. (07 June 2023)

Haskell: Pure-functional language. (24 May 2024)

Haste: an implementation of the Haskell functional programming language, geared towards web applications; compiler generates JavaScript code from Haskell. (06 April 2022)

Hasura: Instant GraphQL on all your data. (11 May 2023)

Hasura: Blazing fast, instant realtime GraphQL APIs on your DB with fine grained access control, also trigger webhooks on database events. (05 July 2022)

Haxe: High-level and strictly-typed, cross-compiles to many different targets. (24 May 2024)

Hazel: Hazel, a live functional programming environment with typed holes (24 May 2024)

Hazure: ML-Inspired programming language that transpiles to Typescript. (30 May 2024)

HBase: Datastore for Apache "big data" projects. (07 June 2021)

HBR's 10 Must Reads 2021: Notes from the book. (18 May 2022)

HBR's 10 Must Reads for New Managers: Notes from the book. (18 May 2022)

HBR's 10 Must Reads on Building a Great Culture: Notes from the book. (18 May 2022)

HBR's 10 Must Reads on Diversity: Notes from the book. (18 May 2022)

HBR's 10 Must Reads on Entrepreneurship: Notes from the book. (18 May 2022)

HBR's 10 Must Reads on Leadership: Notes from the book. (18 May 2022)

HBR's 10 Must Reads on Managing People: Notes from the book. (18 May 2022)

HBR's 10 Must Reads on Managing Yourself: Notes from the book. (18 May 2022)

HBR's 10 Must Reads on Mental Toughness: Notes from the book. (18 May 2022)

HBR's 10 Must Reads on Platforms and Ecosystems: Notes from the book. (18 May 2022)

HBR's 10 Must Reads on Strategy: Notes from the book. (15 December 2022)

HBR's 10 Must Reads on Strategy, Vol 2: Notes from the book. (18 May 2022)

HBR's Everyday Emotional Intelligence: Notes from the book. (18 May 2022)

HBR's Guide to Making Every Meeting Matter: HBR's collection of essays on holding productive/useful meetings. (15 December 2022)

HBR's Guide to Office Politics: Notes from the book. (18 May 2022)

HBR's Guide to Performance Management: HBR's collection of essays on performance management. (05 July 2022)

HBR Manager's Handbook: Notes from the book. (18 May 2022)

HBuilder: Yet another mobile presentation framework/library. (01 August 2023)

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. (06 April 2022)

HeadlessCMS: A list of Content Management Systems for Jamstack sites. (01 July 2021)

Heaps: A mature cross platform graphics engine designed to leverage modern GPUs that are commonly available on both desktop and mobile devices. (13 June 2023)

Hecl: Mobile scripting language for the JVM. (30 November 2022)

Hedy: A gradual programming language to teach children programming. (30 May 2024)

Helios: An extensible open-source mobile backend framework with particular integration with iOS Core Data. (31 December 2022)

Hemlock: Synthesizes the expressive type and module systems of ML-family languages, a unified parametric effects/mutability/type system, and the shared-nothing message-passing parallelism of Erlang. (30 May 2024)

Hercules: An open source software implementation of the mainframe System/370 and ESA/390 architectures, in addition to the latest 64-bit z/Architecture. (01 July 2021)

Heresy: A functional Lisp/Scheme dialect implemented in Racket, with syntax inspired by the BASIC family of programming languages. (04 May 2020)

Hermes: A Javascript engine specifically for use by React Native. (16 May 2024)

Heroku: Cloud host, owned by Salesforce, offering developer-friendly cloud deployment. (16 May 2020)

Heron: A pure functional type-inferred language based on JavaScript. (24 May 2024)

Hetu: A lightweight scripting language written in Dart for embedding in Flutter apps. (03 November 2022)

Hexagonal architecture: Divides work inside and outside of an app instead of into layers. (01 July 2021)

HexagonKt: A microservices toolkit written in Kotlin, to ease the building of services (Web applications or APIs) that run inside a cloud platform. (08 March 2024)

Hexagons in Game Development: A collection of links around using hex-based maps in games. (06 April 2022)

Hexagony: Two-dimensional stack-based programming language. (22 May 2024)

Hexagony: A two-dimensional, hexagonal programming language. (12 July 2023)

Hex Fiend: A fast and clever open source hex editor for macOS. (29 June 2023)

Hexo: Javascript-based static site generator (01 July 2021)

HGSL: A shading language that can be compiled into GLSL ES 3.0. (24 May 2024)

HHVM: A virtual machine for executing programs written in Hack. (04 May 2020)

Hibiki: A powerful new web framework for creating modern, dynamic, frontend applications without JavaScript, that can be fully scripted and controlled by backend code. (06 April 2022)

HiggsJS VM: Higgs JavaScript Virtual Machine. A JIT compiler for JavaScript targetting x86-64 platforms. (27 July 2021)

High Scalability (Website) notes: Collection of notes from the blog http://highscalability.com/ (06 April 2022)

Hilla: Integrates a Spring Boot Java back end with a reactive TypeScript front end. It helps you build apps faster with type-safe server communication, included UI components, and integrated tooling. (18 May 2022)

Hilvi: A programming language that is versatile but with a very small syntax. (30 May 2024)

Historical Source That Every Developer Should See: Links to the modern era's software archaeology roots. (24 February 2023)

HLA (High Level Assembler): A higher-level assembler for a variety of different targets. By Randall Hyde. (06 April 2022)

Hobbes: Built for high performance integration with C/C++ applications. (30 May 2024)

Homebrew (Linuxbrew): Package management tool for macOS, Linux. (08 March 2024)

HonKit: Building beautiful books using Markdown. (30 May 2024)

Hood.ie: A fast, simple and self-hosted backend as a service for your (web) apps, Open Source and free. No need to write server-side code or database schemas. Makes building offline-capable software a breeze. (06 April 2022)

Hook: Cross-platform scripting language with a C-like syntax, dynamic typing, mutable value semantics approach, and memory management through reference counting. (30 May 2024)

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. (30 May 2024)

Hopper (Disassembler): Reverse engineering tool that lets you disassemble, decompile and debug your applications. (02 May 2022)

Hoppscotch: OSS replacement for Postman for API testing/exploration. (06 April 2022)

Horde3d: Small 3D rendering and animation engine written in an effort to create an engine being as lightweight and conceptually clean as possible. (04 May 2020)

Horizon: A realtime, open-source backend for JavaScript apps built on top of RethinkDB. (31 December 2022)

Horse64: Simple & versatile high-level programming language. (22 May 2024)

How to Design Programs: A book on the design of programs from core principles, using Lisps as implementation languages. (13 June 2023)

How to Successfully Market and API: Notes from the book. (22 December 2022)

HTMX: Thin layer over HTML, seeking to apply consistency and simplify the browser programming model. (19 June 2021)

Hugo: Go-based static site generator tool. (01 July 2021)

Hugo: Static site generator written in Go and using that language for its programmatic control. (30 March 2021)

Hugorm: Mission-critical scripting language. (22 May 2024)

Humanizer: All your .NET needs for manipulating and displaying strings, enums, dates, times, timespans, numbers and quantities. (01 January 2023)

Húngaro: A syntax based programming language. (24 May 2024)

Hunting Tech Debt via Org Charts: "As I talk other people through their legacy modernization struggles, the first piece of advice I give them is to look at the org chart." (06 April 2022)

Hush: Hush is a unix shell based on the Lua programming language. Hush is written in Rust. (24 May 2024)

Husky: Programming language designed for many difficult tasks which haven't yet been seen as programmable at all. (22 May 2024)

Husky: Research language aimed at next generation AI and software. (13 January 2024)

HVM: A pure functional compile target that is lazy, non-garbage-collected and massively parallel. It is also beta-optimal, meaning that, in several cases, it can be exponentially faster than most functional runtimes, including Haskell's GHC. (22 May 2024)

Hy: A dialect of Lisp that's embedded in Python. (24 May 2024)

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. (06 April 2022)

Hybris: An object oriented scripting language with dynamic typing. (09 July 2023)

Hylo: A programming language that leverages mutable value semantics and generic programming for high-level systems programming. (24 May 2024)

HyperCard: Apple's original "low-code" environment (06 April 2022)

HyperGraphDB: A general purpose, extensible, portable, distributed, embeddable, open-source data storage mechanism. It is a graph database designed specifically for artificial intelligence and semantic web projects, it can also be used as an embedded object-oriented database for projects of all sizes. (01 July 2021)

HyperSQL: Relational database written in Java. (06 May 2021)

Hypertalk: Apple's groundbreaking scripting language. (22 May 2024)

Hypertext Application Language (HAL): An open specification describing a generic structure for RESTful resources. (01 January 2023)

HyperText Markup Language (HTML): Text format providing hyperlink capability; Internet standard. (16 May 2020)

HyperText Transmission Protocol: Backbone protocol for the World Wide Web. (29 June 2023)

I: A language which generalizes the array and functional capabilities of the array-programming language J to deal with a much broader variety of data structures. (12 July 2023)

iBoxDB: Fast ACID Table-Style Document NoSQL Database. (18 December 2022)

iCal (iCalendar): An open standard for calendar events and appointments. (06 April 2022)

iced: A high performance x86 (16/32/64-bit) instruction decoder, disassembler and assembler. (01 July 2021)

Icepanel: Bridge the gap between design and reality with collaborative modelling; designed for agile teams. (06 April 2022)

ICodeBetter: An opinionated low code platform that helps you code business applications in a better way. (07 June 2021)

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. (01 July 2021)

IDA Pro: A powerful disassembler and a versatile debugger. (02 May 2022)

Idempotence is not a Medical Condition: Idempotence is an essential property for reliable systems; what is it, how do we do it, how can it go wrong, what to do about it. (30 May 2021)

IDL (Interactive Data Language): A programming language used for data analysis. (11 August 2021)

Idris: A dependently typed functional programming language. (24 May 2024)

Iguana: A parsing framework based on context-dependent grammars and top-down general context-free parsing. (10 May 2020)

IKOS (Inference Kernel for Open Static Analyzers): Static analyzer for C/C++ based on the theory of Abstract Interpretation. (01 July 2021)

IKVM: A Java Virtual Machine and Bytecode-to-IL Converter for .NET. (11 May 2023)

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. (06 April 2022)

IllaCloud: A low-code platform for developers to build internal tools in minutes. (18 December 2022)

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. (01 July 2021)

ILSpy: Open-source .NET assembly browser and decompiler. (01 July 2021)

ImageSharp: A modern, cross-platform, 2D Graphics library for .NET. (06 April 2022)

Imba: Imba is a friendly full-stack programming language for the web that compiles to performant JavaScript. It has language-level support for defining, extending, subclassing, instantiating and rendering DOM nodes. (24 May 2024)

ImGui: Bloat-free GUI for C++ with minimal dependencies. (20 March 2024)

ImHex: Hex editor of choice for reverse engineering. (24 February 2023)

Imp: Imp is a simple, incomplete, interpreted, imperative programming language. (06 October 2022)

Impact: A Javascript game engine for building HTML5 games for desktop and mobile browers. (06 April 2022)

Implementation Patterns: A collection of patterns around language atoms. (20 March 2024)

IndexedDB: A low-level API for client-side storage of significant amounts of structured data, including files/blobs. This API uses indexes to enable high-performance searches of this data. (15 May 2020)

Infer.NET: A framework for running Bayesian inference in graphical models. It can also be used for probabalistic programming (10 May 2020)

Inferno: An operating system created by Bell Labs that uses the same 9P distributed file system protocol (in Inferno lingo known as ‘Styx’), but can also run as a virtual machine on top of other operating systems as well as directly on hardware (specially well suited for embedded environments thanks to not requiring a MMU). (06 April 2022)

Infer Static Analyzer: A static analyzer for Java, C, C++, and Objective-C (and C# via InferSharp). (29 June 2023)

InfiniteGraph: Advanced Graph Database and Analytics for Enterprises and Government. (06 April 2022)

Influence: The Psychology of Persuasion. (03 May 2022)

Influence: The Psychology of Persuasion: Notes from and about the book (01 February 2023)

InfluxDB: Platform for building time series applications. (11 May 2023)

Inform6: A natural-language interactive fiction game development language and platform. (10 May 2022)

Inform 6: The latest version of the Inform 6 compiler, used for generating interactive fiction games. (24 May 2024)

Inform7: A natural-language interactive fiction game development language and platform. (10 May 2022)

Inform 7: Inform is a programming language for creating interactive fiction, using natural language syntax. Using natural language and drawing on ideas from linguistics and from literate programming, Inform is widely used as a medium for literary writing, as a prototyping tool in the games industry, and in education, both at school and university level (where Inform is often assigned material for courses on digital narrative). It has several times ranked in the top 100 most influential programming languages according to the TIOBE index. Created in April 2006, it was open-sourced in April 2022. (24 May 2024)

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. (06 April 2022)

injectdso: A collection of tools for injecting DSOs in processes under various operating systems. (16 May 2020)

Ink: Storytelling language behind some popular games. (24 May 2024)

Ink: Minimal programming language inspired by modern JavaScript and Go, with functional style. (22 May 2024)

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. (24 May 2024)

InnoDB: A storage engine for the database management system MySQL and MariaDB. (14 March 2023)

Instaparse: What if context-free grammars were as easy to use as regular expressions? (06 April 2022)

Instrew: Leveraging LLVM for High Performance Dynamic Binary Instrumentation. (01 July 2021)

Interactive Fiction: A collection of links and pages on IF. (10 May 2022)

Intercal: The first esoteric programming language. (30 May 2024)

IntercalScript: Systems programming language for the web that combines a simple and consistent syntax with a static type system that completely eliminates runtime type errors. (22 May 2024)

Internal: Web application builder optimized/intended for internal enterprise use. (05 July 2021)

Interviewing: Collection of links and ideas around tech intervews. (25 February 2023)

Inweb: Literate programming language used for Inform7 development. (29 April 2022)

Io: Inspired by Self, Smalltalk and LISP. (24 May 2024)

Ioke: A dynamic, strongly typed, prototype-based programming language with a very simple homoiconic syntax somewhat similar to Io. (10 May 2020)

Ionic: An open source UI toolkit for building performant, high-quality mobile and desktop apps using web technologies — HTML, CSS, and JavaScript — with integrations for popular frameworks like Angular, React, and Vue. (25 April 2022)

iOS (Platform): The Apple mobile device operating system (on top of the open-source Darwin kernel). (03 May 2022)

iOS Accessibility: Accessibility on the Apple mobile device operating system (on top of the open-source Darwin kernel). (03 May 2022)

iOS APIs and Design: Design and APIs around the Apple mobile device operating system (on top of the open-source Darwin kernel). (03 May 2022)

iOS App launch process: The process that takes place when launching an iOS app. (03 May 2022)

iOS AutoLayout: Trying to understand how AutoLayout works. (06 April 2022)

iOS Concurrency: Threads and queues on the Apple mobile device operating system (on top of the open-source Darwin kernel). (03 May 2022)

iOS Core Data: Making sense of iOS Core Data. (06 April 2022)

iOS Debugging: Debugging code on the Apple mobile device operating system (on top of the open-source Darwin kernel). (03 May 2022)

iOS Event Pipeline and Handling: How do events get queued and dispatched in iOS? (03 May 2022)

iOS Foundation: Using the Foundation frameworks on iOS. (04 May 2022)

iOS Open Source: A collection of iOS-related OSS links (06 April 2022)

iOS Performance: Performance and tuning the Apple mobile device operating system (on top of the open-source Darwin kernel). (03 May 2022)

iOS SwiftUI: SwiftUI user-interface style for the Apple mobile device operating system (on top of the open-source Darwin kernel) UI. (03 May 2022)

iOS UI: UI development for the Apple mobile device operating system (on top of the open-source Darwin kernel). (18 May 2022)

IPFS (InterPlanetary FileSystem) protocol: A peer-to-peer hypermedia protocol designed to preserve and grow humanity's knowledge by making the web upgradeable, resilient, and more open. (01 July 2021)

iPLAss: Java-based open source low-code development platform for enterprise (07 June 2021)

IRC (Internet Relay Chat): A chat protocol for the Internet. (06 April 2022)

Iron (IronMQ, IronWorker): Iron is Workers as a Service/Containers as a Service/Messaging Queue as a Service/Key-Value Store as a Service. (20 March 2024)

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. (06 April 2022)

Irony: .NET Language Implementation Kit. (06 April 2022)

Irrlicht: An open source cross-platform realtime 3D engine written in C++. (06 April 2022)

ISPC: Intel Implicit SPMD Program Compiler is a compiler for a variant of the C programming language, with extensions for single program, multiple data programming. Under the SPMD model, the programmer writes a program that generally appears to be a regular serial program, though the execution model is actually that a number of program instances execute in parallel on the hardware. [C dialect] (24 May 2024)

It's Your Ship!: "Management techniques from the best damn ship in the Navy." Destroyer captain's story of management principles learned from command. (06 April 2022)

IVy: Language and tool for specifying, modeling, implementing, and verifying protocols. (24 May 2024)

IvyScript: The IvyScript language is used to write business rules, for manipulating process data and to define data mappings for Axon.Ivy. Axon.ivy is a Digital Business Platform that simplifies and automates the interaction of humans with their digital systems. The platform is typically in charge of the most precious business cases where companies produce value." (24 May 2024)

J (programming language): A high-level, general-purpose programming language that is particularly suited to the mathematical, statistical, and logical analysis of data. (24 May 2024)

J*: J* is a dynamic embeddable scripting language designed to be as easy as possible to embed into another program. (30 May 2024)

Jacinda: Functional, expression-oriented data processing language. APL meets AWK. A command-line tool for summarizing and reporting, powered by Rust's regex library. (24 May 2024)

Jai: High-level programming language developed by Jonathan Blow. (22 May 2024)

jakt: Memory-safe systems programming language. Currently transpiles to C++. (24 May 2024)

JAMStack: Javascript, APIs, and Markdown presentation layer (06 April 2022)

Janet: Janet is a functional and imperative programming language and bytecode interpreter. It is a lisp-like language, but lists are replaced by other data structures (arrays, tables (hash table), struct (immutable hash table), tuples). The language also supports bridging to native code written in C, meta-programming with macros, and bytecode assembly. (24 May 2024)

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. (22 May 2024)

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. (06 April 2022)

Jank: Jank is a Clojure dialect which aims to offer the best of both worlds: dynamic and static. For both of these worlds, jank uses a single runtime, so the transition from one to the other is not only seamless, it can be gradual. (24 May 2024)

JanusGraph: A scalable graph database optimized for storing and querying graphs containing hundreds of billions of vertices and edges distributed across a multi-machine cluster. (06 April 2022)

Jasm: A JVM assembler for the modern age. (24 May 2024)

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. (06 April 2022)

Jason: A fully-fledged interpreter for an extended version of AgentSpeak, a BDI agent-oriented logic programming language. (13 July 2023)

Jasper: Command Execution Engine and Messaging Solution for .NET Systems. (01 July 2021)

Java: A statically-compiled, object-oriented language for the JVM. (06 April 2022)

Java/JVM Platform: The platform originally built by Sun for the Java programming experience, now expanded to include a number of languages, a ton of enterprise specifications, and hundreds if not thousands of popular libraries. (11 May 2023)

Java Concurrency in Practice: Goetz's seminal work on how concurrency works and operates on the JVM. (03 May 2022)

JavaEE (Enterprise Edition): A collection of specifications and implementations for the JavaEE platform. (11 May 2023)

Java Generic Algorithms (JGA): A functors library for Java; the intent is to explore and exploit functors (an object that encapsulates a function or expression) as a design and implementation tool to reduce boilerplate coding. (24 August 2021)

Javaland: Java in Germany (14 March 2023)

Javalin: A simple Web framework for Java and Kotlin. (09 February 2024)

Java Platform Specifications: A collection of the various specifications (JavaEE, etc) that make up the Java platform (11 May 2023)

Java RMI: Java's Remote Method Invocation distributed objects platform. (06 April 2022)

Javascript.NET: .Net bindings to the V8 JavaScript engine. (06 April 2022)

JavaScript Database (JSDB): (No summary) (30 March 2021)

JavaScript Object Notation (JSON): Object literal syntax from ECMAScript that's since taken off as a data storage and wire transfer format. (06 April 2022)

Javassist: Java bytecode engineering toolkit. (01 January 2023)

Java Virtual Machine (JVM): The execution engine and supporting structure for Java programs. (12 May 2022)

JavaZone: Java conference in Oslo, Norway. (14 March 2023)

JAX and variants: The Conference for Java, Architecture and Software Innovation, from SMS Media. (14 March 2023)

JBake: A JVM-based static site generator. (01 July 2021)

jBPM: A toolkit for building business applications to help automate business processes and decisions. (30 March 2021)

jc (JSON formatting tool): CLI tool and python library that converts the output of popular command-line tools and file-types to JSON or Dictionaries. This allows piping of output to tools like jq and simplifying automation scripts. (24 August 2021)

JCon Europe: In-person Java community conference in Germany organized by the Java User Group Oberpfalz in cooperation with JAVAPRO Magazine. (14 March 2023)

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. (01 July 2021)

JCrete: Heinz's unconference get-together on the isle of Crete. (14 March 2023)

Jeff Patton & Associates: A collection of articles/blogs on product thinking, design, and so on. (06 April 2022)

Jekyll: One of the original static site generators. (01 July 2021)

Jelly: XML based scripting and processing engine for turning XML into executable code, usually for performing some sort of processing action. (06 April 2022)

JESS (Java Expert System Shell): Rule engine language for Java based closely on CLIPS. (30 March 2021)

Jetlang: A high performance java threading library, based upon Retlang. (28 July 2021)

Jexer: An open-source 100% Java Text User Interface (TUI) originally designed to outwardly resemble the DOS-era Turbo Vision library--an advanced text windowing system framework to help new applications take full advantage of the terminal. (25 February 2023)

JFlex: A lexical analyzer generator (also known as scanner generator) for Java, written in Java. (16 May 2020)

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. (06 April 2022)

Jikes RVM: A flexible open testbed to prototype virtual machine technologies and experiment with a large variety of design alternatives. Jikes RVM runs on many platforms and advances the state-of-the-art of virtual machine technologies for dynamic compilation, adaptive optimization, garbage collection, thread scheduling, and synchronization. It is self-hosted, i.e. its Java code runs on itself without requiring a second virtual machine. Most other virtual machines for the Java platform are written in native code (typically C or C++). A Java implementation provides ease of portability and a seamless integration of virtual machine and application resources such as objects, threads, and operating-system interfaces. (06 April 2022)

Jini (Apache River): A programming model to build adaptive network systems that are scalable, evolvable, and flexible. (25 December 2020)

jint: Javascript Interpreter for .NET. (06 April 2022)

J-Integra: Java/Microsoft interoperability tools (Java-COM, Java-.NET). (11 May 2023)

Jinx: Designed for use in realtime applications such as video games. (24 May 2024)

JitBuddy: Provides a small helper method to disassemble to a x86/x64 ASM listing the native code generated by the JIT of a managed method. (01 July 2021)

Jitsi: Video conferences platform and SDK. (06 April 2022)

Jlama: A modern Java inference engine for LLMs. (11 May 2024)

JLex: A Lexical Analyzer Generator for Java. (16 May 2020)

JME: Java Math Expression - a powerful mathematical evaluator in Spanish and a structured script language, JMEScript, that makes use of it. (24 May 2024)

jMonkeyEngine: A modern developer friendly game engine written primarily in Java. (06 April 2022)

JMPLib: A dynamic language implementation library. (13 June 2023)

JNation: Get up to speed with the latest and greatest technology. (14 March 2023)

Job search links and articles: A collection of links and articles about the candidate side of the recruiting process. (10 April 2022)

Job sites: Sites that carry information about employers. Useful for researching new companies, too. (22 January 2024)

JogAmp: The home of high performance Java™ libraries for 3D Graphics, Multimedia and Processing. JOGL, JOCL and JOAL provide cross platform Java™ language bindings to the OpenGL®, OpenCL™, OpenAL and OpenMAX APIs. (06 April 2022)

Joget: An open source no-code/low-code application platform that combines the best of rapid application development, business process automation and workflow management. (07 June 2021)

Join Java: Language based on the join-pattern of join-calculus. (31 March 2021)

Jolie: A microservice/SOA programming language. (16 May 2020)

Joule: A message-based concurrent dataflow programming language, designed for building distributed applications. (10 May 2020)

Joy: A purely functional programming language based on composition of functions rather than lambda calculus. (24 May 2024)

JPC (Java PC): JPC is a fast modern x86 PC emulator capable of booting Windows up to Windows 95 (and windows 98 in safe mode) and some graphical linuxes; it has a full featured graphical debugger with time travel mode along with standard features like break and watch points. (01 July 2021)

JPrime: Enter the Java dimension, from Bulgarian Java User Group. (14 March 2023)

jQuery, jQuery Mobile: Fast, small, and feature-rich JavaScript library (libraries). It makes things like HTML document traversal and manipulation, event handling, animation, and Ajax much simpler with an easy-to-use API that works across a multitude of browsers. (25 April 2022)

jrnl: A command-line tool for journaling work activities on a device. (27 January 2023)

JS++: JS++ is a programming language designed for high-quality web and mobile development. (24 May 2024)

JSDB (JavaScript for Databases): JSDB is JavaScript for databases, a scripting language for data-driven, network-centric programming on Windows, Mac, Linux, and SunOS; it works with databases, XML, the web, and email, as a JavaScript shell, to run CGI programs, or as a web server. (30 May 2020)

js-event-bus: Simple event bus for Javascript applications. (01 January 2023)

JsonDB: A Opensource, Java-based, database. (18 December 2022)

JSON Web Token (JWT): An open, industry standard (RFC 7519) method for representing claims securely between two parties. (06 April 2022)

jSpringNL: The NLJUG Spring conference. (14 March 2023)

js-queue: An ES6 stack which allows for Last In First Out (LIFO) queuing. (06 April 2022)

Juka: Juka Programming Language - Rapid Prototyping Language built to run on Azure Microsoft Server. Juka's goal is to be a universal programming language that can run on any platform. Juka is being built on top of .NET network and runs on any platform that supports .NET. Juka can also compile programs into executables. (24 May 2024)

Julia: A flexible dynamic language, appropriate for scientific and numerical computing, with performance comparable to traditional statically-typed languages. (24 May 2024)

Juliet: A general purpose programming language. (24 May 2024)

June: What ordinary Java would look like if it were simpler. (27 July 2021)

JunoDB: PayPal's home-grown secure, consistent and highly available key-value store providing low, single digit millisecond, latency at any scale. (29 June 2023)

Jurassic: A .NET library to parse and execute JavaScript code. (06 April 2022)

JustPy: An object-oriented, component based, high-level Python Web Framework that requires no front-end programming and makes no distinction between front-end and back-end. (11 May 2024)

Juvix: A more elegant language for a more civilized age. Juvix synthesizes a high-level frontend syntax, dependent-linearly-typed core language, whole-program optimisation system, and backend-swappable execution model into a single unified stack for writing formally verifiable, efficiently executable smart contracts which can be deployed to a variety of distributed ledgers. (24 May 2024)

JVM (Platform) Data-related: Data storage and access on the JVM. (06 April 2022)

JVM-based languages: A collection of JVM-based languages and material (08 March 2024)

JVM Cross-Compilers: A collection of links/tools to compiling either Java or JVM bytecode to other platforms. (06 April 2022)

JVM FFI: A collection of links and notes around JVM foreign function interface and native bindings. (03 May 2022)

JVM Security: Collection of tools and practices around JVM security. (06 April 2022)

JVM Specifications: Specification links for the Java Virtual Machine (JVM). (06 April 2022)

JWEB: System of literate programming. (03 May 2022)

Jx9: An embeddable scripting engine that implements a Turing complete programming language based on JSON. (27 July 2021)

JXRay: JVM heap analysis tool. (24 February 2023)

Jython: Python implementation on the JVM. (20 December 2022)

K: A proprietary array processing programming language developed by Arthur Whitney and commercialized by Kx Systems. (24 May 2024)

KaboomJS: Javascript 2D game library. (11 May 2024)

KAGSA: KAGSA is a new Interpreted programming language based on Python, the language will be practical and reliable in your projects. (24 May 2024)

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. (06 April 2022)

Kalaam: Kalaam is the first-ever programming language in Hindi and has all the basic functionalities of a modern programming language. From for loops to while loops and from functions to conditional statements. (24 May 2024)

Kalix: Removes the hurdles of distributed data, distributed systems and all underlying architecture complexity. (26 February 2023)

kalk.dev: A powerful command-line calculator application for developers. (06 April 2022)

Kalyn: Self-hosting compiler from a Haskell-like Lisp directly to x86-64, developed fully from scratch. (24 May 2024)

Kansas City Developer's Conference: One of the Midwest's best tech-agnostic conferences. (14 March 2023)

Kara: Experimental programming language inspired by Swift and Idris. (22 May 2024)

Katahdin: A programming language where the syntax and semantics are mutable at runtime. (27 July 2021)

KataScript: KataScript is a simple scripting language with familiar syntax, designed to be easily embedded in C++ applications ([In-Browser Demo](https://brwhale.github.io/KataScript/)). (24 May 2024)

Kawa: Kawa is a general-purpose programming language that runs on the Java platform. It aims to combine: the benefits of dynamic scripting languages (non-verbose code with less boiler-plate, fast and easy start-up, a REPL, no required compilation step); with the benefits of traditional compiled languages (fast execution, static error detection, modularity, zero-overhead Java platform integration). (24 May 2024)

Kawa: A Scheme for the JVM (and one of the first at that). (11 May 2023)

KCL: KCL is an open-source, constraint-based record and functional language that enhances the writing of complex configurations, including those for cloud-native scenarios. With its advanced programming language technology and practices, KCL is dedicated to promoting better modularity, scalability, and stability for configurations. It enables simpler logic writing and offers ease of automation APIs and integration with homegrown systems. [Configuration] (24 May 2024)

Keli: A general purpose programming language where its semantics are mostly based on the pure functional programming model (as of Haskell's) which includes user-defined algebraic datatypes, case matching and higher-order functions, while its syntactic structure is strongly influenced by Smalltalk's message sending syntax, such as the unary, binary and keywords messages; moreover, it is almost homoiconic, in the sense that all non-literal expression are functions invocation, including object definition, control structures, type annotation etc. (22 May 2024)

Kempe: Compiled stack-based language. (24 May 2024)

Kernel: Conservative, Scheme-like dialect of Lisp in which everything is a first-class object. (22 May 2024)

Kew: Kew is a powerful but small object-oriented programming language that offers many advanced features, including proper closures, first-class variables, relations, continuations, exceptions, dynamic variables, security, transactions, persistence.... (24 May 2024)

Keystone (Assembler): A lightweight multi-platform, multi-architecture assembler framework. (06 April 2022)

KeystoneJS: Scalable, extensible and open-source platform to build NodeJS applications (01 July 2021)

Keyv: A consistent interface for key-value storage across multiple backends via storage adapters. It supports TTL based expiry, making it suitable as a cache or a persistent key-value store. (06 April 2022)

KFocus: Ubuntu-loaded laptops; "The Just-Works System". (25 May 2023)

Kha: Ultra-portable, high performance, open source multimedia framework. (07 June 2023)

Ki: A Lisp for your JavaScript (24 August 2021)

Kin: Kin is a straightforward programming language created with the purpose of aiding Kinyarwanda speakers in easily learning programming. (24 May 2024)

Kind: A next-gen functional language. (24 May 2024)

Kinto: A generic JSON document store with sharing and synchronisation capabilities. (06 April 2022)

Kinx: Looks like JavaScript, feels like Ruby, and it is the script language fitting in C programmers. (22 May 2024)

Kitten: A statically typed concatenative systems programming language. (24 May 2024)

Kivy: Python cross-platform GUI framework. (30 May 2024)

KiXtart: KiXtart is a free-format scripting language and has rich built-in functionality for easy scripting. It supports COM (providing access to ADSI, ADO, WMI, etc) and thus is easily extensible. Since version 4.50 KiXtart comes with inbuild pre-tokenization system for faster loading and smaller scripts and providing some level of intellectual property protection through obfuscation. 4.60 is the first version with com implementation which allows you to use kixtart from any windows application. 4.70 is the latest version (24 May 2024)

Klaxon: Minimalist RPN language that compiles to x86-64 assembly (24 May 2024)

Klong: Klong is an array language, like K, but without the ambiguity. If you know K or APL, you may be disappointed by Klong. If you don't know any array languages, it might explode your brain. Use at your own risk! (24 May 2024)

Klotho: Applies static analysis to create an adaptive architecture based on in-code annotations it introduces. It also produces the files needed to deploy, run and operate the application in your cloud of choice. (27 January 2023)

Knack: Commercial no-code tool; at its core it is an easy online database. (24 February 2023)

Knowledge Interchange Format (KIF): A computer-oriented language for the interchange of knowledge among disparate programs. (12 July 2023)

Ko: Generic type-safe language for concurrent, stateful, deadlock-free systems and protocol manipulations. (30 May 2024)

Koa: Next-generation web framework for node.js. (08 March 2024)

Kobra: A visual programming language for Machine Learning. (11 May 2024)

Kogut: Kogut is an experimental programming language which supports impurely functional programming and a non-traditional flavor of object-oriented programming. Its semantics is most similar to Scheme or Dylan, but the syntax looks more like ML or Ruby. (24 May 2024)

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. (24 May 2024)

Komodo Edit: A fast and free multi-language code editor written in JS, Python, C++ and based on the Mozilla platform. (15 December 2022)

KorGE: KorGE Game Engine. Multiplatform Kotlin Game Engine (05 July 2022)

Kotlin: An object language originally for JVM and later adopted for Android. (06 April 2022)

Kotlin Multiplatform: (No summary) (24 November 2023)

Koto: Embeddable scripting language, written in Rust. (22 May 2024)

Kotter: A declarative, Kotlin-idiomatic API for writing dynamic console applications. (20 March 2024)

Kraken (OpenKraken): High-performance web rendering engine, built on Flutter. (06 April 2022)

Kubernetes: An open source container orchestration engine for automating deployment, scaling, and management of containerized applications. (10 May 2022)

Kudu: The engine behind git/hg deployments, WebJobs, and various other features in Azure Web Sites. (01 January 2023)

Kuljet: Language for writing database-backed HTML applications. () (22 May 2024)

Kumulos: Secure, easy to use mobile app messaging & management platform (16 May 2020)

Kusto (query language): Query language for use with Azure Data Explorer. (06 April 2022)

Kuzzle: An Open Source backend solution that includes a scalable server, an HTTP/MQTT/websockets API, an admin console, plugins mechanism & a blazing fast real-time capabilities for search, pub/sub, geofencing or any complex use cases. (06 April 2022)

kvass: A personal key-value data store. (11 May 2023)

L.in.oleum: L.in.oleum is an unstructured, untyped, procedural programming language. And more specifically, it's a form of cross-platform assembly language. It is oriented to the developement of general-purpose applications, especially when 100% portability, execution speed and module compactness is requested. This language has an almost 1:1 source-to-CPU instruction ratio, allows direct access to five general-purpose registers (performing basic operations from a theoretical 2 up to a pratical of even 10 times faster than memory-held variables), and if used well, is averagely twice as fast as C in pure computational power. (24 May 2024)

L2: Minimalist type-inferred programming language with procedural macro support. (22 May 2024)

Labrys: Toy language based on LLVM that implements the System Fω type-system. (22 May 2024)

Lakka: The open source game console; a lightweight Linux distro that transforms a small computer into a retrogaming console. (11 May 2024)

Lama: Programming language developed for educational purposes as an exemplary language to introduce the domain of programming languages, compilers and tools. (22 May 2024)

lambda-ski: Small functional language with a combinator based graph-reduction machine. (22 May 2024)

langcc: A collection of tools for language development. (30 May 2024)

Langium: An open source language engineering tool with first-class support for the Language Server Protocol, written in TypeScript and running in Node.js. (16 December 2022)

Language Development: A collection of links and articles on building programming languages. (30 May 2024)

Languages reading: A collection of links and articles on different programming languages. (12 July 2023)

Lark: Lark is an experiment in designing a homoiconic language with a syntax inspired by SmallTalk. It's very early, so there isn't much to see yet, but you can play with it. (24 May 2024)

Lasca: LLVM-based statically or dynamically typed strict functional programming language. Simplified OCaml if you will. (22 May 2024)

Launchrock: A launch site in minutes to capture early users and supercharge your marketing. (16 May 2020)

Lawrence Livermore National Labs (LLNL): Software portal for projects built at LLNL. (24 August 2021)

Lawvere: Categorical programming language with effects. (22 May 2024)

LDPL: A free, powerful, compiled, open-source programming language designed from the ground up to be excessively expressive, readable, fast and easy to learn. (24 May 2024)

Leading Change: How to not fail at digital transformation efforts. (02 June 2021)

Leafscript: Leafscript is a lightweight programming language created as a proof of concept by someone with no idea how to write a language. It's written entirely in Golang, and was inspired by the speed and simplicity of Lua. (24 May 2024)

Lean: A functional programming language that makes it easy to write correct and maintainable code. (24 May 2024)

LeanQt: A stripped-down Qt version easy to build from source and to integrate with an application. (25 February 2023)

Learn X in Y Minutes: Website collection of numerous "Learn You" style tutorials. (06 April 2022)

Lemick: Lemick is a programming language with BASIC syntax, it's a typed and a compiled language, its source is compiled into a platform-independent virtual machine assembler that is later transformed into a platform-dependent representation by the just-in-time compiler. Lemick supports concurrent and distributed programming (multi-threading and distributed multi-threading). Rendezvous are used for message passing; replicas and ultra-weak consistency model implement distributed shared memory simulation. Extension of exception handling mechanism, including distributed version is being developed now. Lemick favors mixed procedural and object-oriented programming style. (24 May 2024)

Lemon: An LALR(1) parser generator maintained as part of the SQLite project. (06 April 2022)

Leo: Functional, statically-typed programming language built for writing private applications. (24 May 2024)

Leo: An Outliner, Editor, IDE and PIM written in 100% Python. (03 May 2022)

Let's Build a Compiler (Jack Crenshaw): A very good tutorial on writing a simple compiler in 16 articles. By Jack W. Crenshaw. (30 May 2024)

Letlang: Functional language with a powerful type system. (24 May 2024)

LevelDB: A very fast and lightweight, embedded database; part of the Chrome browser (exposed as IndexedDB). (30 May 2020)

Levels of War: Differing levels of war (strategic, operational, etc) articles. (30 May 2021)

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. (06 April 2022)

Lia: High-Level Language for Rust. (22 May 2024)

Liberating Structures: Simple Rules to Unleash a Culture of Innovation (06 April 2022)

libGdx: Cross-platform game development built using Java/JVM languages. (13 June 2021)

libGdx Articles: Articles about libGdx. (31 March 2021)

libGdx Ashley library: Entity system library for libGdx. (31 March 2021)

libGdx Examples: Examples of libGdx, a cross-platform game development built using Java/JVM languages. (31 March 2021)

libGdx Tutorials: Tutorials about cross-platform game development built using Java/JVM languages. (11 May 2023)

libgit: A portable, pure C implementation of the Git core methods provided as a re-entrant linkable library with a solid API, allowing you to write native speed custom Git applications in any language which supports C bindings. (01 July 2021)

liblg: Minimal stack-based VM. (22 May 2024)

liblg: Minimal stack-based VM. (22 May 2024)

LibObjectFile: A .NET library to read, manipulate, and write linker and executable object files (ELF, DWARF, ar). (01 July 2021)

Libra: Libra is a basic stack-based programming language simulated through Haskell. Heavily inspired by Porth and Forth (24 May 2024)

Libra: Libra - Lazy Interpreter of Binary Relational Algebra (24 May 2024)

Library of Congress's Sustainability of Digital Formats: One of the premiere resources in the world for in-depth information about digital file formats. It covers over 525 formats, encodings and wrappers in a variety of content categories – sound recordings, still images, datasets, textual materials, moving images, website and web archives, geospatial, music composition, 3D and architectural drawings and many more. (03 May 2022)

Library to Instrument Executable Formats (LIEF): The purpose of this project is to provide a cross platform library which can parse, modify and abstract ELF, PE and MachO formats. (16 May 2020)

libSQL: A next-gen fork of SQLite. (01 August 2023)

libui: Simple and portable (but not inflexible) GUI library in C that uses the native GUI technologies of each platform it supports. (06 October 2022)

Lice: A multi-paradigm programming language running on JVM (09 July 2023)

Lightning: Presentation layer for the Salesforce platform. (24 July 2021)

Lightscript: A Concise Syntax for JavaScript. A close superset of ES7 with JSX and Flow, built with Babel. (06 April 2022)

Light Table (IDE): A Chromium-based IDE tool. (03 May 2022)

lila (li[chess in sca]la): A free online chess game server focused on realtime gameplay and ease of use. (06 April 2022)

Lily: A programming language focused on expressiveness and type safety. (30 May 2020)

Limbo: A concurrent programming language for the Inferno operating system that was also an ancestor to Go. (06 April 2022)

LineageOS: A free and open source operating system for mobile devices. (08 March 2024)

Linear ML: Functional language for parallel programming. (30 May 2024)

Linguist: Language Savant; used on GitHub.com to detect blob languages, ignore binary or vendored files, suppress generated files in diffs, and generate language breakdown graphs. (09 February 2023)

Links: A functional programming language designed to make web programming easier. (08 March 2024)

linq2db: LINQ to database provider. (06 April 2022)

Linux (OS): The original open-source operating system. (11 May 2024)

Lioness: A high-level, dynamic, programming language designed for mathematical purposes. (06 October 2022)

LiquidFun: a 2D rigid-body and fluid simulation C++ library for games based upon Box2D. It provides support for procedural animation of physical bodies to make objects move and interact in realistic ways. (06 April 2022)

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). (24 August 2021)

Lisp: The original dynamic functional(ish) homoiconic (consistent symbology) language. (24 May 2024)

LispE: A _Lisp_ implementation with _Data Structure_, _Arithmetic Type_, _Array Instructions_, _Pattern Matching_ and many many different instructions and libraries. _LispE_ is a mix of functional and array languages. (24 May 2024)

Lists: Languages: Collection of articles, books I recommend around general compilers/interpreters topics. (19 December 2022)

Lit: A simple library for building fast, lightweight web components. (25 April 2022)

Lit: Elements on top of WebComponents. (06 April 2022)

LiteDB: An open source MongoDB-like database with zero configuration - mobile ready. (24 August 2021)

Literate: A literate programming tool for any language (05 February 2024)

Literate programming: The prose-combined-with-code concept started by Knuth. (26 April 2022)

literateprogramming.com: A website dedicated to literate programming and documentation/code tools. (03 May 2022)

LITTLE: LITTLE is a new programming language, looking like LISP, but pure Object-Oriented. (24 May 2024)

Littlefoot: A little language for little people. (15 July 2023)

LiveCode: Commercial open-source cross-platform low-code (natural language expression) platform. (20 June 2021)

LiveKit: SFU and SDKs for high-performance, scalable WebRTC. (06 April 2022)

Lively Kernel: A new approach to Web programming available that provides a complete platform for Web applications, including dynamic graphics, network access, and development tools. (06 April 2022)

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. (01 July 2021)

Lizard: Lizard is a domain-specific language to define and control hardware behaviour. It is intended to run on embedded systems which are connected to motor controllers, sensors etc. Most of the time it is used in combination with a higher level engine like ROS or RoSys. You can think of the microcontroller as the machine's lizard brain which ensures basic safety and performs all time-critical actions. (24 May 2024)

LLJVM (Low Level Java Virtual Machine): A set of tools and libraries for running comparatively low level languages (such as C) on the JVM. (08 March 2024)

LLVM: A compiler and back-end native compilation/linking toolchain. (11 May 2023)

LLVM (toolchain): A collection of tools and libraries for building languages (and language-related tools). (06 April 2022)

LMAX Disruptor: A framework which has "mechanical sympathy" for the hardware it's running on, and that's lock-free. (16 May 2020)

LMQL: A programming language for LLMs; Robust and modular LLM prompting using types, templates, constraints and an optimizing runtime. (24 May 2024)

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. (24 May 2024)

Logica: A logic programming language that compiles to StandardSQL and runs on Google BigQuery. (06 April 2022)

LogicJS: Logic programming for JavaScript. (06 April 2022)

Logo: The classic "turtle" language. (01 November 2022)

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. (24 May 2024)

LokiJS: Super fast in-memory javascript document oriented database. (06 April 2022)

Loko: Loko is an interactive interpreter for the Logo programming language targeting MakoVM, an extremely simple stack-based virtual machine intended for the creation of video games. Logo is best known for beginner-oriented "Turtle Graphics" functionality, but internally the language is actually a dynamically-scoped member of the Lisp family. As such, Logo provides sophisticated list manipulation facilities and support for higher-order functions. (24 May 2024)

LoLa: Small programming language meant to be embedded into games. (22 May 2024)

LOLCODE: Programming in l33tsp33k (30 December 2022)

LOLCODE Specification (1.2): The 1.2 version of the LOLCODE language (24 August 2021)

LoopbackJS: A highly extensible Node.js and TypeScript framework for building APIs and microservices. (09 February 2024)

Lore: General-purpose programming language featuring multi-functions, structs and traits, structural typing enabling component-based programming, and intersection and semantic types. (22 May 2024)

Love2D: Lua-based game engine. (06 April 2022)

Low-Code/No-Code reading: A collection of thoughts about low-code and no-code platforms. (09 December 2022)

Low-code platforms (definition, reading, etc): Reading and notes around low-code platforms. (13 January 2024)

Lowdefy: An open-source low-code framework to build web apps, admin panels, BI dashboards, workflows, and CRUD apps with ease. (07 June 2021)

Lox: jlox & clox implementations of educational Lox language from great book "Crafting Interpreters". (24 May 2024)

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. (03 November 2022)

LSCRIPT: The Lcomp Scripting Engine is a scripting engine written in Visual BASIC for DOS 1.0 that can be used by a programmer to write automatated scripts to perform routine actions in DOS. It can be used as a simple automation tool or a vast programming language (24 May 2024)

LSTS: LSTS is a proof assistant and maybe a programming language. Proofs in LSTS are built by connecting terms, type definitions, and quantified statements. Terms can be evaluated to obtain Values. Types describe properties of Terms. Statements describe relations between Terms and Types. (24 May 2024)

Lua: Scripting language often embedded into game engines for extensibility. (24 May 2024)

Luau: Fast, small, safe, gradually typed embeddable scripting language derived from Lua. (24 May 2024)

Lua VM: Implementation docs and notes for the Lua virtual machine. (25 February 2023)

Luban: (No summary) (06 April 2022)

Lucee: CFML application server/engine. Lucee provides a lot of functionality (tags and functions) to deal with all kinds of web related actions. Manipulating images, PDF files, XML, string, numbers, dates and a lot more. (18 November 2020)

Luf: Statically typed, embeddable, scripting language written in Zig. (22 May 2024)

Lumberyard: Amazon's game engine for AAA games. (11 May 2023)

Luna: Data processing and visualization environment. (22 May 2024)

Lush: Object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications. (24 May 2024)

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. (24 August 2021)

Lux: Lux is a new programming language in the making. It's meant to be a functional, statically-typed Lisp that will run on several platforms, such as the Java Virtual Machine and JavaScript, Python, Lua, or Ruby interpreters. (24 May 2024)

Lux: Meant to be a functional, statically-typed Lisp that will run on several platforms, such as the Java Virtual Machine and JavaScript interpreters. (27 July 2021)

Luxe: 2D-first/3D game engine prioritizing design and workflow for rapidly expressing ideas. (04 May 2020)

Luxury: Statically programming language which is targeting embedded programming. (22 May 2024)

lviv: Stack-based RPN functional programming language. Written in Scheme. (22 May 2024)

LWJGL (LightWeight Java Game Library): A Java library that enables cross-platform access to popular native APIs useful in the development of graphics (OpenGL, Vulkan), audio (OpenAL) and parallel computing (OpenCL) applications. (13 June 2021)

Lys: A language that compiles to WebAssembly. (21 November 2020)

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. (24 May 2024)

m4: A general-purpose macro processor (a text-replacement tool, employed to re-use text templates). (30 May 2021)

Mach-O: macOS executable file format. (06 April 2022)

macOS (OS): The Apple operating system (on top of the open-source Darwin kernel) that ships with Apple computers. (12 July 2023)

macOS (OS) Development: Writing code for the Apple operating system (on top of the open-source Darwin kernel) that ships with Apple desktop computers. (30 March 2021)

macOS (OS) usage: Tips on using the Apple desktop operating system (on top of the open-source Darwin kernel) that ships with Apple computers. (22 January 2024)

macOS (OS) Virtual Machine Notes: Running the Apple desktop operating system (on top of the open-source Darwin kernel) in a virtual machine. (22 January 2024)

macOS Open Source: A collection of macOS-related OSS links (06 April 2022)

macOS Setup: macOS Setup tools and scripts. (22 January 2024)

Macro Lambda Calculus: lambda calculus using interaction nets, providing CLI and API. Its browserified version is available as [an online demo](https://codedot.github.io/lambda/). (24 May 2024)

Magic-trace: High-resolution traces of what a process is doing (26 April 2022)

Magmide: A dependently-typed language intended to make provably correct code possible for working software engineers. (24 May 2024)

Magnet: Magnet is an object-oriented programming language, that is prototype-based to the point of real types being absent in favor of duck types. E.g. every object providing a read method that returns a readable, is considered "readable" (meaning it can represent a string). Since this causes a recursion, there must be some "primal" readable to end that: Such primal readable is also known as a String Object in Magnet. Furthermore, Magnet is syntax driven. This means: Everything that can be done to reduce code, retain simplicity and to amaze the developer, IS done! (24 May 2024)

Magpie: A toy language interpreter, written in Go. It has C-style syntax, and is largely inspired by Ruby, Python, Perl and c#. (24 May 2024)

Magpie: (05 February 2024)

MailChimp: Email/marketing platform. (16 May 2020)

Makam: Tool for rapid language prototyping. (22 May 2024)

Make: A build tool with some dependency-based tracking available. (06 April 2022)

Maker: Maker, a Forth-inspired compiled language targeting Mako. Mako is an extremely simple stack-based virtual machine intended for the creation of video games. (24 May 2024)

Makeshift: Programming language that was designed to bootstrap the Ashet Home Computer. (22 May 2024)

MakoForth: MakoForth is a small Forth dialect targeting MakoVM, an extremely simple stack-based virtual machine intended for the creation of video games. MakoForth should be moderately familiar to anyone who has been exposed to ANS-Forth. The major notable differences are the use of # as line comments, loop...(break)...again|until|while looping constructs and the inclusion of syntax for inline double-quoted string constants. Cells are always 32-bit two's complement signed integers. (24 May 2024)

Malbolge: A programming language designed to be difficult (or impossible) to program in. (30 May 2024)

MAME: A multi-purpose "vintage" software emulation framework. (01 July 2021)

Management and Admins Reading: Thoughts, notes, and links on how to work with admins (13 June 2023)

Management frameworks: A collection of leadership/management frameworks/scaffolding, for thinking about how to frame steps and thinking. (02 June 2023)

Management reading: Collection of thoughts/essays/etc on managing people. (11 May 2024)

Manager Pool: Collection of management patterns. (06 April 2022)

Managing Humans: Managing technical teams of people. (06 April 2022)

Managing Oneself: Most of us have to learn to manage and develop ourselves, which also means know how and when to change the work we do. (02 June 2021)

Mango: A Java library of a iterators, algorithms and functions. (24 August 2021)

MANOOL: MANOOL is a programming language designed with an idea to maximize the expressive power / implementation complexity ratio. (24 May 2024)

Manticore: High-level parallel programming language aimed at general-purpose applications running on multi-core processors. (22 May 2024)

Mantra: (Might be a TParr class assignment?) (02 August 2021)

Marco: Safe, Expressive Macros for Any Language (30 May 2021)

Mare: Reimagining of the Pony language in Crystal. (22 May 2024)

MariaDB: Open-source relational database. (14 March 2023)

Markdig: A CommonMark-compatible Markdown parser. (14 January 2024)

Markdoc: A Markdown-based syntax and toolchain for creating custom documtation sites. (18 May 2022)

Markdown: Text-based markup language originally intended for easy HTML creation. (24 August 2021)

Marketing Myopia: The reason growth is threatened, slowed, stopped is not because the market is saturated; it is because there has been a failure of management. (02 June 2021)

MarkovJunior: MarkovJunior is a probabilistic programming language where programs are combinations of rewrite rules and inference is performed via constraint propagation. MarkovJunior is named after mathematician Andrey Andreyevich Markov, who defined and studied what is now called Markov algorithms. (24 May 2024)

Marp: Markdown presentation ecosystem. (06 April 2022)

Marten: Transactional Document DB and Event Store on PostgreSQL. (01 July 2021)

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. (03 May 2022)

Mash: Untyped, lightweight, crossplatform OOP language. (24 May 2024)

MASICA: An educational interactive TinyBASIC interpreter targeting MakoVM, an extremely simple stack-based virtual machine intended for the creation of video games. MASICA is designed to provide an absolute minimum of features and complexity while including what is necessary to illustrate core imperative programming concepts such as variables, iteration and conditional branches. Variable names are single letters. The MASICA interface is similar to that of early 8-bit microcomputers- a prompt which can evaluate commands immediately or store a sequence of commands prefixed with line numbers. Several commands for removing or editing existing lines are also provided. (24 May 2024)

MassiveJS: A data mapper for Node.js that goes all in on PostgreSQL and embraces the power and flexibility of SQL and the relational model. (06 April 2022)

Mastodon: Free, open-source decentralized social media platform. (18 December 2022)

Mastodon: a free, open-source social network server based on ActivityPub where users can follow friends and discover new ones. On Mastodon, users can publish anything they want: links, pictures, text, video. All Mastodon servers are interoperable as a federated network (users on one server can seamlessly communicate with users from another one, including non-Mastodon software that implements ActivityPub)! (19 May 2022)

Mattermost: An open source platform for secure collaboration across the entire software development lifecycle. (11 May 2023)

Maude: Maude is a high-performance reflective language and system supporting both equational and rewriting logic specification and programming for a wide range of applications. Maude has been influenced in important ways by the OBJ3 language, which can be regarded as an equational logic sublanguage. Besides supporting equational specification and programming, Maude also supports rewriting logic computation. (24 May 2024)

Maxine-VM: A meta-circular research VM; a next generation, highly productive platform for virtual machine research.. (08 March 2024)

Mbeddr: mbeddr is a set of integrated and extensible languages for embedded software engineering, plus an IDE. It supports implementation, testing, verification and process aspects. It integrates with command-line build tools and integration servers, as well as file-based version control systems. mbeddr has support for requirements and product line definition, software documentation, implementation in C and C extensions such as state machines physical units or interfaces and components, as well as testing, mocking, as well as formal verification. mbeddr comes with a state-of-the-art IDE including syntax coloring, code completion, go to definition, realtime type checks, quick fixes, refactorings, customizable find-usages, automated synchronization between related parts of the code, version control integration and debugging. (24 May 2024)

MCPL: MCPL is a simple typeless language which is based on BCPL. It makes extensive use of pattern matching somewhat related to that used in ML and Prolog, and some other features come from C. (24 May 2024)

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. (01 July 2021)

MDP: A command-line based markdown presentation tool. (20 March 2024)

Mech: Language for developing data-driven, reactive systems like animations, games, and robots. (22 May 2024)

MediaCloud: An open-source platform for media analysis. (31 December 2022)

MedusaVM: Aims at running pre-existing Python code without any or minimal modification at a much faster rates compared to the usual implementations by leveraging Dart and the DartiumVM. (20 December 2022)

Meeting Design: Notes from the book. (30 December 2022)

Meeting the Challenge of Disruptive Change: Innovation and disruption. (02 June 2021)

Megamek: An open-source implementation of BattleTech, in Java. (06 April 2022)

Melody: Melody is a language that compiles to regular expressions and aims to be more easily readable and maintainable. (24 May 2024)

Memgraph: A streaming graph application platform that helps you wrangle your streaming data, build sophisticated models that you can query in real-time. (06 April 2022)

Memory Management and Garbage Collection (reading and references): Papers, books, and thoughts around manual and automatic memory management (GC). (06 April 2022)

Mendix: Commercial (free trial) low-code application development platform. (05 July 2021)

Mercat: Mercat is not really useful for anything much. It is, on the other hand, an excellent example of how to implement a self-hosted recursive-descent-parsed language and virtual machine (24 May 2024)

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. (24 May 2024)

Merlin: An simple actor-based programming language. (30 May 2024)

Mermaid: Generation of diagram and flowchart from text in a similar manner as markdown. (06 April 2022)

Meson: Yet another build tool for C++. (01 August 2023)

Message passing (reading): A mechanism of communication or control flow in which a block of data is explicitly constructed and communicated to the recipient. (06 April 2022)

MetaCall: MetaCall is an extensible, embeddable, and interoperable cross-platform polyglot runtime. It supports NodeJS, Vanilla JavaScript, TypeScript, Python, Ruby, C#, Java, WASM, Go, C, C++, Rust, D, Cobol and more. (24 May 2024)

Metadata-Connect: A massively scalable metadata (data about the data) management platform hosted in the cloud. (06 April 2022)

METAL: METAL is a 100% free extended BASIC language metacompiler for PowerMac. (24 May 2024)

MetaLang 99: A functional language for C99 preprocessor metaprogramming. (24 May 2024)

Metalua: A Lua code analysis tool, as well as a compiler for a superset of Lua 5.1 supporting Compile-Time Meta-Programming. (05 February 2024)

Metamine: Completely declarative programming language. (22 May 2024)

Metaobject Protocol (MOP): Building on top of object systems, metaobject protocols allow for changing the "surface area" of objects at runtime. (06 April 2022)

Metawidget: A smart widget that populates itself, either statically or at runtime, with UI components to match the properties of your domain objects. (01 July 2021)

Meteor: An open source framework for seamlessly building and deploying Web, Mobile, and Desktop applications in Javascript. (06 April 2022)

Mewl: Program in cats' language. (03 November 2022)

MewMew: /ᐠ。ꞈ。ᐟ\ MewMew Programming Language - Program in Cats' Language (03 November 2022)

micro-mitten: Bare-bones Rust-like programming language, stripped down to simplify control-flow structures and the type system. (22 May 2024)

MicroPython: Implements the Python 3.4 syntax and some of the core datatypes. (18 November 2020)

Microservices: Reading on microservices architecture. (05 July 2022)

Microservices (resources): A collection of resources and links on microservices. (08 March 2024)

Microservices DSL: A Domain-Specific Language (DSL) to specify (micro-)service contracts, their data representations and API endpoints. (09 February 2024)

Microsoft Office (libraries, specifications, etc): Various libraries to manipulate Microsoft Office files. (05 July 2021)

Microsoft Office Protocols and Formats: Detailed technical specifications for Microsoft protocols that are implemented and used by Office to interoperate or communicate with other Microsoft products. (01 January 2023)

Microsoft Open Specifications Site: A single site with many of Microsoft's Open Specification documents (05 July 2021)

Microsoft OSS: Microsoft's collection of open-source projects. (06 April 2022)

Microsoft PowerApps: Low-code apps on Microsoft platform. (30 May 2021)

Microsoft PowerToys: Collection of useful utilities for Windows. (10 May 2022)

Microsoft Resarch (MSR): Microsoft's collection of research projects. (10 May 2020)

Microsoft SQL Server: Microsoft's relational database implementation. (06 April 2022)

Microsoft XNA: Microsoft's (since-cancelled) game development framework. (06 April 2022)

MicroWF: A simple finite state machine (FSM) with workflow character where you define your workflows in code. (20 January 2023)

Middleman: A static site generator using all the shortcuts and tools in modern web development. (06 April 2022)

mimir: An experimental rule engine written in Clojure. (06 April 2022)

min: Tiny concatenative programming language and shell. (22 May 2024)

Min: A Prototype-based language with syntax inspired by Io and Ruby, topped with Python's indentation (but only when you want to). (24 May 2024)

MingW32: Win32 port of GCC and other utilities for running on the Win32 platform. (06 April 2022)

MiniAgda: Prototypical dependently typed languages with sized types and variances. (22 May 2024)

MiniGDX: A minimalist game framework using Kotlin multiplatform. (13 June 2021)

miniKanren: An embedded Domain Specific Language for logic programming. (08 January 2023)

Minio: S3 compatible object storage. (06 April 2022)

MiniScript: MiniScript is modern, elegant, easy to learn, and easy to embed in your own C#, C++ or Kotlin projects. (24 May 2024)

miniVM: A small and fast cross-language Virtual Machine (VM) written in good ol' C, meaning it can compile and run just about anywhere. (06 April 2022)

Minix: The classic educational operating system that was the inspiration and starting point for Linux. (06 April 2022)

Minsk: Minsk, a handwritten compiler in C#. It illustrates basic concepts of compiler construction and how one can tool the language inside of an IDE by exposing APIs for parsing and type checking. (24 May 2024)

Minsk: A handwritten compiler in C#, illustrating basic concepts of compiler construction. (26 February 2023)

Mint: A package manager that installs/runs executable Swift command-line tool packages. (23 April 2022)

Mint: A refreshing programming language for the front-end web. (15 November 2020)

Minze: Dead-simple JS framework for native web components. (06 April 2022)

MIPS Assembly: A brief overview of MIPS assembly. (06 April 2022)

Mirah: Mirah is a customizable programming language featuring static types, local type inference and a heavily Ruby-inspired syntax. Mirah currently includes a typer/compiler backend for the JVM which can output JVM bytecode. (24 May 2024)

Mirah: A programming language based on Ruby language syntax, local type inference, hybrid static–dynamic type system, and a pluggable compiler toolchain. (01 November 2020)

Miranda: A pure, non-strict, polymorphic, higher order functional programming language that later inspired Haskell. (27 July 2021)

Mirth: a new concatenative programming language, inspired by Forth, Joy, Haskell, Idris, Rust, Lisp, ATS, and monoidal category theory. (24 May 2024)

Misc: Misc is a simple but powerful programming language, designed especially for performing efficient calculations. Development of the Misc Engine is currently continued as part of the Descend project (24 May 2024)

Miso: A small, production-ready, "isomorphic" Haskell front-end framework for quickly building highly interactive single-page web applications. (30 May 2021)

Mission-Critical Meetings: Notes from the book. (25 May 2023)

Mistral: An experimental language for distributed programming, with an emphasis on the specification and maintenance of a virtual overlay network. (03 November 2022)

Mithril: Another client-side JS framework for building Single-Page Applications. (27 December 2020)

MIX-MIXAL: MIX is Donald Knuth's mythical computer as described in his monumental work The Art Of Computer Programming. As any of its real counterparts, the MIX features registers, memory cells, an overflow toggle, comparison flags, input-output devices, and a set of binary instructions executable by its virtual CPU. You can program the MIX using an assembly language called MIXAL, the MIX Assembly Language. (24 May 2024)

Mizu: API traffic viewer for Kubernetes enabling you to view all API communication between microservices. Think TCPDump and Wireshark re-invented for Kubernetes (10 May 2022)

Mkdocs: A static site generator that's geared towards building project documentation; doc source files are written in Markdown, and configured with a single YAML configuration file. (08 July 2023)

ML: A strictly-functional language that later inspired OCaML and others. (30 May 2024)

Mlatu: Statically typed, stack-based purely functional programming language designed for simplicity, speed, and safety. (22 May 2024)

ML-I: ML/I is a general purpose macro processor. (24 May 2024)

MLIR: A hybrid IR which can support multiple different requirements in a unified infrastructure. (08 July 2023)

mLite: a lightweight (and slightly odd) inhabitant of the ML universe. Much like ML, but with dynamic typing, guards, and a Haskell-style apply operator. (30 May 2024)

Mn: A truly minimal concatenative programming language. (24 May 2024)

MoarVM: A VM with adaptive optimization and JIT compilation, built for Rakudo (04 May 2020)

Mobile Angular UI: A mobile UI HTML/CSS/JS framework based on Angular and Twitter Bootstrap. (25 April 2022)

mobl: A mobile application language and framework. (26 May 2022)

Mochi: A dynamically typed programming language for functional programming and actor-style programming. (05 February 2024)

Modeling Languages: A website about modeling languages. (24 February 2023)

Modern Compiler Implementation: This book covers compiler theory, design, and implementation. (30 May 2024)

Modula-2: Modula-2 is a programming language developed by Niklaus Wirth at ETH in Zurich, Switzerland in the late 70's. Wirth also developed Algol-W, Pascal, Modula, and Oberon. Modula-2 corrects some of the deficiencies of Pascal. It is suitable for learning programming, for large projects written and maintained in the fashion of professional software engineers, and for real time embedded systems. Modula-2 is small, expressive, easy to learn and to read. (24 May 2024)

Modula-3: Critical Mass Modula-3. (24 May 2024)

Mojo: The usability of Python with the performance of C, unlocking unparalleled programmability of AI hardware and extensibility of AI models. (24 May 2024)

Monaca: Cross-platform hybrid mobile app development platform and tools in the cloud. (25 April 2022)

Monads: Collection of articles on monads (and monoids and related subjects). (08 March 2024)

Mond: A scripting language for .NET Core. You can try it in a browser [here](https://rohbot.net/mond/). (24 May 2024)

Mond: A scripting language for .NET Core. (15 November 2020)

MongoDB: Document-oriented network storage. (18 May 2022)

Monicelli: An esoteric programming language, come se fosse antani. (05 February 2024)

Monkey: Monkey is a programming language designed by Thorsten Ball. (24 May 2024)

Monkey-2: Monkey2 is an easy to use, cross platform, games oriented programming language from Blitz Research. (24 May 2024)

Monkey-X: A games oriented programming language from Blitz Research. (24 May 2024)

Mono.Cecil: A library to inspect, modify and create .NET programs and libraries. (01 July 2021)

MonoGame: Spiritual successor to XNA; a CLR-based open source game framework. (20 March 2024)

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. (01 July 2021)

Moonscript: A dynamic scripting language that compiles to Lua. (24 May 2024)

Mops: A full featured, stand-alone development environment for programming the Macintosh written by Mike Hore. Inspired by Smalltalk and the commercial language Neon, Mops is based on Forth with extended object-oriented features such as multiple inheritance, early and late binding, persistent objects, and garbage collection. (24 May 2024)

morloc: Typed, polyglot, functional language. (22 May 2024)

morph: A mostly pure functional programming language (24 May 2024)

Morphic: A style of "direct-manipulation" (of objects) user interface first seen in the Self language/environment and later adopted by other object platforms. (06 April 2022)

Motion: Motion is a clean, dynamically typed programming language, created in C with no dependencies. (24 May 2024)

Motoko: Simple high-level language for writing Internet Computer canisters (08 March 2024)

Motorway: An esoteric programming language based around the British motorway network. (24 May 2024)

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. (22 January 2024)

Move: A new programmable platform for blockchains and other applications where safety and correctness are paramount. (24 May 2024)

Mozilla Developer Network (MDN): Web development resources. (30 May 2020)

MPS (Meta-Programming System): JetBrains' language-development workbench and environment. (24 August 2021)

MQTT: A Client Server publish/subscribe messaging transport protocol. (03 October 2022)

MQTTnet: A high performance .NET library for MQTT based communication. It provides a MQTT client and a MQTT server (broker). (01 January 2023)

MRI (Matz's Ruby Interpreter): The original fully-interpreted Ruby VM. (20 December 2022)

MSBuild: A build system from Microsoft heavily inspired by Ant. (11 May 2023)

Mu: Minimal-dependency hobbyist computing stack. (22 May 2024)

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. (30 December 2022)

Mu (Code Editor): A simple Python editor for beginners. (30 December 2022)

Mu (Scripting language): A lightweight scripting language designed to be easily embedded into existing projects. (30 December 2022)

Multi-Dimensional and Hierarchical Database Toolkit: A Linux-based, open sourced, C/C++ toolkit of portable software that supports fast, flexible, multi-dimensional and hierarchical storage, retrieval and manipulation of information in data bases ranging in size up to 256 terabytes. (22 December 2022)

Multi-Paradigm Design in C++: Some ways to think about object-oriented design and design in general. (06 April 2022)

Multipliers: How the best leaders make everyone smarter. (02 June 2023)

Mun: A programming language empowering creation through iteration. (24 May 2024)

Muon: Modern low-level programming language. (24 May 2024)

Mux: An API that enables developers to build unique live and on-demand video experiences. (06 April 2022)

Myia: Myia is a new differentiable programming language. It aims to support large scale high performance computations (e.g. linear algebra) and their gradients. The main application Myia aims to support is research in artificial intelligence, in particular deep learning algorithms. (24 May 2024)

mypy: Mypy is an optional static type checker for Python that aims to combine the benefits of dynamic (or "duck") typing and static typing. (30 May 2024)

Myst: Structured, dynamic, general-purpose language. (22 May 2024)

N8N: Node-based workflow automation tool for developers. (06 April 2022)

Naked Objects: The practice of generating UI (and, optionally, persistence) directly from domain objects without compilation requirements. (06 April 2022)

Naked Objects Framework: Turns a POCO domain model (that follows a few simple conventions) into a complete application. (01 July 2021)

Nannou: A library that aims to make it easy for artists to express themselves with simple, fast, reliable code. (26 February 2023)

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. (24 July 2021)

NanoVM: A java virtual machine for the Atmel AVR ATmega8 CPU, the member of the AVR CPU family used e.g. in the DLR Asuro robot, manufactured by AREXX engineering. (06 April 2022)

Nasal: Nasal: Not another scripting language! Vectors, Hashes and Scalars (number/strings) "Normal" OOP syntax Small! 146k source code. Easily embeddable and extensible Functional programming Garbage collected Threadsafe (24 May 2024)

nasm (Netwide Assembler): A portable-ish assembler. (06 April 2022)

Natalie: A (work-in-progress) Ruby implementation, compiled to C++ (native). (06 April 2022)

NativeScript: Single-source Javascript-based cross-mobile platform. (15 May 2020)

NATS: A simple, secure and high performance open source messaging system for cloud native applications, IoT messaging, and microservices architectures. (16 May 2020)

Natural Language Processing (NLP) places: A collection of NLP links. (03 May 2022)

Natural Language Processing for Semantic Search: Learn how to make machines understand language as people do. This free course covers everything you need to build state-of-the-art language models, from machine translation to question-answering, and more. (06 April 2022)

Nature: Nature is the modern systems programming language and compiler, striving for elegant and concise syntax while prioritizing the writing and reading experience for developers. Key features of nature at the language level include: Type system, null safety, generics, union types In-house compiler/assembler/linker, not reliant on llvm. Supports compilation for amd64/riscv64/wasm architectures Non-intrusive interaction with C for efficient and high-performance development Progressive GC, supports both automatic and manual GC Built-in vec/map/set/tup data structures Package and module management Function tags/closures/error prompts/runtime stack traces/coroutines Integrated SSA/linear scan register allocation/reflection/assembler & linker (24 May 2024)

Nazo ML: Experimental implementation of temporal-logic-based Hindley-Milner type system. (30 May 2024)

NDatabase: OODBMS native and transparent persistence for .NET. (01 July 2021)

Neat: A "D-lite" (subset of D) language. (06 April 2022)

NeDB: The JavaScript Database, for Node.js, nw.js, electron and the browser. (30 May 2020)

Negotiation reading: Collections of articles and links on negotiation. (06 April 2022)

Neko (Language): A high-level dynamically typed programming language and virtual machine. (24 May 2024)

Neko (VM): The NekoVM is a target for several compilers, including Haxe. (11 May 2023)

Nelua: Minimal, simple, efficient, statically typed, compiled, meta programmable, safe and extensible systems programming language with a Lua flavor. (24 May 2024)

Nemerle: A general-purpose, multi-paradigm programming language for the .Net platform; metaprogramming is based on macros bearing some similarity to Lisp. (06 May 2021)

Neo4J: Industry standard for graph-oriented database. (11 May 2023)

Neon: High-level, statically typed, garbage collected, imperative programming language intended for teaching and learning the craft of programming. (22 May 2024)

Neosphere: A lightweight game engine and development platform using JavaScript for game coding, based on the original Sphere engine by Chad Austin but with a redesigned, modern API and brand-new command-line development tools. (06 April 2022)

Neptune: Fast, concurrent and embeddable scripting language. (24 May 2024)

Netflix OSS: Netflix's collection of OSS projects. (06 April 2022)

Netlify: JAMstack-focused cloud platform. (06 April 2022)

Netlify CMS: Git-based CMS for static site generators. (01 August 2023)

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. (10 May 2020)

Neut: Dependently-typed programming language based on the Calculus of Constructions. (24 May 2024)

Never: A statically typed functional programming language. (24 May 2024)

NewLang: NewLang is a high-level programming language that combines standard algorithmic constructs with declarative programming and tensor computing for machine learning problems. The main feature of the language is an easy, logical and non-contradictory syntax, which is not based on the use of reserved keywords, but on a strict system of grammatical rules using punctuation marks (which also includes language operators). (24 May 2024)

newRPL: newRPL is a re-implementation of the HP48/49/50 series calculators programming environment. The RPL scripting language is being redesigned and recreated with even more powerful features. (24 May 2024)

Newspeak: A language in the tradition of Self and Smalltalk, dynamic and reflective, but designed to support modularity and security. (01 May 2021)

Nexe: A tool to create a standalone executable out of nodejs apps. (13 June 2021)

Nextcloud: A personal cloud which runs on your own server. (06 April 2022)

NextJS: Browser-based React framework. (30 May 2020)

NeXTSpace: A desktop environment that brings a NeXTSTEP look and feel to Linux. (06 April 2022)

NHost: An open-source Firebase alternative with GraphQL; easy-to-use, full-featured backend-as-a-service (Baas) for your web and mobile apps. (11 August 2021)

Niall: An array language, like APL, J, or K, but with a more english-like syntax. (24 August 2021)

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. (24 May 2024)

NiceGUI: A Python-based UI framework, which shows up in your web browser. (11 May 2024)

Nickel: Write complex configurations. Modular, correct and boilerplate-free. (11 May 2024)

Nickle: Nickle is a programming language based prototyping environment with powerful programming and scripting capabilities. Nickle supports a variety of datatypes, especially arbitrary precision numbers. The programming language vaguely resembles C. Some things in C which do not translate easily are different, some design choices have been made differently, and a very few features are simply missing. Nickle provides the functionality of UNIX bc, dc and expr in much-improved form. It is also an ideal environment for prototyping complex algorithms. Nickle's scripting capabilities make it a nice replacement for spreadsheets in some applications, and its numeric features nicely complement the limited numeric functionality of text-oriented languages such as AWK and PERL. (24 May 2024)

Nim: A compiled, garbage-collected systems programming language with a design that focuses on efficiency, expressiveness, and elegance (in that order of priority). (24 May 2024)

Nimskull: An in development statically typed systems programming language; with sustainability at its core. We, the community of users, maintain it. (24 May 2024)

Ninja: A small build system with a focus on speed. (01 July 2021)

Nit: Nit is an expressive language with a script-like syntax, a friendly type-system and aims at elegance, simplicity and intuitiveness. (24 May 2024)

Nitric: A framework for cloud and serverless apps. (03 May 2022)

Nitrite: An open source nosql embedded document store written in Java with MongoDB like API that supports both in-memory and single file based persistent store. (18 December 2022)

Nix: Expression language for the Nix package manager. The Nix expression language is a pure, lazy, functional language. (24 May 2024)

Nix/NixOS/nixpkgs: A tool that takes a unique approach to package management and system configuration. (22 January 2024)

Nixt: Interpreted lisp inspired programming language written in Rust. (22 May 2024)

NLTK: A leading platform for building Python programs to work with human language data. (03 May 2022)

NMemory: A lightweight non-persistent in-memory relational database engine that is purely written in C# and can be hosted by .NET applications. (24 August 2021)

Nocobase: An open source and free no-code development platform. (24 February 2023)

NocoDB: The Open Source Airtable alternative. (13 March 2024)

NodeJS (platform): A platform built around the V8 (Javascript) engine. (06 April 2022)

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. (24 August 2021)

Node Rules: A light weight forward chaining Rule Engine, written in JavaScript for both browser and node.js environments. (06 April 2022)

Noisecraft: Browser-based visual programming language and platform for sound synthesis. (05 February 2024)

Noja: A very high level language in the same range of abstraction as languages like Ruby, Python and Javascript. (24 May 2024)

Nomad: A simple and flexible scheduler and workload orchestrator to deploy and manage containers and non-containerized applications across on-prem and clouds at scale. (06 April 2022)

Noms: The versioned, forkable, syncable database. (30 March 2021)

Nools: Rules engine inference and enforcement in JS. (01 August 2023)

No One Understands You: and What To Do About It (06 April 2022)

North-Hollywood Python: A strongly-typed, memory-safe, compiled dialect of Python, that transpiles to human-readable C. (30 May 2024)

NosDB: A 100% native .NET Open Source NoSQL Database, extremely fast and linearly scalable and allows your .NET applications to handle extreme transaction loads (XTP). (27 May 2020)

Nosica: An Object-Oriented language, with a syntax similar to Java or C++, and with advanced high level features such as a strong type system, automatic memory management, and global code optimisation. (30 May 2024)

Notable Design Patterns for Domain-Specific Languages: We describe eight recurring patterns that we have identified as being used for DSL design and implementation. (26 February 2023)

notc: This is a simple interpreter with c-like syntax. (24 May 2024)

Noulith: Browser-based visual programming language and platform for sound synthesis. (14 December 2022)

Novika: A moldable, concise, expressive language in the spirit of Forth, Self, Red/Rebol, and Lisp. (13 January 2024)

Nox: A programming language focusing on performance and memory/thread safety. (30 May 2024)

NPL: NPL or Neural Parallel Language is an open source, high-performance scripting language. (30 May 2024)

NRefactory: Currently unmaintained parser/compiler frontend for C#. (01 July 2021)

nScript: Script language similar to C. (30 May 2024)

NScript: A tool similar to Microsoft's WScript except that it allows scripts to be written in .NET languages such as C#, VB.NET and JScript.NET. (30 May 2024)

Nu: An interpreted Lisp that builds on the Objective-C runtime and Foundation framework. (29 June 2023)

Nuklear: A single-header ANSI C immediate mode cross-platform GUI library. (21 February 2021)

nullc: Fast C-like programming language with advanced features. (24 May 2024)

NuoDB: Distributed SQL database. (06 April 2022)

nuweb: A Simple Literate Programming Tool. (03 May 2022)

Nuxt: Vue-based static site generator. (01 July 2021)

NXUI: NXUI (nex-ui), next-gen UI - Create minimal Avalonia applications using C# 10 and .NET 6 and 7. (29 June 2023)

Nylo: A declarative programming language that takes some constructs from functional and logic paradigms, aims to be simple and clear, but powerful. (01 November 2022)

nyx: Dynamically typed scripting language. (01 November 2022)

Oak: Expressive, simple, dynamic programming language. (24 May 2024)

OASIS Advanced Message Queue Protocol (AMQP): The global standard enterprise messaging protocol. (03 October 2022)

OAT (Android Runtime): Android runtime file format. (16 May 2020)

OAuth: Specification for third-party authentication. (09 February 2023)

Oberon: Predecessor to Pascal and a lot of concepts: Oberon, Oberon-2, Active Oberon, Modula-2/3, Oberon-07, and Component Pascal (Blackbox Oberon). (24 May 2024)

Oberon+: A general-purpose, procedural and object-oriented programming language in the tradition of Oberon-07 and Oberon-2. (30 May 2024)

Oberon+: A successor to Pascal with some interesting elements. (01 August 2023)

Objeck: An object-oriented programming language with functional features. (30 May 2024)

Object-capability model: A capability describes a transferable right to perform one (or more) operations on a given object. (06 April 2022)

Object Constraint Language: A formal language used to describe expressions on UML that typically specify invariant conditions that must hold for the system being modeled or queries over objects described in a model. (30 January 2023)

ObjectDB: A powerful Object-Oriented Database Management System (ODBMS) whose native API is the Java Persistence API (JPA). (18 December 2022)

Objective-C: The other object-oriented take on C, based much more directly on the message-passing principles of Smalltalk. (06 April 2022)

Objective-C (Platform): The platform underlying the Objective-C (and, by extension, Swift) languages. (03 May 2021)

Objective-J: A new programming language that is a superset of JavaScript and based on Objective-C. (30 May 2024)

Objective Lua: An almost pure superset of Lua that welds the Objective C object orientation system and syntax on top of the classic Lua language. (30 May 2024)

Objective-S: Smalltalk-ish language. (30 May 2024)

Objectivity/DB: A scalable, high performance, distributed Object Database (ODBMS). (06 April 2022)

ObjectScript: A general purpose object-oriented programming language. (30 May 2024)

ObjectScript: A general purpose object-oriented programming language for the JVM. (30 November 2022)

Object Thinking: Approaches to object-oriented design and thinking. (06 April 2022)

Obsidian: A powerful knowledge base on top of a local folder of plain text Markdown files. (06 April 2022)

OCaml: An object-functional hybrid language and platform. (30 May 2024)

OCaml for the Masses: Why the next language you learn should be functional (26 November 2020)

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. (06 April 2022)

Ockam: A suite of open source tools, programming libraries, and managed cloud services to orchestrate end-to-end encryption, mutual authentication, key management, credential management, and authorization policy enforcement – at massive scale. (24 February 2023)

Octave (GNU Octave): GNU Matlab replacement/supplement/version. (30 January 2023)

Octokit: A GitHub API client library with various bindings. (01 July 2021)

OData: OASIS standard for data over HTTP-based communication. (01 January 2023)

Ode: A stack-based, concatenative, functional programming language with an interactive online development environment written in JavaScript. (30 May 2024)

Odin: Designed with the intent of creating an alternative to C around simplicity, high performance, built for modern systems, and joy of programming. (24 May 2024)

Ogol: Variant of the Logo computer language. (22 May 2024)

Ohm: A library and language for building parsers, interpreters, compilers, etc. (12 June 2024)

Ohm: A library and language for building parsers, interpreters, compilers, etc. (09 July 2023)

OhMyForm: Create stunning embedable forms for recruiting, market research, surveys and more; open source alternative to TypeForm, TellForm, or Google Forms. (11 August 2021)

Oil: A new Unix shell. (30 May 2024)

Oilpan: A mark-sweep tracing GC library hosted by the V8 ECMAScript engine for C++ applications. (06 April 2022)

Okta: A new open source, general-purpose programming language that, although it's still in its childhood, aims to provide a simple platform to create low level, efficient software. (30 May 2024)

Olin: Olin is like the JVM for WebAssembly. It wraps WebAssembly with a set of functions to access the outside world and keeps track of things like how many instructions were used, how many syscalls were made and how much memory was used. (06 April 2022)

OllyDbg: A 32-bit assembler level analysing debugger for Microsoft® Windows. (02 May 2022)

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. (12 June 2024)

OMG (Object Management Group): An international (27 countries), membership-driven (230+ organizations) and not-for-profit consortium with focus to generate technology standards (250+) that provide quantifiable real-world value to all vertical industries. (30 January 2023)

OmniSharp: A family of open-source projects for .NET. (06 April 2022)

OMR: Reliable components for building language runtimes. (04 May 2020)

One: An open source, self-hosted, bootstrapping system programming language which makes it easy to build reliable and efficient software. (30 May 2024)

Onion Architecture: Layers presented as circles, each wrapping around a previous one, forming an "onion". (01 July 2021)

Onsen UI: The fastest way to develop beautiful HTML5 hybrid and mobile web apps. (25 April 2022)

Onyx: An efficient, procedural, and pragmatic programming language, compiling solely to WebAssembly. (24 May 2024)

Onyx: An efficient, procedural, and pragmatic programming language. (11 May 2024)

OOC: A small programming language with a clear and concise syntax that compiles to C99. (10 May 2020)

Ook!: A programming language designed for orang-utans. (30 May 2024)

Oolong: iPhone game engine (06 April 2022)

OOUI: a small cross-platform UI library for .NET that uses web technologies; presents a classic object-oriented UI API that controls a dumb browser. (24 July 2021)

Opa: An attempt at an "all-in-one" presentation, middleware, and storage system. (21 October 2020)

Opal: Ruby (hearts) JavaScript. (31 July 2021)

Open3D Development Engine (O3DE): Open-source, real-time 3-D engine. (30 November 2022)

OpenAI: API and SDKs for using OpenAI. (24 February 2023)

OpenAI: Collection of AI services for natural language and images. (08 January 2023)

Open API Specification (OAS): A standard, programming language-agnostic interface description for REST APIs, which allows both humans and computers to discover and understand the capabilities of a service without requiring access to source code, additional documentation, or inspection of network traffic. (08 January 2023)

OpenComal: OpenComal is a portable and free implementation of the Comal programming language written by moi. Currently supported platforms are Unix, MsDos and Win32 (95, 98, NT, 2000, XP and whatever they come up with next :-) Comal is a crossover between Basic and Pascal, with the best features of both and none of the drawbacks of either. (24 May 2024)

OpenCRUD: A GraphQL CRUD API specification for databases. (06 April 2022)

OpeNER: Goal is to provide a set of ready to use tools to perform some natural language processing tasks, free and easy to adapt for Academia, Research and Small and Medium Enterprise to integrate them in their workflow. More precisely, OpeNER aims to be able to detect and disambiguate entity mentions and perform sentiment analysis and opinion detection on the texts, to be able for example, to extract the sentiment and the opinion of customers about certain resource (e.g. hotels and accommodations) in Web reviews. (03 May 2022)

OpenFin: A web runtime and operating environment designed for enterprise app development. (05 July 2021)

openFrameworks: A collection of open-source frameworks for easier creative development. (10 May 2020)

Open Grid Forum: An open global community committed to driving the rapid evolution and adoption of modern advanced applied distributed computing, including cloud, grid and associated storage, networking and workflow methods. OGF is focused on developing and promoting innovative scalable techniques, applications and infrastructures to improve productivity in the enterprise and within the international research, science and business communities. (24 August 2021)

OpenJDK JVM: A collection of links and reading specific to the OpenJDK. (12 May 2022)

Open Liberty: A lightweight open framework for building fast and efficient cloud-native Java microservices. (13 January 2024)

OpenLibrary: An open, editable library catalog, building towards a web page for every book ever published. (29 June 2023)

Open RA: An open-source game engine for Westwood Studios-style RTS games. (04 May 2020)

OpenResty: Web software management and diagnostics platform(s)? (06 April 2022)

OpenRTS: Real-Time Strategy game 3D engine coded in pure java. (06 April 2022)

Open Smalltalk: Cross-platform virtual machine for Squeak, Pharo, Cuis, and Newspeak. (27 July 2021)

opensource.facebook.com: Facebook's home page for open-source projects. (02 August 2021)

Open-Source Games: A collection of open-source games; capturing them here for play and research purposes. (11 May 2024)

OpenTelemetry: High-quality, ubiquitous, and portable telemetry to enable effective observability. (06 April 2022)

OpenVidu: Platform and SDKs to build on-premises WebRTC video conferences. (06 April 2022)

OpenXava: Low-Code Platform for Rapid Development of Enterprise Web Applications. (07 June 2021)

OpenXML SDK: Provides tools for working with Office Word, Excel, and PowerPoint documents. (01 January 2023)

OpenZz: OpenZz is an interpreted dynamic parser which is well suited to rapid development of parsing solutions, starting from rapid language prototyping to full fledged compilers. OpenZz is a dynamic LALR(1) parser which allows its grammar to be modified and extended by commands written in its own language as well as through functionality provided by external libraries. OpenZz is implemented as a C library and exports C-bindings, so it can be joined with other code libraries both by static linking and runtime module loading. OpenZz is being developed by the INFN for use in the compilation chain of the APE("ah-pei") series of highly parallel processing computers. APE systems are developed for performing LQCD physics research. (24 May 2024)

Operating System (Documentation Project): This independent project aims to be one of the best online resources available in public for all people who are looking for informations about operating systems and their producers. Facts about the history of operating systems are preserved in long term. (06 April 2022)

OptaPlanner: A JVM-based constraint logic problem solver. (30 March 2021)

Oqtane: An open source and cross-platform CMS and application framework for building modern digital experiences on .NET; composed of reusable web UI components implemented using C#, HTML, and CSS, with both the client and server code is written in C#. (12 July 2023)

Oqtane: A Modular Application Framework for Blazor (.NET WebAssembly). (06 April 2022)

Oracle Apex: "World's most popular enterprise low-code application platform." (24 February 2023)

Orbit: Virtual actor framework for building distributed systems. (21 December 2020)

Orbital: A Java class library providing object-oriented representations and algorithms for logic, mathematics, and computer science. This Java library provides computer algebra, numerical algorithms, theorem proving, search and planning etc. Generally speaking, the conceptual idea behind the Orbital library is to provide extensional services and components for Java, which surround the heart of many scientific applications. (24 August 2021)

Orca: An esoteric programming language designed to quickly create procedural sequencers, in which every letter of the alphabet is an operation, where lowercase letters operate on bang, uppercase letters operate each frame. (05 February 2024)

Orchard Framework: Open-source, modular, multi-tenant application framework and CMS for ASP.NET Core. (06 April 2022)

Oredev: Tech conference in Malmo, Sweden. (14 March 2023)

OrientDB: Multidimensional open-source database. (07 June 2021)

OrioleDB: A new storage engine for PostgreSQL, bringing a modern approach to database capacity, capabilities and performance to the world's most-loved database platform. (08 January 2023)

Orion: Orion is a high level, purely functional Lisp dialect. (24 May 2024)

Orleans: Actors-based implementation for distributed systems implementation. (24 August 2021)

Orly: An open-source graph database (07 June 2021)

OSTEP: Operating Systems: Three Easy Pieces: a free online operating systems book! The book is centered around three conceptual pieces that are fundamental to operating systems: virtualization, concurrency, and persistence. In understanding the conceptual, you will also learn the practical, including how an operating system does things like schedule the CPU, manage memory, and store files persistently. (06 April 2022)

Outsystems: Using visual, model-driven development, AI-powered tools that improve the entire application lifecycle, and a cloud-native platform, you can quickly and easily build, deploy and manage the software that makes a difference. (01 July 2021)

OverScript: OverScript is a simple and powerful C-like statically-typed language written in C# and is great for both embedding in .NET programs and building standalone applications. The project was developed from scratch without looking back at traditional approaches to creating languages. The unique approach allows the language to go beyond the standard features and have great potential for improvement. (24 May 2024)

Owin: Open Web Interface for .NET. (06 April 2022)

Owncloud: A personal cloud which runs on your own server. (06 April 2022)

Ox: Ox is an object-oriented statistical system. At its core is a powerful matrix language, which is complemented by a comprehensive statistical library. Among the special features of Ox are its speed, well-designed syntax and editor, and graphical facilities. Ox can read and write many data formats, including spreadsheets and OxMetrics files; Ox can run most econometric Gausstm programs. Ox comes in two versions: Ox Professional and Ox Console. Ox is available for Windows, Linux, Mac (macOS), and several Unix platforms. (24 May 2024)

Oxide: An interpreted scripting language with a Rust influenced syntax. (01 November 2022)

OxygenBasic: BASIC compiler. Run programs directly, or compile to 32/64 bit binary. Supports C headers and assembly code. Supports Unicode source scripts. (24 May 2024)

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. (24 May 2024)

P: A statically-compiled research language from Microsoft around explicit state machine management. (24 May 2024)

P#: A statically-compiled research language from Microsoft around explicit state machine management. (01 November 2020)

P5: A JavaScript library for creative coding, with a focus on making coding accessible and inclusive for artists, designers, educators. (25 February 2023)

Package by Feature Architecture: Capitalizes on cohesion and coupling by moving the layering a level down — to the class level — and focusing on coupling and cohesion at a higher level by keeping all classes related to the same feature in the same package/module. (01 July 2021)

PAIP: PAIP (pipe) is a universal filter application. It uses plugins to transmit and convert data. They can be nested, so the inner structures can become quite complex (non-linear). The command-line interface is similar to a programming language and very easy. (24 May 2024)

Paka: A language designed to be everything that the author wants in a language. (06 April 2022)

PANDA (Platform for Architecture-Neutral Dynamic Analysis): A platform for doing dynamic analysis across several platforms. (01 July 2021)

Panda3D: An open-source, completely free-to-use engine for realtime 3D games, visualizations, simulations, experiments, whatever. (10 May 2022)

Papers We Love: A collection of academic papers gathered by a popular "user group" dedicated to reading through them. (27 September 2022)

Paper websites: Can you build a website from a piece of paper? (06 April 2022)

Paradigms of Artificial Intelligence Programming: Norvig's classic, on the Web. (01 August 2023)

parboiled: A mixed Java/Scala library providing for lightweight and easy-to-use, yet powerful and elegant parsing of arbitrary input text based on Parsing expression grammars (PEGs). (30 May 2024)

Parrot: Virtual machine implementation for Perl and other dynamic languages. (04 May 2020)

Parse Alternatives: Since Parse's departure, many cloud hosts have declared themselves to be Parse's logical successor; this is a collection of those links. (01 July 2021)

Parse Platform: Open-souce backend platform running on NodeJS. (01 July 2021)

Parser (programming language): Scripting language used for web development and server-side scripting. (30 May 2021)

Parser Construction Kit (PCK): Multi-input parser generator toolkit. (16 May 2020)

Parsing (language syntax): A collection of links on parsers, parser generators, parsing algorithms, and so on. (30 May 2024)

Parsix: High level parsing to ensure input is in the right shape and satisfies all constraints that business logic requires. (24 August 2021)

Pascal (and Object Pascal): A procedural language with added object extensions popularized by Borland as Delphi. (22 January 2024)

PascalABC.NET: A new generation Pascal programming language that combines simplicity of classic Pascal, a great number of modern extensions and broad capabilities of Microsoft .NET Framework. (05 February 2024)

PascalABCNet: PascalABC.NET is the new generation Pascal programming language that combines simplicity of classic Pascal, a great number of modern extensions and broad capabilities of Microsoft .NET Framework. It's ree, simple and powerful IDE. Built-in form designer for rapid development of Windows desktop applications. (24 May 2024)

Pascal Script: Pascal Script is an Object Pascal/Delphi/Lazarus-compatible interpreter with bytecode compiler that delivers a scripting environment for application programs. (24 May 2024)

Pashmak: An interesting developing language. (01 August 2023)

Passerine: A small, concise, extensible functional scripting language, powered by a VM written in Rust. (24 May 2024)

PATAT: Terminal-based presentations using Pandoc. (08 March 2024)

Patat (Presentations Atop The ANSI Terminal): Terminal-based presentations using Pandoc. (20 March 2024)

Pattern-Oriented Software Architecture 1 (POSA1): A collection of patterns by "the gang of five". (07 June 2021)

Pattern-Oriented Software Architecture 2 (POSA2): Another collection of patterns. (07 June 2021)

Patterns: A collection of books and reading on patterns. (11 May 2024)

Patterns of Distributed Systems: Martin Fowler series, on distributed systems. (20 March 2024)

Patterns of Enterprise Application Architecture: Martin Fowler's enterprise systems text. (30 May 2021)

Pawn: A curly-brace language with a small-footprint VM. Represents data as 4/8-byte "cells". Compiles to CPU-specific bytecode. (18 November 2020)

PaxScript: paxScript is an interpreter of 4 object-oriented scripting languages: paxBasic, paxC, paxPascal and paxJavaScript All pax-languages support such concepts of the modern programming as namespaces, nested classes, inheritance, static(shared) members, indexed properties, default parameters, overloaded routines, operator overloading, delegates, exception handling, regular expressions, conditional compilation. If you know VB.NET, C# or Object Pascal, you are already familiar with paxScript. (more...) Cross-language integration. For example, you can use modules written in paxBasic and paxC in your paxPascal scripts and vice versa. Separate compilation of the modules. Direct calling dll-defined routines. All calling conventions register, pascal, cdecl, stdcall, safecall are supported. (See demo.) Embedding scripts into html pages. (24 May 2024)

Payload: Free and Open-source Headless CMS and Application Framework built with TypeScript, Node.js, React and MongoDB. (05 July 2022)

PDF24 Tools: Free and easy-to-use online PDF tools that make you more productive. (29 June 2023)

Peachpie: PeachPie is a modern PHP compiler based on the Microsoft Roslyn compiler platform and drawing from our popular Phalanger project. It allows PHP to be executed within the .NET framework, thereby opening the door for PHP developers into the world of .NET - and vice versa. (24 May 2024)

PearPC: An architecture-independent PowerPC platform emulator capable of running many PowerPC operating systems, including pre-Intel versions of Mac OS X, Darwin and Linux. (01 July 2021)

Pen: Programming language for scalable development. (22 May 2024)

Pendulum: Synchronous reactive language (OCaml extension) to program reactive systems on the Web. (22 May 2024)

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. (01 November 2022)

Peregrine: Easy to use systems programming language with Python-like syntax. (24 May 2024)

Performance tools and research: A collection of links around performance tools (06 April 2022)

Peridot: An experimental language for exploring the applications of two level type theory to high-performance functional programming (24 May 2024)

Perl: A language inspired by regular expressions--and it got worse from there somehow. (02 August 2021)

Perst: Open source, dual license, object-oriented embedded database system (ODBMS). (06 April 2022)

Peter: Gemtree Peter is a visual programming tool designed for a simple and fast generation of the programs for Windows 95/98/NT/ME/2000/XP/Vista. Its principal characteristic is the graphical presentation of the program structure. The program sections are assembled using the mouse like a jigsaw puzzle. Thanks to the justification check of the element combinations, carried out already at the time of the program generation, there is no chance of syntactic failure origination. The program presentation by means of a tree structure enables a considerable improvement of the program lucidity. The creation of the program is quickly becoming extraordinary easy and flexible. (24 May 2024)

Pharo: Pharo is a pure object-oriented programming language and a powerful environment, focused on simplicity and immediate feedback (think IDE and OS rolled into one). (24 May 2024)

Pharo: A dynamic reflective pure object-oriented language supporting live programming inspired by Smalltalk. (06 April 2022)

Phasar: A LLVM-based static code analysis framework (01 July 2021)

Phaser: HTML 5 game engine. (06 April 2022)

Phix: An open source, self-hosted, interpreted or compiled programming language with a strong emphasis on simplicity and plain human-readable error messages. (24 May 2024)

Photino: A lightweight open-source framework for building native, cross-platform desktop applications with Web UI technology. (08 July 2023)

PhotonOS: An open source, minimal Linux container host that is optimized for cloud-native applications, cloud platforms, and VMware infrastructure. (01 July 2021)

PHP: Language designed for building web page generators/servers. (11 May 2024)

Picat: A simple, and yet powerful, logic-based multi-paradigm programming language aimed for general-purpose applications. (Pattern-matching, Intuitive, Constraints, Actors, Tabling) (15 November 2020)

Piccola: Piccola is a small, pure language for building applications from software components. Piccola is small in the sense that its syntax is tiny, and it is pure in the sense that it provides only compositional features — computation is performed entirely by components of the host programming language. The semantics of Piccola is defined in terms of a process calculus, an extension of Milner's pi calculus in which values communicated are forms, rather than tuples. A "form" is essentially an extensible nested record which also serves as a namespace in which expressions may be evaluated. This simple mechanism is responsible for much of the expressive power of Piccola. (24 May 2024)

Pico: Pico is a tiny but expressive programming language that was especially designed to teach advance computer science concepts to students in other sciences than computer science (such as Physics and Chemistry). In a sense, Pico can be seen as a non-trivial marriage between the power of languages like Scheme, and, the standard infix notation students are used to from ordinary calculus. A.o., Pico features garbage collected tables (i.e. arrays), higher order functions, objects, meta programming and reflection. But above all, Pico is small! Really small! (24 May 2024)

PicoLisp: PicoLisp is a programming language, a dialect of the language Lisp. Its most prominent features are simplicity and minimalism. It is built on one internal data type: a cell. On the language level, a programmer can use three different data types (numbers, symbols, and lists) being represented by cells and differentiated by bits at the end of the cell. (30 May 2024)

Pict: Pict, a concurrent programming language based on the pi-calculus. Pict is a language in the ML tradition, formed by adding a layer of convenient syntactic sugar and a static type system to a tiny core. The current release includes a Pict-to-C compiler, reference manual, language tutorial, numerous libraries, and example programs. The core language - an asynchronous variant of Milner, Parrow, and Walker's pi-calculus - has been used as a theoretical foundation for a broad class of concurrent computations. The goal in Pict is to identify high-level idioms that arise naturally when these primitives are used to build working programs - idioms such as basic data structures, protocols for returning results, higher-order programming, selective communication, and concurrent objects. The type system integrates a number of features found in recent work on theoretical foundations for typed object-oriented languages: higher-order polymorphism, simple recursive types, subtyping, and a powerful partial type inference algorithm. (30 May 2024)

Piet: A language where the programs are works of modern art. (30 May 2024)

Pikachu: Pika pika. (30 May 2024)

Pikelet: Small, functional, dependently typed programming language. (22 May 2024)

Pikt: Pikt is a pixel-based, Turing complete esoteric programming language that generates fast and lightweight programs out of aesthetically pleasant image sources. Indeed, Pikt's most interesting feature is flexibility: every keyword, statement, function, operator and so on is linked to one - or more - color, which can be easily customized via color schemes. (24 May 2024)

PILL: PILL is a scripting language for applications. The syntax (based on functional languages) might look weird but it have some advantages. It contains only a minimal set of functions, applications will have to register new ones via the interpreter's API in order to make it to replay the scripts as wanted. This abstraction offers a flexible way to expand scripts abilities to virtually any domain and to allow various applications to share/re-use foreign scripts. (24 May 2024)

Pin: A Dynamic Binary Instrumentation Tool. (01 July 2021)

Pinafore: Pinafore is a language that allows you to structure information and create user interfaces for it. Currently it's at the "proof of concept" stage. You can build it from source and run it. (24 May 2024)

Pine64: A collection of OSS-inspired hardware: laptops, tablets, phones, e-ink readers, and more. (06 April 2022)

Pineapple: Pineapple is a language that focus on maintainability. (03 November 2022)

Pinecone: Pinecone is a brand new, easy to learn, general purpose, multi-paradigm, high performance programming language created by Sophie Winter. Work on the language began on October 4th, 2016. Pinecone can now be interpreted or transpiled to C++. The language is written from scratch (it includes an integrated lexer, parser and interpreter, etc.). (24 May 2024)

PingCAP: NewSQL database that supports HTAP workloads. (06 April 2022)

Pipedream: Pipedream is an integration platform for developers. (11 May 2024)

Pipedream: Workflow automation and API integration platform. (06 April 2022)

Pipelines: An experimental programming language for data flow. (15 November 2020)

Piston: A modular open source game engine. (26 February 2023)

PIXAR's 22 Rules of Storytelling: A helpful list for becoming a better storyteller from the world’s animation experts. (24 November 2023)

Pixie: A small, fast, native lisp with "magical" powers. (20 December 2022)

PixiJS: A rendering library that will allow you to create rich, interactive graphics, cross platform applications, and games without having to dive into the WebGL API or deal with browser and device compatibility. (24 August 2021)

Pizza: The Pizza language is an extension to Java with three new features: Generics (aka Parametric polymorphism) Function pointers (aka First-class functions) Class cases and pattern matching (aka Algebraic types) Furthermore you can use the Pizza compiler embedded into other applications. (24 May 2024)

Pizza: One of the original extension-languages to Java. Historical interest only. (11 August 2021)

PL/0 Language Tools: An implementation of PL/0 including a tree-based interpreter and virtual machine. (06 October 2022)

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. (01 July 2021)

Plan9: A distributed research operating system developed at Bell Labs by the same team that created Unix and C. Over the years there have been four major releases or ‘Editions’; after the Fourth Edition the project adopted a ‘open source’ model and changes are published daily in a public repository; a distributed computing environment assembled from separate machines acting as CPU servers, file servers, and terminals. The pieces are connected by a single file-oriented protocol and local name space operations. (06 April 2022)

PlanetScale: A serverless MySQL platform based on the Vitess horizontal scaling MySQL technology. (08 March 2024)

PlantUML: Language for defining UML diagrams. (04 May 2020)

Plasmic: Visual web app builder on top of React. (05 July 2021)

Platform Revolution: How networked markets are transforming the economy and how to make them work for you. (06 April 2022)

Plato: Plato is an efficient and (hopefully!) fun programming language inspired by JavaScript, TypeScript, C#, and Haskell. Plato is designed to be easy to teach and learn while being efficient and robust enough for professional coding, particularly in the realm of 3D graphics. Plato is a statically typed functional language that looks and behaves in many ways like an object-oriented scripting language, but with a lot less complexity. (24 May 2024)

Play: Visual app builder intended for use on mobile devices. "Design, test and share powerful mobile products—directly from your mobile device." (05 July 2021)

PlayN: a Java library for writing games which can be deployed to Windows/Mac/Linux desktop Java, iOS devices, Android devices, and HTML5 browsers. (06 April 2022)

PLC: PLC is a simple, powerful way to add custom scripting to any program. A basic C parser and interpreter is included, and new scripting languages can be designed easily. (24 May 2024)

Plutus: Plutus Core is the scripting language embedded in the Cardano ledger and forms the basis of the Plutus Platform, an application development platform for developing distributed applications using the Cardano blockchain. (24 May 2024)

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. (06 April 2022)

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. (10 May 2020)

Pocketbase: Open Source backend for your next SaaS and Mobile app in 1 file. (03 October 2022)

Pocketlang: A lightweight, fast, embeddable scripting language. (24 May 2024)

Pogo, Pogoscript: Little language that emphasizes readability, DSLs, and asynchronous primitives. (03 October 2022)

Pointless: A scripting language for learning and fun. (15 July 2023)

Polly: A .NET resilience and transient-fault-handling library that allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner. (01 January 2023)

Poly: A general-purpose language based on the idea of treating types as first-class values. (02 June 2021)

Polyglot: Experiment with PHP+C polyglot snippets and a transpiler written in OCaml. (24 May 2024)

Polyglot: Extensible compiler front end framework for language implementation on the JVM. (04 May 2020)

Polylang: TypeScript-like language that compiles to zero knowledge computation. (24 May 2024)

Polylith: A software architecture that applies functional thinking at the system scale. It helps us build simple, maintainable, testable, and scalable backend systems. (06 April 2022)

Polymer (Project): Libraries, tools, and standards for a better web: LitElement, lit-html, web components, ... (06 April 2022)

Pony: Open-source, object-oriented, actor-model, capabilities-secure, high-performance programming language. (24 May 2024)

Portable Document Format (PDF): A cross-platform format for rendering pixel-correct pages. (01 July 2021)

Portable Executable (PE): Win32 executable file format. (07 April 2022)

PortableGL: An implementation of OpenGL 3.x-ish in clean C. (06 April 2022)

Portable Unix Documentation (PUD): Currently provides two mini-languages for authoring in the UNIX environment. The two mini-languages are for writing UNIX manual pages and FAQ documents. Source documents in PUD languages can be compiled to either cross-linked html or to troff. The troff output can be further compiled into PostScript, PDF, and plain text. (06 April 2022)

Porter: Kubernetes powered PaaS that runs in your own cloud (06 April 2022)

PostgresQL: Open-source relational database. (22 January 2024)

PostScript: A dynamically typed, concatenative programming language page description language in the electronic publishing and desktop publishing business. (01 July 2021)

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. (01 July 2021)

Potion: An object- and mixin-oriented (traits) language by _why the lucky stiff. (13 June 2023)

PouchDB: Open-source JavaScript database inspired by CouchDB. (01 July 2021)

PowerFX: Low-code language (13 May 2021)

Power Fx: Microsoft Power Fx is a low-code general purpose programming language based on spreadsheet-like formulas. It is a strongly typed, declarative, and functional language, with imperative logic and state management available as needed. (24 May 2024)

POWER-KI: POWER-KI allows HYBRID PROGRAMMING, i.e. the development of applications with components created with different languages in a single package, making the most of each of them. In fact from POWER-KI it is possible to directly execute PyThon code, C / C ++ code using WRAP and javascript in the Web User Interface. In this way, for example, it is possible to create applications based on Python code that take advantage of the POWER-KI Native Cloud for the user interface or create C / C ++ functions for maximum performance. (24 May 2024)

PowerLoom: a language and environment for constructing intelligent, knowledge-based applications using a fully expressive, logic-based representation language (a variant of KIF) and a natural deduction inference engine that combines forward and backward chaining to derive what logically follows from the facts and rules asserted in the knowledge base. (12 July 2023)

PowerMops: A full featured, stand-alone development environment for programming the Macintosh written by Mike Hore. (24 May 2024)

PowerShell: Cross-platform strongly dynamic typed object-based with functional features automation and configuration language. (22 May 2024)

Practical Compiler Construction: A no-nonsense tour through a C compiler. (30 May 2024)

Pragma: Pragma generates a GraphQL API based on your data models, authorization rules, and custom Javascript functions. (04 May 2020)

Pragmatic Programmer: The best non-technical programming book in the world. (13 October 2023)

Pragmatic Thinking & Learning: Andy Hunt's thoughts on thinking. (06 April 2022)

Prefect: "Build, run, and monitor data pipelines at scale." Use a flexible Python framework to easily combine tasks into workflows, then deploy, schedule, and monitor their execution through the Prefect UI or API. (24 August 2021)

Preql: Preql is an interpreted, relational programming language, that specializes in database queries and compiles to SQL. (24 May 2024)

Presentation Patterns: A collection of patterns around public speaking. (30 December 2022)

Present-RPC: Simple, idiomatic RPCs for Java, Javascript, Android, iOS, and more (16 May 2020)

Presto (PrestoDB, PrestoSQL): Open source distributed SQL query engine for running interactive analytic queries against data sources of all sizes. (01 July 2021)

Pretty Laughable Language: An educational C-like toy programming language that compiles to x64 binary. (30 December 2023)

Primi: A scripting language written in and interpreted in PHP. (13 July 2023)

Priml: A new programming language aimed at facilitating systems and AI infrastructure development. (24 May 2024)

Prince of Persia: The classic Apple ][ game. (30 December 2022)

Prisma: An auto-generated and fully type-safe database client providing a simplistic yet extremely powerful API. (14 March 2023)

Prismic.io: Headless, API-driven "content platform" CMS. (01 July 2021)

Probase: The goal of Probase is to make machines “aware” of the mental world of human beings, so that machines can better understand human communication. We do this by giving certain general knowledge or certain common sense to machines. (06 April 2022)

Processing: Processing is a flexible software sketchbook and a language for learning how to code. Since 2001, Processing has promoted software literacy within the visual arts and visual literacy within technology. There are tens of thousands of students, artists, designers, researchers, and hobbyists who use Processing for learning and prototyping. (24 May 2024)

Processing: An open-source graphical library and integrated development environment (IDE) built for the electronic arts, new media art, and visual design communities with the purpose of teaching non-programmers the fundamentals of computer programming in a visual context. (01 July 2021)

Product Roadmaps: Developing product roadmaps. (11 May 2024)

Program analysis: A collection of links around program analysis (06 April 2022)

Programmer fonts: A collection of fonts commonly used or recommended by programmers. (26 February 2023)

Programming Debug Binary (PDB): Debugging file format for Windows executables. (06 April 2022)

Programming Dojo: This site was designed to improve the awareness of different programming languages. (06 October 2022)

Programming Languages: Application and Interpretation: Notes on the book. (30 May 2024)

Programming Language sites/links: A collection of language sites and links (06 April 2022)

Programming Paradigms for Dummies: What Every Programmer Should Know: Notes from the VanRoy paper. (06 April 2022)

Progressive Web applications (PWAs): Collection of resources and ideas on PWAs. (11 May 2023)

Proguard: Library to read, write, analyze, and process java bytecode. (26 February 2023)

Project Reactor: A fourth-generation reactive library, based on the Reactive Streams specification, for building non-blocking applications on the JVM. (30 July 2021)

Project Tye: An experimental developer tool that makes developing, testing, and deploying microservices and distributed applications easier. (20 December 2020)

Prolog: A recursive-cut, declarative, logic programming language. (11 May 2024)

Prompto: Platform and differing-syntax languages for cloud development. (24 May 2024)

Prose: A simple language inspired by Io and Ioke that compiles to Clojure and ClojureScript. (24 May 2024)

PROSE Framework: A framework of technologies for programming by examples: automatic generation of programs from input-output examples. (06 April 2022)

Protocol Buffers: a language-neutral, platform-neutral, extensible way of serializing structured data for use in communications protocols, data storage, and more. (25 February 2023)

Prowl: The Prowl Language is a statically-typed stack-based programming language that draws from a wide range of inspirations, mainly functional, logic, and stack-based languages. However, the language is unique with its powerful program combinator system. Prowl exploits a homomorphism between string concatenation and concatenative languages that allows regex to be used as a computational and mental model for control flow. This model provides a rigid framework to solve combinatory and constraint problems (in addition to general purpose programming) yet retains performant translations into DFAs due to the regex base. With stacks for data and regex for control flow, Prowl provides a unique but ergonomic way to think about hard problems. (24 May 2024)

PRQL (Pipelined Relational Query Language): A modern language for transforming data — a simple, powerful, pipelined SQL replacement. (30 December 2022)

pSpaces: Implementations of Tuple Spaces (aka object spaces) across several languages/platforms. (25 December 2020)

Psychology (reading): A collection of articles and links on psychology and the brain. (30 December 2022)

Public Speaking Topic Secrets for College, Community, Toastmasters and TED Talks: Exercises for figuring out speaking topics. (25 November 2020)

PubNub: Cloud platform for realtime message broadcast/consumption. (16 May 2020)

Puffin: A cross-platform 2D C# game engine. (18 May 2020)

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. (06 April 2022)

PumpkinOS: A PalmOS-compatible. (11 May 2024)

Punk-C: A hacked version of C (on top of Lua) for use in the Witchcraft tool set. (16 May 2020)

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. (24 May 2024)

PureBasic: PureBasic is a modern BASIC programming language. The key features of PureBasic are portability (Windows, Linux, OS X and Raspberry supported with the same source code), the production of very fast and optimized native 32-bit or 64-bit executables and, of course, the very simple BASIC language syntax. PureBasic has been created for the beginner and expert alike. We have put a lot of effort into its conception to produce a fast, reliable system and friendly BASIC compiler. (24 May 2024)

Pure Data: Pure Data (or just "Pd") is an open source visual programming language for multimedia. Pure Data is developed by Miller Puckette since 1996 and you can find it on his official website along with the official documentation and other related resources. (24 May 2024)

PureScript: A strongly-typed functional programming language that compiles to JavaScript (24 May 2024)

PureScript: A strongly-typed language that transpiles to JavaScript. (06 April 2022)

PursuedPyBear: Game development engine/library for Python. (01 August 2023)

Puter: Cloud-hosted OS-like platform. (11 May 2023)

PuzzleScript: A language/environment for creating turn-based, keyboard-controlled games where you're moving a thing, or several things around. (18 November 2020)

PXP: A superset of PHP with extended syntax and runtime capabilities. (24 May 2024)

PyAutoGui: Lets Python scripts control the mouse and keyboard to automate interactions with other applications. (24 August 2021)

Pycopy: Pycopy - a minimalist and memory-efficient Python dialect. Good for desktop, cloud, constrained systems, microcontrollers, and just everything. (24 May 2024)

Pyew: A (command line) python tool to analyse malware. (16 May 2020)

Pygame: A commonly-cited/-quoted Python game toolkit. (10 May 2022)

Pygame Zero: Toolkit on top of Pygame for building games for game-building beginners. (10 May 2022)

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. (06 April 2022)

PyPy: A replacement for CPython, built using the RPython language that was co-developed with it. (20 December 2022)

Pyret: Python like scripting language. (24 May 2024)

Pyro: A universal probabilistic programming language (PPL) written in Python and supported by PyTorch on the backend, enabling flexible and expressive deep probabilistic modeling, unifying the best of modern deep learning and Bayesian modeling. (13 June 2023)

Python: A dynamic language and platform. (11 May 2024)

Python.NET: A package that allows Python code to interact with the CLR, and may also be used to embed Python into a .NET application. (01 January 2023)

Python Tricks, The Book: A Buffet of Awesome Python Features (30 May 2021)

Python UI frameworks/libraries: A collection of links to (and on) Python GUI libraries/frameworks. (29 June 2023)

Pyxell: Multi-paradigm, statically typed programming language, compiled to machine code via C++. (22 May 2024)

q: Programming language focusing on performance and efficiency. (24 May 2024)

Q (Scripting Language): Q is a scripting engine that implements C-like language, compiler, and bytecode interpreter. (30 May 2024)

q3vm: Single file (vm.c) bytecode virtual machine/interpreter for C-language input. (12 July 2023)

q5JS: A small and fast alternative (experimental) implementation of p5.js. (25 February 2023)

QBDI (QuarkslaB Dynamic binary Instrumentation): A Dynamic Binary Instrumentation framework based on LLVM. (01 July 2021)

QCon: InfoQ's conferences (14 March 2023)

Qemu: A Unix clone. (26 February 2023)

Qi: Lightweight and fast programming language designed to be written in Chinese. (24 May 2024)

Qiew: Hex/File format viewer. (16 May 2020)

Qogo: This application was developed to teach 5 to 10 year olds the principles of programming via the venerable "Turtle Graphics" paradigm. It is written in TCL so it runs on all computer platforms. It features a full IDE with undo support and interactive construction as well as being able to save newly created commands as new instructions. (24 May 2024)

QOI (Quite OK Image) format: An image format that losslessly compresses RGB and RGBA images to a similar size of PNG, while offering a 20x-50x speedup in compression and 3x-4x speedup in decompression. (06 April 2022)

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. (06 April 2022)

Qovery: Kubernetes powered PaaS that runs in your own cloud. (06 April 2022)

Qt: One framework. One codebase. Any platform. Qt is the fastest and smartest way to produce industry-leading software that users love. (06 April 2022)

QuakeC/VM: The language from the game Quake. (06 April 2022)

Quarkly: Design tool for creating websites and web apps. (05 July 2021)

Quasar: An open-source VueJS-based framework, to quickly create response++ websites/apps. (11 May 2024)

QuestDB: Database designed to process time series data. (06 April 2022)

QuestPDF: Modern .NET library for PDF document generation. (29 June 2023)

Quick.Ref Cheat Sheets: A collection of "cheat sheets"/quick-reference-guides for various tools and platforms and languages and .... (24 August 2021)

QuickBase: An application development platform that unites business and IT teams by enabling problem solvers of any technical background to work together to safely, securely and sustainably create an ecosystem of applications. (05 July 2021)

Quil: A Portable Quantum Instruction Language. (24 May 2024)

Quirrel: Quirrel - Gaijin Entertainment dynamic script language (former Squirrel). (24 May 2024)

Quorum: Quorum is a general purpose programming language designed for several purposes. First, we regularly run experiments with people at various age and experience ranges, investigating ways to make the language easier to use. Evidence gathered from these studies is filtered back into the design, making quorum an "evidence-based" programming language. Second, as our team is interested in issues of equity for all people, perhaps especially people with disabilities, we are careful to design libraries that are friendly to the broad population. This means many internal libraries in the language have support for accessibility. (24 May 2024)

Qwik: An Open-Source framework designed for best possible time to interactive, by focusing on resumability of server-side-rendering of HTML, and fine-grained lazy-loading of code. (06 April 2022)

R: A free software environment for statistical computing and graphics. (06 April 2022)

R3: R3 is a Colorforth like laneguage, a FORTH dialect, R3 is a 64 bits, very small dictionary and simple working, strong typed, many version for windows/linux/mac and raspberry pi. (24 May 2024)

R4: R4 is a Colorforth like laneguage, a FORTH dialect, R4 is 32bits, very small dictionary and simple working, strong typed, many version for windows/linux/mac and raspberry pi. (24 May 2024)

Racket: A general-purpose, multi-paradigm programming language and a multi-platform distribution that includes the Racket language, compiler, large standard library, IDE, development tools, and a set of additional languages including Typed Racket (a sister language of Racket with a static type-checker), Swindle, FrTime, Lazy Racket, R5RS & R6RS Scheme, Scribble, Datalog, Racklog, Algol 60 and several teaching languages. (24 May 2024)

Racket: Racket language/platform is a Lisp, but has numerous language implementations built on it. (24 August 2021)

RAD Basic: RAD Basic 100% compatible with your Visual Basic 6 projects. (24 May 2024)

Radiance: Simple language that compiles to WASM. (22 May 2024)

Radish: Radish is an easy-to-learn, object-oriented programming language written in C#. If you know JavaScript, you know Radish. (24 May 2024)

Ragel: Ragel compiles executable finite state machines from regular languages. Ragel targets C, C++ and ASM. Ragel state machines can not only recognize byte sequences as regular expression machines do, but can also execute code at arbitrary points in the recognition of a regular language. Code embedding is done using inline operators that do not disrupt the regular language syntax. (24 May 2024)

Railo: An open-source CFML server. (18 November 2020)

Raku: Perl-themed object and functional language. (24 May 2024)

RapidAPI: World’s largest API marketplace. (01 July 2021)

RapidBATCH: A general-purpose scripting language platform for automation. (24 May 2024)

RaptorJIT: Dynamic language for system programming (LuaJIT fork). (22 May 2024)

RascalMPL: An experimental domain specific language for metaprogramming, such as static code analysis, program transformation, program generation and implementation of domain specific languages. (24 May 2024)

Ratchet: Build mobile apps with simple HTML‚ CSS‚ and JS components. (25 April 2022)

Rave: Rave is a statically typed, compiled, procedural, general-purpose programming language. (24 May 2024)

RavenDB: Document-oriented database in .NET. (01 July 2021)

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. (02 August 2021)

Ravenscript: A scripting language for the first-person team shooter game Ravenfield based on Lua. (02 August 2021)

Ravi: Ravi is a dialect of Lua with limited optional static typing and features a JIT compiler powered by MIR as well as support for AOT compilation to native code. (24 May 2024)

ravynOS: An OS aimed to provide the finesse of macOS with the freedom of FreeBSD. (11 May 2023)

React: SinglePageApplication component-based functional framework for the browser. (06 April 2022)

React Game Kit: Component library for making games with React & React Native. (06 April 2022)

Reactive ML: Synchronous reactive language that combines the temporal expressiveness of synchronous languages with the power of functional programming. (30 May 2024)

Reactive Streams: An initiative to provide a standard for asynchronous stream processing with non-blocking back pressure. This encompasses efforts aimed at runtime environments (JVM and JavaScript) as well as network protocols. (28 July 2021)

ReactiveUI: Use the Reactive Extensions for .NET to create elegant, testable user interfaces that run on any mobile or desktop platform. (30 May 2021)

React Native: An implementation that takes React source and executes it on mobile devices. (06 April 2022)

ReactOS: The open-source Windows clone. (05 February 2024)

Reading about Virtual Machines (implementation): A collection of interesting links and reading on VM-related topics. (21 December 2022)

Reading in Algorithms and Data Structures: A collection of books and articles on algorithms and data structures. Language-agnostic. (08 March 2024)

Reading in Artificial Intelligence: A collection of language-agnostic links on AI and Machine Learning. (11 May 2024)

Reading in mathematics: A collection of notes, articles, and free books on maths. (29 June 2023)

Reading list: Computer Science: Collection of articles, books I recommend around general Comp Sci topics. (26 April 2022)

Reading list: Hardware: Collection of articles, books I recommend around hardware topics. (26 April 2022)

Reading on software licensing: A collection of links around the licensing of software. (09 December 2022)

Reading on Testing: A collection of articles and ideas around software testing. (24 February 2023)

Readings on operating systems: Collection of links and notes on reading on operating systems. (06 April 2022)

Really Simple Syndication (RSS): XML-based format for syndicated sites. (24 May 2020)

Realm (Realm Database, Realm Object Server): Object database intended as a replacement for SQLite and other mobile data storage systems. (01 July 2021)

RealWorld: Exemplary fullstack Medium.com clone powered by React, Angular, Node, Django, ... multiple front-ends, multiple back-ends, all operating off of the same API specification. (27 December 2020)

Real World Haskell: Full text of the book online (06 April 2022)

Reaqtor: Reaqtor is a framework for reliable, stateful, distributed, and scalable event processing based on Rx. (06 April 2022)

Reason: Simple, fast & type safe code that leverages the JavaScript & OCaml ecosystems. (24 May 2024)

ReasonML: A syntax over OCaml that is easier to get started for programmers who are familiar with C-style syntax like JavaScript. (30 May 2024)

Rebol: A lean, extensible platform that operates over a variety of operating systems and devices. (02 August 2021)

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 (24 May 2024)

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. (06 April 2022)

Redis: An in-memory database that persists on disk. The data model is key-value, but many different kind of values are supported: Strings, Lists, Sets, Sorted Sets, Hashes, Streams, HyperLogLogs, Bitmaps. (20 January 2023)

RedisGraph: A graph database module for Redis. (20 January 2023)

Redline Smalltalk: Smalltalk implementation for the JVM. (31 May 2020)

Redox: A Unix-like Operating System written in Rust, aiming to bring the innovations of Rust to a modern microkernel and full set of applications. (26 February 2023)

Redux: State management for React. (06 April 2022)

RedwoodJS: The App Framework for Startups (26 February 2023)

Refactoring to HTML: Early thoughts about how to get back to HTML-first web page design. (06 April 2022)

Reflow: A language and runtime for distributed, incremental data processing in the cloud. (21 November 2020)

Regent (Regent-Lang): A language for implicit dataflow parallelism. (02 August 2021)

Rel: A desktop database management system that implements the "Tutorial D" database language. (11 May 2023)

Relate: Website builder (11 July 2021)

Relational Model: Thoughts/articles on the relational model of storage. (19 May 2023)

Release It!: Patterns/concepts around what it takes to make software "production-ready". (06 April 2022)

Remote: Office Not Required: DHH's screed on remote work. Most of it is now (2021) more widely-accepted as a given, but still useful as a reference. (02 June 2023)

Remote management: Topics and links around remote management of teams. (26 April 2022)

Remult: A CRUD framework for full-stack TypeScript. (24 May 2022)

Ren'Py: A visual novel engine that helps you use words, images, and sounds to tell interactive stories that run on computers and mobile devices. These can be both visual novels and life simulation games. (10 May 2022)

Renjin: JVM-based interpreter for the R language for the statistical analysis. The primary goals of the project are to provide a modern interpreter that serves as a drop-in replacement for GNU R, but is easier to integrate with other systems, offers better performance, and is more extensible. (24 May 2024)

ReoScript: Sn ECMAScript-like script language runner for .NET applications. By using ReoScript, the application would be able to run own extended script library. (06 April 2022)

Replicache: An in-browser persistent key-value store that is git-like under the hood. (11 May 2023)

Replicant: A mobile operating system focusing more on older devices. (03 October 2022)

Replit: Build software collaboratively from anywhere in the world, on any device, without spending a second on setup. (26 February 2023)

Representational State Transfer (REST): Collection of links and reading and notes on Fielding's dissertation. (06 April 2022)

Req: A simple and opinionated HTTP scripting language. It is designed for easily making HTTP requests, and working with their responses. Below is an example that calls out to the GitHub API and displays the user making the call. (24 May 2024)

Rescript: A robustly typed language that compiles to efficient and human-readable JavaScript. (24 May 2024)

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. (05 July 2021)

Reshape: A zero-downtime schema migration tool for Postgres. (12 May 2022)

Resource Description Framework (RDF): A data format for Semantic Web involving triplets of data. (06 April 2022)

Resources List: Compilers: Collection of articles, books I recommend around general compilers/interpreters topics. (30 May 2024)

Rest# (Rest-Sharp): HTTP client library for the CLR. (16 May 2020)

REST Assured: Java DSL for easy testing of REST services (16 May 2020)

RestDB.io: Simple online NoSQL database backend with automatic APIs and low code javascript hooks. (30 May 2020)

Restful Objects: A generic way to expose a domain model through a REST (or more precisely, hypermedia) API. (01 January 2023)

reStructuredText (reST): Plaintext markup syntax and parser system. (03 May 2022)

RetDec: A retargetable machine-code decompiler based on LLVM (01 July 2021)

RethinkDB: Distributed document database. (30 May 2020)

Retlang: A high performance C# threading library (see Jetlang for a version in Java). The library is intended for use in message based concurrency similar to event based actors in Scala. The library does not provide remote messaging capabilities. It is designed specifically for high performance in-memory messaging. (28 July 2021)

Retool: Build internal tools, remarkably fast. (07 July 2021)

Reversing/reverse engineering: A collection of notes and reading on going from executable code back to source (or source-like). (06 April 2022)

RevoltChat: Open-source user-first chat service. (31 December 2022)

Rework: DHH's book on business (and, to a much lesser degree, management). (06 April 2022)

Rewrite: Rewrite is estimated to be a Turing complete, s-expression based term rewriting system. Its original intention is operating over s-expressions to expand asserted template occurrences while aiming to be intuitive enough to introduce code templating to non-technical users. To try Rewrite within browser, please refer to [Rewrite Playground](https://contrast-zone.github.io/rewrite/playground/index.html). (24 May 2024)

Rexx: A structured, high-level programming language designed for ease of learning and reading. (24 May 2024)

RFD (Request For Discussion): A means by which architectural (and other) decisions can be made collaboratively. (24 February 2023)

Rhai: An embedded scripting language for Rust inspired by ChaiScript. (24 May 2024)

Rhovas: A programming language for API design and enforcement. (24 May 2024)

Riak: Highly available, operationally simple, distributed database. (06 April 2022)

Ribbon: Ribbon is a dynamic interpreted programming language. It's inspired by the likes of Python, Javascript and a little bit of Lua. (24 May 2024)

Rich CLI: A command line toolbox for fancy output in the terminal. (06 April 2022)

Rickroll: A light meme based, process oriented, dynamic, strong, esoteric programming language. All of the keywords/statements are came from Rick Astley's lyrics. I believe that rick roll is not only a way to promote people's communication, it is also one of the most paramount art in the human history. The purpose of the Rickroll Language is to introduce this art to people in a distinctive way - programming. (24 May 2024)

Rick Roll: A rickroll based, process oriented, dynamic, strong, esoteric programming language. (03 November 2022)

RIFE2: A full-stack, no-declaration, framework to quickly and effortlessly create web applications with modern Java. (22 December 2022)

Ring: A language supporting Imperative, Procedural, Object-Oriented, Functional, Meta programming, Declarative programming using nested structures, and Natural programming. (24 May 2024)

Rintagi: Open-source low-code development platform for mission-critical applications. (07 June 2021)

Rio: A script-feeling, safe, naturally compatible replacement for C, with no runtime nor std lib of its own. (24 May 2024)

RISC-V Assembly: Assembly language for the RISC-V architecture. (26 February 2023)

RISC-V Reading: A collection of resources and reading around the RISC-V CPU/assembly platform. (06 April 2022)

RISC-V Software: A collection of links to software (tools, libraries, etc) around the RISC-V CPU/assembly specification. (06 April 2022)

Rivescript: A RiveScript interpreter for JavaScript. RiveScript is a scripting language for chatterbots. (06 October 2022)

Rivet: A general-purpose programming language, focused on simplicity, safety and stability. (24 May 2024)

Robin: Robin is a functional programming language with eager evaluation, latent typing, and a homoiconic syntax (see Scheme), based on a radically simple core semantics (see Pixley) in which both functions and macros are defined in terms of a more basic abstraction, the fexpr. Expressions in Robin are referentially transparent; programs interact with the outside world through an event-oriented framework. (24 May 2024)

Robomongo / Robo 3T: Shell for SQL and MongoDB. (01 July 2021)

Robot Framework: A generic open source automation framework. It can be used for test automation and robotic process automation (RPA). (30 March 2021)

RobotWar: Links to games in which one programs a robot to do battle in an arena. (06 April 2022)

Roc: A fast, friendly, functional language. (24 May 2024)

Rock: Little language made with Rust and LLVM. Aim to follow the enforced safeness of the Rust model with a borrow checker (SoonT) and achieve high native performances thanks to LLVM. Rock is highly inspired from Livescript and Rust, and will also borrow (pun intended) some features from Crystal, from functional languages like Haskell, and even from Rust itself. (24 May 2024)

RocketMQ: A unified messaging engine, lightweight data processing platform. (06 April 2022)

RocksDB: A library that provides an embeddable, persistent key-value store for fast storage. (14 March 2023)

Rockstar: A dynamically typed computer programming language, designed for creating programs that are also song lyrics. (15 July 2023)

Rococoa: Allows you to call Objective-C code through Java classes and interfaces that you define. (19 May 2023)

ROFLKODE: An imperative, block structured, statically-typed programming language that is very similar to Adam Lindsay's language LOLCODE. (30 May 2024)

Roman II: Roman II is a dynamic programming language with a naive mark and sweep garbage collector, all written from the ground up in about 5000 lines of the GNU11 dialect of C. (24 May 2024)

Rools: A small rule engine for Node. (30 March 2021)

Ropper: ROP gadget finder and binary information tool (ELF, PE, Mach-O) (16 May 2020)

Rowy: An open-source Airtable-like UI for your database and to build serverless cloud functions visually in the context of your data. (06 April 2022)

Roy: An experimental programming language that targets JavaScript. It tries to meld JavaScript semantics with some features common in static functional languages. (02 August 2021)

RPG: An older imperative language (with some modern implementations). (29 December 2023)

RPL2: Reverse Polish Lisp/2 release 4.1.31, half-compiled high-level language using shared libaries and mainly aiming at scientific calculations and complex algorithms (24 May 2024)

rpn: rpn - Reverse Polish Notation CLI calculator. A math functional language using reverse (postfix) polish notation (24 May 2024)

RPython: A translation and support framework for producing implementations of dynamic languages, emphasizing a clean separation between language specification and implementation aspects. (20 December 2022)

rst (ReStructured Text): A file format created by the Python community to write documentation. A markdown language like HTML but is much more lightweight and easier to read. (06 April 2022)

Rubinius: A modern language vm that supports a number of programming languages. (15 May 2020)

Ruby: A dynamic language. (06 April 2022)

RubyMotion: Bridge for writing cross-platform apps in Ruby. (06 April 2022)

ruby-opengl: OpenGL wrapper for Ruby. (06 April 2022)

Ruffle: A Flash Player emulator built in the Rust programming language. (12 July 2023)

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. (02 August 2021)

Rules Engine: A Json based Rules Engine with extensive Dynamic expression support. (31 March 2021)

Rune: Embeddable dynamic programming language for Rust. (24 May 2024)

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. (01 November 2022)

Rust: Native language intended to supplement or replace C/C++ someday. (24 February 2023)

RustScript: RustScript is a functional scripting language with as much relation to Rust as Javascript has to Java. (24 May 2024)

RxDB: A fast, offline-first, reactive database for JavaScript Applications. (11 May 2023)

S4: A minimal and extendable stack machine VM/CPU (08 March 2024)

SaC: Single-Assignment C is an array programming language predominantly suited for application areas such as numerically intensive applications and signal processing. Its distinctive feature is that it combines high-level program specifications with runtime efficiency similar to that of hand-optimized low-level specifications. Key to the optimization process that facilitates these runtimes is the underlying functional model which also constitutes the basis for implicit parallelisation. This makes SAC ideally suited for harnessing the full potential of a wide variety of modern architectures ranging from a few symmetric cores with shared memory to massively parallel systems that host heterogeneous components including GPUs and FPGAs. (24 May 2024)

Safari (Browser): The Apple macOS/iOS Web browser as a platform. (06 April 2022)

SAFE Stack: Full-stack web development based on F# throughout each layer. (05 July 2021)

SailsJS: A Model-View-Controller web application framework developed atop the Node.js environment (01 July 2021)

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. (01 July 2021)

Salt: Compilation target that functional programmers always wanted. (22 May 2024)

Saltcorn: A platform for building database web applications without writing a single line of code. Use the intuitive point-and-click, drag-and-drop user interface to build the whole application (06 April 2022)

Samples: Collection of collections of sample files (usually for tools to test on). (16 May 2020)

Sapphire (Ruby in Steel): A professional Ruby development environment for Visual Studio. (06 April 2022)

SASM: Simple crossplatform IDE for NASM, MASM, GAS, FASM assembly languages (06 April 2022)

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. (05 July 2022)

SATySFi: SATySFi (pronounced in the same way as the verb “satisfy” in English) is a new typesetting system equipped with a statically-typed, functional programming language. It consists mainly of two “layers” ― the text layer and the program layer. The former is for writing documents in LaTeX-like syntax. The latter, which has OCaml-like syntax, is for defining functions and commands. SATySFi enables you to write documents markuped with flexible commands of your own making. In addition, its informative type error reporting will be a good help to your writing. (24 May 2024)

Scala: A functional/object hybrid for the JVM. (06 April 2022)

Scalable Vector Graphics (SVG): An XML-based vector image format for two-dimensional graphics with support for interactivity and animation. (01 July 2021)

Scale: Open Source stack-based concatenative programming language. (22 May 2024)

Scapy: Python-based interactive packet manipulation program & library. (10 May 2022)

SchemaCrawler: A relationaldatabase schema discovery and comprehension tool. (29 June 2023)

Scheme: Scheme is a dialect of the Lisp family of programming languages. It was the first dialect of Lisp to choose lexical scope and the first to require implementations to perform tail-call optimization, giving stronger support for functional programming and associated techniques such as recursive algorithms. It was also one of the first programming languages to support first-class continuations. (24 May 2024)

Scheme: Homoiconic dynamic functional(ish) language derived from Lisp. (21 December 2022)

Scion: A suite of software for standard state machine support. (01 July 2021)

Sciter: Embeddable HTML/CSS/script engine for modern UI development (06 April 2022)

ScottLogic Blog: A collection of blogs from a UK consulting company. (30 May 2021)

Scratch: A fork of Google's Blockly project that provides a design specification and codebase for building creative computing interfaces. (27 July 2021)

Scratchapixel: A free educational site that progressively introduces you to the world of computer graphics. (29 June 2023)

ScratchJr: an introductory programming language that enables young children (ages 5-7) to create their own interactive stories and games. (27 July 2021)

Scratch VM: Virtual Machine used to represent, run, and maintain the state of programs for Scratch 3.0. (27 July 2021)

Screeps: MMO sandbox game for programmers; "scripting creeps" is an open-source game for programmers, wherein the core mechanic is programming your units' AI. You control your colony by writing JavaScript. (06 April 2022)

ScummVM: Classic VM environment for running graphical point-and-click adventure games and RPGs. (04 May 2020)

Scuttlebutt: A decentralized platform. (06 April 2022)

Scuttlebutt (protocol): How Scuttlebutt (a decentralized peer-to-peer protocol) peers find and talk to each other. (06 April 2022)

SCXML (State Chart XML): State Machine notation for control abstraction specification. (01 July 2021)

SDL: A library commonly used for core input and output of games. (05 February 2024)

SDL (Specification and Definition Language): A specification language targeted at the unambiguous specification and description of the behaviour of reactive and distributed systems (04 May 2020)

SeaTable: A new kind of spreadsheet/database and data automation application. It helps you to easily record and manage all kinds of scattered information. With built-in automation features, scripts and APIs, you can automate data processing with no code or little code. (11 July 2021)

sed: The "stream editing" tool from UNIX. (06 April 2022)

Seed7: A general purpose programming language transpiling to C and higher-level compared to Ada, C/C++ and Java. (24 May 2024)

Self: An object-oriented programming language based on the concept of prototypes. (24 May 2024)

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. (09 February 2023)

SemanticUI: A UI component framework based around useful principles from natural language. (01 November 2020)

Semantic Web: A model of the web based more around its founder's original intent (hyperlinks and full-state "documents"). (01 July 2021)

Semmle QL: A declarative, object-oriented query language designed for program analysis. (01 July 2021)

Sencha (ExtJS): Comprehensive JavaScript framework for building data-intensive, cross-platform web and mobile applications for any modern device. (25 April 2022)

Senegal: A powerful, small-but-fast, concurrent, class-based, and dynamically-typed programming language with a modern syntax. (24 May 2024)

SerenityOS: Graphical Unix-like operating system for x86 computers. Roughly speaking, the goal is a marriage between the aesthetic of late-1990s productivity software and the power-user accessibility of late-2000s *nix. (06 April 2022)

Service Design Patterns: Collection of patterns specific to services. (07 June 2021)

Service Weaver: Service Weaver is a programming framework for writing and deploying cloud applications from a single monolithic binary into microservices. (29 June 2023)

SetlX: A language with support for sets and lists; as set theory is the language of mathematics, many mathematical algorithms that are formulated in terms of set theory have very straightforward implementations in SetlX. (13 July 2023)

Seven Kingdoms Ancient Adversaries: Real-time strategy game w/source. (30 December 2022)

S-Expressions: Abstract representations of an AST (among other things). (06 April 2022)

SFML (Simple and Fast Multimedia Library): A simple interface to the various components of your PC, to ease the development of games and multimedia applications. It is composed of five modules: system, window, graphics, audio and network. (06 April 2022)

SGScript: Features include a built-in data serialization format, coroutines, class-based OOP, sandboxed evaluation, a built-in debugger and profiler. (18 November 2020)

Shakespeare (Programming Language): Prithee, thou art desiring to program using Shakespearean English, art thou not? (12 July 2023)

ShapeCrawler: A .NET library for manipulating PowerPoint presentations. (01 January 2023)

sharedb: Realtime database backend based on Operational Transformation (OT). (31 December 2022)

Sharp Cells: Enjoy the full power of functional programming in the world's most popular functional programming environment. (24 February 2023)

Shattuck: Rust-based script programming language. (22 May 2024)

shc: shc - Generic shell script compiler (24 May 2024)

SheerPower: Sheerpower is a next generation database and scripting language for Windows. It is supported on Windows 10, 11, and Windows Server 2016 and above. (24 May 2024)

Shift (JavaScript AST): Defines an interface for an abstract syntax tree that can be used to represent the structure of an ECMAScript program, and tools that leverage that AST for interesting purposes. (17 January 2023)

Shiika: Statically-typed programming language. Looks like Ruby, but has explicit type annotations. (24 May 2024)

Ship It!: A collection of ideas for how to get software shipped. (06 April 2022)

Shoelace: A framework-independent component-based UX library. (26 February 2023)

Shoelace: A forward-thinking library of web components. (06 April 2022)

Silice: A language for hardcoding algorithms into FPGA hardware (24 May 2024)

Silk: Small system programming language. Flexible and simple as C, but more pleasant to write. (22 May 2024)

Silk: Markdown-based document-driven RESTful API testing. (16 May 2020)

Silk.NET: One-stop-shop for high-speed .NET multimedia, graphics, and compute; providing bindings to popular low-level APIs such as OpenGL, OpenCL, OpenAL, OpenXR, GLFW, SDL, Vulkan, Assimp, and DirectX; use to spruce up your games and applications with cross-platform 3D graphics, audio, compute and haptics. (01 January 2023)

SILK (Simple Interpreted Language Kit): A .NET class library that makes it easy to add scripting and automation to your .NET applications. (22 May 2024)

Silos, Politics, and Turf Wars: How to eliminate silos in organizations. (31 December 2020)

Silq: A high-level quantum language. (01 July 2021)

Silt: An in-progress fast, dependently typed, functional programming language implemented in Swift. (22 May 2024)

Simpl: Platform for developing process-controlled applications with Web front end. (06 April 2022)

SimpleActors: Wraps any Javascript object as an actor. (06 April 2022)

Simple Binary Encoding (SBE): Binary codec for several languages. (16 May 2020)

Simple DirectMedia Layer: A cross-platform development library designed to provide low level access to audio, keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D. (06 April 2022)

Simple Object Machine: A minimal Smalltalk for teaching of and research on Virtual Machines. (04 May 2020)

Simple Rules: Descriptions of how to guide behavior using simple rules. (02 June 2023)

SimpleScript: SimpleScript is a simple programming tool for scripting languages (Perl, PHP, Python, Ruby, TCL) written in Obj-C/Cocoa. It can be used by experienced developers to write and test on the fly small routines, and is a good solution for educational purposes. Do not use it in production environments or to manage large projects. (24 May 2024)

Simple State Machine Library: A simple library for realization state machines in C# code. (20 January 2023)

Simplexity: "Why Simple Things Become Complex (and how Complex Things Can Be Made Simple)." Simplexity is a whole new science redefining how we look at the world; seen through this lens, the world becomes a more delicate place filled with predictable patterns, which we often fail to see as we're time and again fooled by our instincts, our fear, the size of things, or even their beauty. (26 April 2022)

Simula: This is a new Simula System created by the Open Source Project 'Portable Simula Revisited'. The project was initiated as a response to the lecture held by James Gosling at the 50th anniversary of Simula in Oslo on 27th September, 2017. This Simula System is written in Java and compiles to pure Java code with one exception, the Goto Statement need to be corrected in the byte code, which is done automatically. (24 May 2024)

Singularity: From-scratch re-imagination of an operating system from Microsoft Research. (06 April 2022)

Sirius: Sirius is a general-purpose programming language which could best be described as a cross between Pascal and BASIC, although that may be misleading. Syntactically, it is similar to Pascal. Functionally, it resembles languages such as VAX BASIC and Borland's Delphi. Conceptually, it is like C in some respects: minimal keywords, access to low-level programming, etc. But the main idea behind Sirius is simply a programming tool which reduces the amount of time required to write applications. For instance, the language has all of the common data types built-in, so that you don't have to reinvent the wheel for linked lists, binary trees, queues, stacks, and the like. It also allows static strings and dynamic strings with automatic garbage collection. (24 May 2024)

SISAL: An efficient functional programming language for numerical computation on both serial and parallel computers. (08 July 2023)

SISC: SISC is an extensible Java based interpreter of the algorithmic language Scheme. SISC uses modern interpretation techniques, and handily outperforms all existing JVM interpreters (often by more than an order of magnitude). (24 May 2024)

SiteJS: (No summary) (30 March 2021)

Sixten: Experimental functional language where all data is unboxed by default. Functional programming with fewer indirections. (22 May 2024)

Skew: Web-first, cross-platform programming language with an optimizing compiler. (22 May 2024)

Skip: Programming language to skip the things you have already computed. (22 May 2024)

Skip (or Skiplang): A general-purpose programming language that provides caching with features like reactive invalidation, safe parallelism, and efficient garbage collection. (30 May 2020)

Skriv/SkrivML: A lightweight markup language. (01 November 2022)

Skyve: an open-source platform that gives you access to all of the key capabilities need to build sophisticated, robust and scalable cloud solutions. Skyve is platform/operating-system independent, works with all common database types, and is accessible through all common browsers and devices. (06 April 2022)

Slang: Statically typed scripting language... syntax errors should be catched at design time! (24 May 2024)

Slang2: S-Lang is a multi-platform programmer's library designed to allow a developer to create robust multi-platform software. It provides facilities required by interactive applications such as display/screen management, keyboard input, keymaps, and so on. The most exciting feature of the library is the slang interpreter that may be easily embedded into a program to make it extensible. While the emphasis has always been on the embedded nature of the interpreter, it may also be used in a stand-alone fashion through the use of slsh, which is part of the S-Lang distribution. (24 May 2024)

Slashbase: The open-source modern database IDE. (29 June 2023)

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. (27 July 2021)

Sleep: A Java-based scripting language heavily inspired by Perl. (30 November 2022)

sli.dev: Create presentations/slides from Markdown. (29 June 2023)

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. (01 November 2022)

SMAL: The machine independant SMAL assembler and linker supports conditional and macro assembly and all linkage editing operations commonly associated with languages such as FORTRAN and C. It comes with a user's manual that also explains how to customize it to support a variety of machine instruction sets. (24 May 2024)

SmallBASIC: SmallBASIC is a fast and easy to learn BASIC language interpreter ideal for everyday calculations, scripts and prototypes. SmallBASIC includes trigonometric, matrices and algebra functions, a built in IDE, a powerful string library, system, sound, and graphic commands along with structured programming syntax. (24 May 2024)

Small Basic: A stripped-down/"lean" version of Basic for learning programming. (06 April 2022)

SmallDragon: Simple, statically typed programming language that can be transpiled to C. (22 May 2024)

Smalltalk: The original object-oriented programming language, emphasizing multiple inheritance and message-passing. (22 January 2024)

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. (21 November 2020)

SmashTest: An open-source tool and language for rapidly generating tests. (27 July 2021)

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. (02 June 2021)

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. (30 May 2024)

Smudge: Domain-specific language for state machines. (22 May 2024)

Snap: A visual, blocks-based programming language. (05 February 2024)

SOA Design Patterns: A collection of patterns specific to service-orientation. (07 June 2021)

Soar: A general cognitive architecture for developing systems that exhibit intelligent behavior. (11 May 2024)

Software Design: Collection of links, blogs, articles and other reading material on software design. (19 May 2022)

Software development for beginners: A collection of resources for those just starting on the journey. (10 May 2022)

Software development roles: A collection of links and notes on the different roles that can/do appear in software dev teams. (26 February 2023)

Software Foundations: A broad introduction to the mathematical underpinnings of reliable software. (08 March 2024)

Software reading: A collection of reading about software. (06 April 2022)

Solar2D: Lua based game engine with focus on ease of iterations and usage. (01 July 2021)

Solidity: Solidity is an object-oriented programming language for implementing smart contracts on various blockchain platforms, most notably, Ethereum. (24 May 2024)

sones: An object-orientated graph data storage for a large amount of highly connected semi-structured data in a distributed environment. (07 June 2021)

Sorbet: A fast, powerful type checker designed for Ruby. (30 July 2021)

Souffle: A logic programming language inspired by Datalog. (12 July 2023)

Souffle: A logic programming language inspired by Datalog. (25 May 2023)

SOUL: An attempt to modernise and optimise the way high-performance, low-latency audio code is written and executed. (24 May 2024)

SourcePawn: Small and fast typed language for embedding in host applications. (22 May 2024)

SPA: A simple interpreter of a pseudo assembler language. (24 May 2024)

Space Cloud: Serverless cloud deployment platform. (06 April 2022)

spaCy: A free, open-source library for advanced Natural Language Processing (NLP) in Python. (03 May 2022)

sparcl: Sparcl: A Language for Partially-Invertible Computation. This is an implementation of a system presented in the paper: Kazutaka Matsuda and Meng Wang: Sparcl: A Language for Partially-Invertible Computation, ICFP 2020. (24 May 2024)

SPARK: SPARK stands for the Scanning, Parsing, and Rewriting Kit. It formerly had no name, and was referred to as the "little language framework." The first version (circa 1998) was described in the paper Little Languages in Python at the 7th International Python Conference. (24 May 2024)

Sparkjava: A micro framework for creating web applications in Kotlin and Java 8 with minimal effort. (09 February 2024)

SPARQL: A query language designed for semantic web data retrieval and update. (01 July 2021)

Sparrow: Open source game engine for iOS. (06 April 2022)

SPARTA: a library that provides the basic blocks for building high-performance static code analyzers based on Abstract Interpretation (01 July 2021)

Speaking.io: A website about public speaking. (06 April 2022)

Speaking reading: A collection of articles and resources about public (technical) speaking. (30 December 2022)

Spec#: A formal language for API contracts, which extends C# with constructs for non-null types, preconditions, postconditions, and object invariants. (01 November 2020)

Spectre Console: A .NET library that makes it easier to create beautiful console applications. (06 April 2022)

Speech and Language Processing (3rd ed): A online textbook (draft) of NLP topics. (08 January 2023)

Sphinx: Sphinx is a dynamically typed programming language that is inspired by Lua and Python, and implemented entirely in Rust! (24 May 2024)

Sphinx: A documentation tool written in Python (used to make Python website docs). (03 May 2022)

Spice: A spicy cross-platform UI framework. (24 February 2023)

Spider: A programming language that compiles to JavaScript (ES5 and ES6 targets). (24 August 2021)

SpiderBasic: SpiderBasic is new web client-side programming language based on established BASIC rules. Its allows development of very complex, windowed based web applications, including mobile app for iOS and Android. It provides a large commandset to handle complex and reactive GUI, 2D games, and many more in a coherent manner. Every library and commands behave the same and have similar syntax for easier and faster learning. (24 May 2024)

Spiral: Functional language with intensional polymorphism and first-class staging. (24 May 2024)

Spoofax Language Workbench: A platform for developing textual (domain-specific) programming languages. (30 December 2022)

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. (01 January 2023)

Spring: Rod Johnson's "everything but EJB" application server based on dependency injection. (06 April 2022)

Spring (Game Engine): A free RTS game engine developed for Windows, Linux and Mac OS X. (06 April 2022)

SpringIO: Conference for Spring topics. (14 March 2023)

SpriteKit: Apple's 2D game toolkit for iOS. (11 May 2023)

Spry: A Smalltalk and Rebol inspired language implemented as an AST interpreter in Nim. (12 July 2023)

SQL.js (SQLite in JavaScript): A javascript library to run SQLite on the web. (17 January 2023)

SQL (Structured Query Language): Standard language for querying (and updating) a relational database, originally intended for ad-hoc usage from an interactive prompt. (06 April 2022)

Sql+NET: A build time ORM designed to complement the skills of SQL developers. (18 May 2022)

SQLglot: A no dependency Python SQL parser, transpiler, optimizer, and engine. (30 January 2023)

SQLite: A C-language library that implements a small, fast, self-contained, high-reliability, full-featured, SQL database engine. (13 January 2024)

Squeak: Open-source Smalltalk system. (06 April 2022)

Squeak VM: The VM for the Squeak implementation of Smalltalk. (10 May 2020)

SquidLib: Useful tools for roguelike, role-playing, strategy, and other grid-based games in Java. (30 May 2021)

Squilu: A scripting language that accepts a subset of javascript and C/C++. (24 May 2024)

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. (24 May 2024)

SR: SR (Synchronizing Resources) is a language for writing concurrent programs. The main language constructs are resources and operations. Resources encapsulate processes and variables they share; operations provide the primary mechanism for process interaction. SR provides a novel integration of the mechanisms for invoking and servicing operations. Consequently, all of local and remote procedure call, rendezvous, message passing, dynamic process creation, multicast, and semaphores are supported. SR also supports shared global variables and operations. (24 May 2024)

SSCLI Essentials: by Stutz, Shilling, Pobar and myself on the Shared Source CLI, the predecessor to the .NET Core CLR. (30 July 2021)

STABLE: An extreme small an fast FORTH-VM (08 March 2024)

StackEdit: Add StackEdit to any website. (09 February 2024)

StackStorm: A platform for integration and automation across services and tools, taking actions in response to events; event-driven automation for auto-remediation, security responses, troubleshooting, deployments, and more. Includes rules engine, workflow, 160 integration packs with 6000+ actions (see https://exchange.stackstorm.org) and ChatOps. (06 April 2022)

Staff Engineer: Leadership Beyond the Management Track: Not everyone needs to be the boss. (02 June 2023)

Star: An experimental programming language that's made to be powerful, productive, and predictable. One of the most important goals of Star is that it's designed to be completely consistent. In other words, Star has been designed to not have edge cases, footguns, or any sort of "magic" that's exclusive to language built-ins. (24 May 2024)

Starcounter: "Fused" ACID memory centric database engine and C# VM. (21 December 2020)

Stark: A a safe and efficient system programming language seeking to be inspired by C# but not compatible. (24 May 2024)

Starlark: Deterministic language inspired by Python3, used for configuration in the build systems Bazel and Buck. (24 May 2024)

Starlark (formerly Skylark): A language intended for use as a configuration language, based on Python syntax. (01 August 2021)

Starling: Cross-platform game engine. (06 April 2022)

StarShip: Interpreted, strongly typed, and functional programming language written in Swift. (22 May 2024)

Stateless: A simple library for creating state machines in C# code. (20 January 2023)

Static analysis tools - benchmarking: A collection of readings around benchmarking and deciding between static analysis tools. (06 April 2022)

Static analysis - verification: A collection of readings on static analysis for verificatio of safety of programs. (06 April 2022)

Staticgen: A list of static site generators for Jamstack sites. (01 July 2021)

Static Program Analysis: A collection of resources and readings on static program analysis (06 April 2022)

Static Site Generators list: The definitive listing of Static Site Generators. (19 December 2022)

Statiq: Static generation platform, allowing you to use or create a static generator that's exactly what you need. (01 July 2021)

Steeltoe: An open source project that provides a collection of libraries that helps users build production-grade cloud-native applications using externalized configuration, service discovery, distributed tracing, application management, and more. (01 January 2023)

STELLA: A strongly typed, object-oriented, Lisp-like language, designed to facilitate symbolic programming tasks in artificial intelligence applications. (12 July 2023)

STELLA: Lisp-style symbolic programming with delivery in Common Lisp, C++ and Java (08 July 2023)

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. (07 April 2022)

Steve Yegge Rants: Some links/excerpts from Yegge's various rants. (29 June 2023)

STOICAL: STOICAL is vastly different from its predecessors. Primarily because so much has changed since the decades ago that they were developed. Today STOICAL is powerful and general enough to be used as a high performance replacement for semi-compiled and interpreted languages like Perl, Python, SED and Awk. And because of STOICAL's advanced support for networking and concurrent threads of execution, it can be used to write efficient long-running servers and daemons that would normally need to be written in C. The intent here is not to explore the intricacies of archaic systems, but to create a new and modern language, well suited to the world as it exists today. STOICAL might therefore be more accurately represented by the recursive acronym SINS, SINS Is Not STOIC, but this word has a remarkable stigma attached to it ;-) (24 May 2024)

Storj: Decentralized cloud storage. (06 April 2022)

Storyscript: Magical coding language for tomorrow’s developer; the other 1 billion people not in GitHub. (15 November 2020)

StorySynth: Make, play, and share storytelling games. (24 February 2023)

Storyteller: Solutions for creating robust, human readable acceptance tests for your .Net or CoreCLR system and a means to create "living" technical documentation. (06 April 2022)

Strapi: Node.js Headless CMS to build customisable APIs. (06 April 2022)

Streamlit: Turns data scripts into shareable web apps in minutes. All in pure Python. No front‑end experience required. (11 May 2024)

Streamlit: Turns data scripts into shareable web apps in minutes. (06 April 2022)

Streem: Streem is a stream based concurrent scripting language. It is based on a programming model similar to the shell, with influences from Ruby, Erlang, and other functional programming languages. (24 May 2024)

StrictlyFalse: I have designed an eccentric programming language (Strictly False) an extension of Wouter van Oortmerssen's elegant False programming language. ... to run my interpreter (and my language is definitely more powerful), you need Moscow ML. (24 May 2024)

Stride3D: Open-source C# game engine. (06 April 2022)

Strongtalk: A bytecode-based virtual machine that formed the core of the modern JVM. (04 May 2020)

Stroscot: Stroscot is an imperative programming language designed for modern processors. (24 May 2024)

Stroyent: Stroyent is an infix, procedural systems programming language targeting MakoVM. Stroyent syntax superficially resembles that of C, but there are many important differences in the semantics of these languages. (24 May 2024)

Structure and Interpretation of Computer Programs (SICP): The classic treatise on the tiny barrier between code and data. (03 May 2022)

Structurizr: Builds upon "diagrams as code", allowing you to create multiple diagrams from a single model, using a number of tools and programming languages. (06 April 2022)

Suave: A simple web development F# library providing a lightweight web server and a set of combinators to manipulate route flow and task composition. (10 April 2022)

SubC: A fast and simple public domain compiler for a clean subset of the C programming language. (24 May 2024)

Sugar: A language to make JavaScript programming sweeter. (01 July 2021)

SugarCubes: Synchronous (à la Boussinot) reactive language that allows to write reactive parallel/concurrent programs on top of sequential JavaScript. (30 May 2024)

Sulu: Modern Symfony based CMS. (06 April 2022)

Suneido: Suneido™ is a complete, integrated application platform – a system for developing and deploying applications without the frustrations of integrating multiple different products. Suneido incorporates an object-oriented programming language, client-server relational database software, and application frameworks and components. It includes the integrated development environment (IDE) used to create applications as well as the client and server required to run applications across networks. Suneido is Open Source – it is provided free, with complete source code. (24 May 2024)

Supabase: Backend server with REST APIs to manage core backend needs. (24 November 2023)

Superblocks: A programmable IDE for developers to build any internal app, workflow, or scheduled job. (26 February 2023)

Superbosses: A study of what makes 'superbosses'--those bosses who create a large 'coaching tree' of excellent managers--tick. (24 November 2023)

Supercollider: An audio server, programming language, and IDE for sound synthesis and algorithmic composition. (05 February 2024)

Superforecasting: The Art and Science of Prediction: Notes on the book, about how non-experts can often outpredict the experts by following some remarkably straightforward approaches. (30 May 2024)

Superx++: Superx++ is an object-oriented language that is entirely based on XML's syntactical structure. Superx++ conforms with the XML version 1.0 specification as published on the W3C web site. Programming in XML itself has great potential and Superx++ pushes the envelope! (24 May 2024)

Surprising Science of Meetings: Notes from the book. (25 May 2023)

SurrealDB: A single easy-to-use API for relational, document and graph databases. (08 March 2024)

SushiVM: A JIT-enabled virtual machine and scripting interpreter. (01 November 2022)

Svelte: A framework for building websites. (06 April 2022)

Swarm: JavaScript replicated model (M of MVC) library. (06 April 2022)

Sway: The irresistable pull of irrational behavior (26 April 2022)

SweetJS: Semantic macros for ECMAScript. (01 November 2020)

Swift: A second-generation object-oriented language with functional overtones. (03 May 2022)

Swift FFI: Swift Foreign Function Interface notes. (03 May 2022)

Swift Playgrounds: Swift Playgrounds are a combination of documentation and code in a interactive format (inside of XCode) or documentation (HTML). (03 May 2022)

SwiftWasm: Write Swift, compile to WASM/WebAssembly bytecode. (06 April 2022)

Swirl: Open-source software that uses AI to simultaneously search multiple content and data sources, finds the best results using a reader LLM, then prompts Generative AI, enabling you to get answers from your own data. (29 December 2023)

Switch: How to Change Things When Change Is Hard (06 April 2022)

SymmetricDS: Open-source database replication software that focuses on features and cross-platform compatibility. (24 November 2023)

symtool: Static symbol manipulation tool for ELF and Mach-O objects. (16 May 2020)

Syncano: A development platform for building more, faster by leveraging existing backend code. (16 May 2020)

Syntax Definition Formalism (SDF): a metasyntax used to define context-free grammars: that is, a formal way to describe formal languages. It can express the entire range of context-free grammars. (30 May 2024)

Systems Thinking: Collection of notes links, articles, blog posts and other resources on systems thinking. (29 June 2023)

T3X: T3X is a small, portable, procedural, block-structured, recursive, almost typeless, and to some degree object-oriented programming language. Its syntax is similar to Pascal, its semantics resembles BCPL's. (24 May 2024)

T3XFORTH: T3XFORTH is an old-school, plain vanilla FORTH system that is mostly compatible to FORTH-79 with some parts borrowed from FIG FORTH, FORTH-83, and EFORTH, and taking some inspiration from Leo Brodie's (classic, 1983) book, "Starting FORTH". T3XFORTH runs on 8086 processors under DOS on an IBM PC, or stand-alone using the PC BIOS. It can also run on 32-bit Unix systems using a T3XFORTH VM emulator. (24 May 2024)

TabbyML: Opensource, self-hosted AI coding assistant. (22 January 2024)

TableM: A relational language. (24 May 2024)

Tabloid: A minimal programming language inspired by clickbait headlines. (01 November 2022)

Tabris: Native mobile apps in JavaScript. TypeScript is a first class citizen for app development with Tabris.js. (01 August 2021)

TabrisJS: Native mobile apps in JavaScript. TypeScript as a first class citizen for app development.. (24 August 2021)

TADS: Authoring system for writing Interactive Fiction. (10 May 2022)

TaffyDB: JavaScript database. (01 July 2021)

Taichi: Language for high-performance, sparse & differentiable graphics computing. (24 May 2024)

TAMGU: FIL programming language: Functional, Imperative, Logical all in one for annotation and data augmentation. (24 May 2024)

Tamsin: Tamsin is an oddball little language that can't decide if it's a meta-language, a programming language, or a rubbish lister. Its primary goal is to allow the rapid development of parsers, static analyzers, interpreters, and compilers, and to allow them to be expressed compactly. Golf your grammar! (Or write it like a decent human being, if you must.) (24 May 2024)

Tandem: Tandem is an experimental rewriting language where the rewrite rules form a Kleene algebra. The object being rewritten by a Tandem program is a collection of labelled stacks -- a finite mapping from strings to strings. The strings are always rewritten at the left edge, so they are effectively stacks. A Tandem program consists of a single rewrite rule along with zero or more pragmas. The rewrite rule is applied to an initial state to possibly obtain a final state. This rule is applied only once. However, in Tandem, a rule is a composite object which may contain subrules that get applied many times. (24 May 2024)

Tangle: Radically simple multiplayer networking apps. (24 February 2023)

Tao: Statically-typed functional programming language. (24 May 2024)

Tao3D: Tao3D is a dynamic document description language designed specifically for real-time 3D animations. It can be used to present complex information in an entertaining and interactive way. (24 May 2024)

Tap: A note-taking system that uses SMS and other approaches rather than a single app. (06 April 2022)

tasm (Turbo Assembler): Borland's assembler for x86. (06 April 2022)

Tau: Open source interpreted programming language designed to be minimal, fast and efficient. (22 May 2024)

Tauri: Build smaller, faster, and more secure desktop applications with a web frontend (30 March 2021)

Taxi: A language for describing API's and their models. (06 April 2022)

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! (30 May 2024)

Tcl/Java: Implementation of Tcl on the JVM. (30 November 2022)

Tcl (Tool Control Language): A high-level scripting language vaguely object-like. (24 May 2024)

TDengine: Database designed to process time series data. (06 April 2022)

TDL: A prototype-based event-driven language with influences from ooc, Ruby, and Ioke. (24 August 2021)

Teach Yourself Computer Science: A collection of links for learning CS for those who didn't study it at school. (06 April 2022)

Teach Yourself Scheme in Fixnum Days: Scheme tutorials. (06 April 2022)

Team Topologies: Organizing business and technology teams for fast flow. (06 April 2022)

TeaVM: Compiles Java bytecode to JavaScript, WebAssembly and C (08 March 2024)

TechBash: A developer conference in the northeast (US). (14 March 2023)

Technology Fallacy: How people are the real key to digital transformation (06 April 2022)

Tempo: "timing, tactics and strategy in narrative-driven decision-making." Tempo is a modern treatment of decision-making that weaves together concepts and principles from the mathematical decision sciences, cognitive psychology, philosophy and theories of narrative and metaphor. (26 April 2022)

Temporal: A developer-first, open source platform that ensures the successful execution of services and applications (using workflows). (18 December 2022)

Temporal: Workflows as code platform. (06 April 2022)

Tengo: Fast script language for Go. (22 May 2024)

Terminal.GUI: Console-based user interface toolkit. (18 May 2022)

TerminusDB: Knowledge graph and document store. (06 April 2022)

Terra: A low-level system programming language that is embedded in and meta-programmed by the Lua programming language. (24 May 2024)

TerraFx.Interop.Windows: Interop bindings for Windows. (06 April 2022)

Tesseract Game Engine: A first-person shooter game focused on instagib deathmatch and capture-the-flag gameplay as well as cooperative in-game map editing. Provides a unique open-source engine derived from Cube 2: Sauerbraten technology but with upgraded modern rendering techniques. The new rendering features include fully dynamic omnidirectional shadows, global illumination, HDR lighting, deferred shading, morphological/temporal/multisample anti-aliasing, and much more. (06 April 2022)

Testing: A collection of links and resources around testing (24 November 2023)

TextBundle: A file format for bundling text (Markdown) and binary (images, etc) in one file. (24 August 2021)

Textual: A Rapid Application Development framework for Python. (29 June 2023)

textX: DSL library for Python. (24 August 2021)

The 1-Week Marketing Plan: How to build a marketing plan in one week. (25 November 2020)

The Advantage: (Placeholder) (06 April 2022)

The Art of Concurrency: Thoughts on implementation using concurrent mechanics. (06 April 2022)

The Big List of Naughty Strings: The Big List of Naughty Strings is a list of strings which have a high probability of causing issues when used as user-input data. (03 May 2022)

The Book on Writing: Notes on writing mechanics. Very tactical. (06 April 2022)

The Business Value of Developer Relations: Notes from the book. (30 December 2022)

The Coaching Habit: Say Less, Ask More & Change the Way You Lead Forever (06 April 2022)

The Elephant in the Brain: Hidden motives in everyday life; a study of the intrinsic selfishness of the human brain. (31 December 2020)

The Eleven Laws of Showrunning: A showrunner's manifesto about being an executive producer on a TV show. (24 February 2023)

The Essence of Compiling with Continuations: A paper on compilation using continuations as a key element. (30 May 2024)

The Field Guide to Understanding 'Human Error' (3rd Ed): A new view of accidents caused by 'human error'. (24 November 2023)

The Five Dysfunctions of a Team: Understanding teamwork and overcoming the common dysfunctions of a team. (21 February 2021)

The Five Temptations of a CEO: Five ways CEOs go wrong and how to avoid them. (06 April 2022)

The Four Obsessions of an Extraordinary Executive: (Placeholder) (06 April 2022)

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. (01 July 2021)

The Ideal Team Player: What makes for the ideal hire on your team? (06 April 2022)

The Kick Ass College Guide to Presentations: A collection of ideas to make public speaking go well. (25 November 2020)

The Motive: (Placeholder) (06 April 2022)

The Online Books Page: Listing over 3 million free books on the Web (30 May 2021)

The Passionate Programmer: Chad Fowler's successor to "My Job Went to India (and All I Got Was This Lousy Book)"; very much in the spirit of PragProg. (09 December 2022)

The Philosophical Programmer: A collection of discussions of philosophy as it meets programming. (11 May 2024)

The Reactive Manifesto: "We believe that a coherent approach to systems architecture is needed, and we believe that all necessary aspects are already recognised individually: we want systems that are Responsive, Resilient, Elastic and Message Driven. We call these Reactive Systems." (09 December 2022)

The Red Team Handbook: The Army's guide to making better decisions. (24 February 2023)

The Signal: A collaborative blog between the Digital Strategy Directorate and the Digital Content Management Section at the Library of Congress. Initially created in 2011 to share about digital preservation efforts, the blog has traced the evolution of digital practices at the Library over the course of a decade. (06 April 2022)

The Subtle Art of Not Giving a F*ck: Interesting modern take on Stoic thought and philosophy. (06 April 2022)

The Ultimate Public Speaking Survival Guide: Notes from the book. (30 December 2022)

The Witchcraft Compiler Collection: A collection of compilation tools to perform binary black magic on the GNU/Linux and other POSIX platforms. (16 May 2020)

ThinBasic: Very fast "BASIC like" programming language useful to Beginners and to Gurus. BASIC interpreter for Windows able to create console and gui applications with most of the user interface controls, automate process, automate data exchange, connect to databases, send mails, connect to ftp sites, rest api, parsing strings, tokenizing, traversing xml, handling files, Windows Registry, OpenGl, graphics, sound, printing ... and much more. (24 May 2024)

Thinking Fast and Slow: System 1 and System 2 types of thinking and how to move from one to another. (06 April 2022)

Thinking in Bets: How to make decisions with less than perfect information. (26 April 2022)

Thinking in Systems: A primer on systems thinking. (02 June 2023)

Thinking Reading: A collection of links (usually to articles) about the various forms of thinking we do. (22 January 2024)

ThinScript: Low-level programming language inspired by TypeScript. (22 May 2024)

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. (27 July 2021)

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. (18 November 2020)

TikiTrackers: A full-featured, tightly integrated, Free / Libre / Open Source, multilingual (40+ languages), all-in-one Wiki+CMS+Groupware, written in PHP and actively developed by a very large international community. Major features include articles, forums, newsletters, blogs, file and image galleries, wiki, bug and issue trackers (form generator), calendar, RSS feeds, category system, tags, advanced permission system for users and groups, and more. (11 July 2021)

TimescaleDB: Database designed to process time series data. (06 April 2022)

Timid: A small programming language that made to be able to quickly solve problems like tedious math homework in as little time as possible (as in runtime). Also, it's possible to compile code once, and run anywhere using the Timid Runtime. (24 May 2024)

TiML: Functional Language for Practical Complexity Analysis with Invariants. (22 May 2024)

tin: Statically structurally typed JIT-compiled programming language, mainly for embedding in other programs. (22 May 2024)

Tina: Visual editor for React websites. (06 April 2022)

TinaCMS: A CMS with version control built-in (22 January 2024)

TingoDB: Embedded JavaScript MongoDB-compatible database for Node.js and node-webkit (01 July 2021)

Tink: Access a broad range of high-quality financial data from banks across Europe through a single API. So you can provide smart financial services – or engaging new customer experiences. (05 July 2021)

Tint: Tint is a string substition language; it is intended to be used as an extention language. Tint Emacs is an emacs clone for Win32, Mac OS X, Darwin, and Linux. It uses Tint as its extension language. (24 May 2024)

Tiny: A virtual console that offers an easy and efficient way to build games and other applications with its Lua programming support, hot reloading, and 256-color maximum. (12 October 2023)

Tiny Actor RunTime (tart): Tiny actor runtime. (06 April 2022)

Tiny Actor RunTime in Javascript (tartjs): JavaScript implementation of Tiny Actor Run-Time. (08 March 2024)

TinyBase: A JavaScript library for structured state. (06 April 2022)

TinyBasic: A family of dialects of the BASIC programming language that can fit into 4 or fewer KBs of memory. (30 May 2024)

TinyC: A considerably stripped down version of C and it is meant as a pedagogical tool for learning about compilers. (07 June 2021)

Tinymoe: For DSL (Domain Specific Language) building and embedding, with dynamic typing, multiple dispatching and build-in continuation. (24 May 2024)

TIS-100: An open-ended assembly language... game. Seriously. It's a game. (05 July 2022)

TIScript: A language that is a gentle extension of Javascript. (26 February 2023)

Titan: New programming language, designed to be a statically-typed, ahead-of-time compiled sister language to Lua. (22 May 2024)

Titan: A scalable graph database optimized for storing and querying graphs containing hundreds of billions of vertices and edges distributed across a multi-machine cluster. (07 June 2021)

Titanium Mobile: Develop cross-platform native mobile applications and build great mobile experiences using JavaScript. (11 May 2023)

Toit: Python-inspired language for ESP32 microcontrollers. (06 April 2022)

Tokamak: SwiftUI-compatible framework for building browser apps with WebAssembly and native apps for other platforms. (06 April 2022)

Tokay: Imperative, procedural programming language dedicated to parsing and other text-processing tasks. (24 May 2024)

Tone.js: A Web Audio framework for creating interactive music in the browser. (30 May 2021)

Tooljet: An open-source low-code framework to build & deploy internal tools with minimal engineering effort. (11 August 2021)

ToonTalk: ToonTalk is an interpreter for a concurrent constraint programming language. Concurrent constraint programming is a synthesis of concurrent logic programming and constraint logic programming. (See, for example, Saraswat). The class of languages for which programs are roughly interchangeable with ToonTalk programs include Oz, E-Lang, Janus, Flat Guarded Horn Clauses, KL1/KLIC, Flat Concurrent Prolog, Parlog, and Strand. The syntax of all these languages is textual while ToonTalk has an action-oriented video game animation syntax. The programming environment is completely different as well. In ToonTalk, the process of constructing, testing, and debugging programs closely resembles playing a video game. "From Prolog and Zelda to ToonTalk" is a paper discussing these ideas in detail. (24 May 2024)

TopazRuby: A high performance Ruby, written in RPython (20 December 2022)

TopShell: Purely functional, reactive scripting language. (22 May 2024)

Torgo: Logo Interpreter in Java. (13 July 2023)

TornadoVM: A practical and efficient heterogeneous programming framework for managed languages; an open-source software technology that automatically accelerates Java programs on multi-core CPUs, GPUs, and FPGAs. (05 February 2024)

To Sell Is Human: The Surprising Truth about Moving Others (06 April 2022)

TotalJS: A collection of server-side & client-side JavaScript/Node.js libraries, Web Components, icons, practices, and complete apps written in pure JavaScript, mostly without dependencies. (14 March 2023)

Tovie: An Advanced Programming Language (Compiler + Interpreter + Transpiler ). (01 November 2022)

Toy: An imperative bytecode-intermediate embedded scripting language, intended as a hosted scripting langauge engine. (12 July 2023)

Toy2: Refinement types + dependent types = ❤️. A Toy proof-of-concept implementation of a language with refinement types that compiles to Idris. (24 May 2024)

Toy3: The Toy programming language interpreter, written in C. (24 May 2024)

Tracer: Set of Dynamic Binary Instrumentation and visualization tools for execution traces. (01 July 2021)

Tracing (in software) reading: A collection of links and resources on tracing through programs in assistance of debugging. (06 April 2022)

Tree-Sitter: Tree-sitter generates parsers based on a language and provides insights about the code as seen by the engine. (30 May 2024)

Trino: Fast distributed SQL query engine for big data analytics that helps you explore your data universe. (30 December 2022)

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. (08 January 2023)

tRPC: Typescript-centric client/server RPC over HTTP. (13 January 2024)

Trygve: Building a DCI-centric language from the ground up. (03 May 2022)

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. (24 August 2021)

Tsuru: Open-source extensible Platform as a Service. (26 April 2022)

Tundra: A high-performance code build system designed to give the best possible incremental build times even for very large software projects. (01 July 2021)

Tunneling tools: A collection of network-tunneling tools. (04 January 2024)

Tup: A file-based build system. (01 July 2021)

Tuple (app): Remote pair programming app for macOS. (06 April 2022)

Tuple Space: An implementation of the associative memory paradigm for parallel/distributed computing. It provides a repository of tuples that can be accessed concurrently; they may be thought of as "distributed shared memory". (01 July 2021)

TurboSharp: A command-line IDE for C#. (01 February 2023)

Turbo Vision: Reimplementations of Borland's old Character User Interface framework. (11 May 2024)

Turin: A language built "for fun". (01 July 2021)

Turing: Imperative possibly object-oriented language and environment. (29 June 2023)

Turn the Ship Around!: "A true story of turning followers into leaders." Management principles from a submarine captain. (06 April 2022)

TUTOR (programming language): Designed for use in computer assisted instruction (CAI) and computer managed instruction (CMI). (06 May 2021)

Twilio: Commercial platform for various (human) communication (SMS, video, etc). (06 April 2022)

TwinBasic: TwinBasic: a modern, BASIC programming language, aiming for 100% backwards compatibility with existing VB6/VBA projects. A complete replacement development environment offering significant new features and improvements over the VB6 IDE. (24 May 2024)

Twine: A language/platform for creating interactive fiction. (21 November 2020)

Twitch: Commercial live streaming platform. (06 April 2022)

Twitter Open Source: Twitter's collection of OSS projects. (06 April 2022)

Tycho: A dynamically-typed language for the CLR designed for language-oriented programming. (24 August 2021)

tyk: Open source Enterprise API Gateway, supporting REST, GraphQL, TCP and gRPC protocols. (18 May 2022)

TypeDB: A database with a rich and logical type system. TypeDB empowers you to solve complex problems, using TypeQL as its query language. (02 August 2021)

Types and type systems (reading): Reading and notes about types and type systems in programming languages (and related). (30 May 2024)

TypeScript: A superset of JavaScript with strong compile-time typechecking that transpiles to clean JavaScript output. (22 May 2024)

Typhon: A virtual machine for the Monte programming language. (20 December 2022)

Typst: A new markup-based typesetting system that is powerful and easy to learn. (24 May 2024)

Tyr: Tyr is an experimental minimalistic language. It's meant to be both a programming language and a conlang. Programmers should think of it as a speakable programming language. Conlangers should see it as a logical conlang, which can also be used for programming. To achieve this, this language has clear and simple nesting rules based on the words, but no syntax for nesting. You can write sentences without the need of indentation. Any kind of indent is not even allowed. It's still in an early stage and only supports a few math primitives. Many things will probably be changed. I'll only document the current state here. (24 May 2024)

Tyrade: Pure functional language for type-level programming in Rust. (22 May 2024)

Tyro: TYRO is a very high level programming language designed mainly for the beginners of the programming, to develop a thorough understanding of the fundamental concepts of languages. (24 May 2024)

U: Experimental programming language that is compilable, statically-typed C++-like language. It is similar to C++ or Rust. Main goal is a safety, but not with cost of verbosity. [C++ killer, Rust killer] (24 May 2024)

Ubuntu Touch: A mobile version of the Ubuntu operating system for mobile devices. (03 October 2022)

UCI (Universal Chess Interface): An open communication protocol that enables chess engines to communicate with user interfaces. (24 February 2023)

UEFI (Unified Extensible Firmware Interface): A new model for the interface between personal-computer operating systems and platform firmware; the interface consists of data tables that contain platform-related information, plus boot and runtime service calls that are available to the operating system and its loader. Together, these provide a standard environment for booting an operating system and running pre-boot applications. (01 July 2021)

UI Bakery: Internal/enterprise web application builder. (11 July 2021)

UILang: A minimal, UI-focused programming language for web designers. (05 February 2024)

Ultimate Backend: Multi tenant SaaS starter kit with cqrs graphql microservice architecture, apollo federation, event source and authentication. (31 December 2022)

Umbraco: Open-source CMS running on top of .NET. (06 April 2022)

Umka: A statically typed embeddable scripting language. (24 May 2024)

Umlet: A free, open-source UML tool with a simple user interface: draw UML diagrams fast, build sequence and activity diagrams from plain text, export diagrams to eps, pdf, jpg, svg, and clipboard, share diagrams using Eclipse, and create new, custom UML elements. (26 February 2023)

Umple: A modeling tool and programming language family for Model-Oriented Programming. (04 May 2020)

Uncertainty: A C# library that uses LINQ to let developers easily express probabilistic computations and then inference over those computations. (10 May 2020)

Unicon: Unicon is a very high level programming language. It runs on many operating systems including most Linux distributions, Windows, macOS, and BSD systems. It also supports most modern CPU architectures such as i386, amd64, armhf, arm64, and ppc64el. (24 May 2024)

Unison: A modern, statically-typed purely functional language with the ability to describe entire distributed systems using a single program. (24 May 2024)

Unit: Unit is a General Purpose Visual Programming Language and Environment built with a primary focus on Developer Experience. It is heavily inspired by Live, Data Flow, Reactive, Functional and Object Oriented Programming paradigms. Formally, units are Multi Input Multi Output (MIMO) Finite State Machines (FSM). A program in Unit is represented as a Graph. (24 May 2024)

Universal Chiplet Interconnect Express (UCIe): A standard for connecting chiplets together, making it easier for companies to mix and match different chiplet components when building SoCs. (06 April 2022)

Universe: Visual website builder from mobile devices. (05 July 2021)

Unlambda: A language that 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. (30 May 2024)

Uno: The first and only UI Platform for single-codebase applications for Windows, WebAssembly, iOS, macOS, Android and Linux. (06 April 2022)

UnQLite: Embedded C-bindings document and key/value store. (30 May 2020)

Unqork: A no‑code application platform that helps organizations build enterprise‑grade software faster, avoid legacy code, reduce production issues, and lower total cost of ownership (06 April 2022)

Untools: Collection of thinking tools and frameworks to help you solve problems, make decisions and understand systems. (08 July 2023)

uom: A library to represent quantities and perform conversions between units of measurements with double or arbitray precision. (01 July 2021)

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. (24 May 2024)

Urbi: Component Software Platform (Urbi) & Concurrent Programming Language (urbiscript). (29 June 2023)

Urho3d: A free lightweight, cross-platform 2D and 3D game engine. (30 December 2022)

Ursina Engine: Makes it easier to develop games, visualizations and other kinds of software. (10 May 2022)

UseTheSource: An open-source projects collection. (10 May 2020)

UtahJS: Javascript conference in Utah. (02 June 2023)

V: Simple, fast, safe, compiled language for developing maintainable software. (24 May 2024)

V1: V1 is a simple functional interpreter language with syntax from C, PHP and JavaScript. It was developed from the scratch. The focus is on administrative and experimental programming, but it has enhanced benefits like Multithreading, CGI, Web functions and native function calling. The most buildin functions are compatible with PHP, for example fopen(). (24 May 2024)

V8: Bytecode virtual machine for Javascript. (06 April 2022)

Vaadin: A open source Java web app development platform for Java. With Vaadin, your UI code runs securely on the server, right next to your business logic that you can access with native Java API. Vaadin takes care of routing and server-client communication transparently, quickly, and securely, so you can focus on what matters - building a great app for your users. (06 April 2022)

Val: A programming language that leverages mutable value semantics and generic programming for high-level systems programming. (24 May 2024)

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. (24 May 2024)

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. (24 May 2024)

VALE (Verified Assembly for Everest): A tool for constructing formally verified high-performance assembly language code, with an emphasis on cryptographic code. (06 April 2022)

Valgrind: An instrumentation framework for building dynamic analysis tools. (01 July 2021)

ValLang: A Java library for typed immutable data: numbers, lists, sets, maps, relations, algebraic data-types. (06 April 2022)

Vanilla: A platform for community discussion. (06 April 2022)

VanillaJS (aka No Web Framework): Articles and links about using no Web framework at all. (06 April 2022)

VanillaOS: An Ubuntu-based distro that aims to provide a stock GNOME experience with on-demand immutability and the freedom to choose packages. (24 February 2023)

VanillaOS: An Ubuntu Linux-based Point Release distribution that receives updates at the right time, neither before nor after, without sacrificing security and functionality. (08 January 2023)

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). (06 April 2022)

Vavr: A functional library for Java. It helps to reduce the amount of code and to increase the robustness. A first step towards functional programming is to start thinking in immutable values. Vavr provides immutable collections and the necessary functions and control structures to operate on these values. (06 April 2022)

Vedis: An embeddable datastore C library built with over 70 commands similar in concept to Redis but without the networking layer since Vedis run in the same process of the host application. (27 July 2021)

VelocityDB: C# .NET NoSQL Object Database, extended as Graph Database is VelocityGraph. (01 July 2021)

VeloxDB: A fast, object-oriented, open source in-memory database for C# with an emphasis on correctness. (30 January 2023)

Verasco: A formally verified C static analyzer (01 July 2021)

Vercel.com: Static and JAMstack deployment workflow/infrastructure. (06 April 2022)

Verona: A research (not ready for non-reseearch use) programming language to explore the concept of concurrent ownership. We are providing a new concurrency model that seamlessly integrates ownership. (24 May 2024)

Verse: Statically typed, concise syntax, classes, templates, const correctness, semi-functional style. (24 May 2024)

Vert.x: Reactive applications on the JVM. (08 March 2024)

Verve: Functional language for the working hacker. (22 May 2024)

Victim: Victim is dynamically typed interpreted scripting language written in Haskell. The name is inspired by source code of [malloc](https://code.woboq.org/userspace/glibc/malloc/malloc.c.html#3038). (24 May 2024)

Vigil: Vigil, the eternal morally vigilant programming language (24 May 2024)

Vim: The vi tool, continuing to make its presence felt. (06 April 2022)

Vinci: A proof-of-concept compiler targeting SPIR-V for a toy ML functional shading language. (24 May 2024)

Vinegar: Vinegar is a semi-concatenative language where every operation can fail. (24 May 2024)

Virgil: Fast and lightweight native programming language designed for fast, dependency-free programs. (24 May 2024)

Visly (Figma): Build React components visually (11 July 2021)

Visual Basic (.NET): A largely-deprecated object-oriented programming language for the CLR. (06 April 2022)

Visual Python: GUI-based Python code generator for data science. (12 May 2022)

Visual Studio (and related) tools: Links and collections around the Visual Studio (including Visual C++) tool suite. (01 July 2021)

Visula: Visula is a general-purpose visual programming language (VPL) based on object-orientation. Visula programs are diagrams that are edited in a graphical editor. Programmers don't write software - they draw it! (24 May 2024)

Vitess: A scalable open-source database developed by Google to accommodate billions of YouTube users. (08 March 2024)

vizh: Esoteric visual language that takes image files as input based on a multi-tape turing machine, designed for compatibility with C. (22 May 2024)

vm86: A x86 script instruction virtual machine. (27 July 2021)

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. (27 July 2021)

Voiceliner: Hold record, say what you want, and release. Just like you'd expect from an outliner, create hierarchies and rearrange. Notes are auto-transcribed and searchable, but you can always play back the audio. Automatically attach location to notes. Remember walks you took, and which places sparked what ideas. (06 April 2022)

Volt: Systems level programming language written in D. (22 May 2024)

VoltDB: A data platform built to make your entire tech stack leaner, faster, and less expensive, so that your applications (and your company) can scale seamlessly to meet the ultra-low latency SLAs of 5G, IoT, edge computing, and whatever comes next. (01 January 2024)

Vonage (Developer): Integrate sms, voice, video and two-factor authentication into your apps with Vonage communication APIs. (29 September 2022)

Vortex: Vortex is a language designed to explore links and relationships between entities. It heavily relies on side effects, and as such it would fall under the Dysfunctional Programming paradigm. (24 May 2024)

Vox: Vox is a multiparadigm programming language inspired by D (60%), Jai (30%), and Zig (10%). Vox language compiler. AOT / JIT / Linker. Zero dependencies. (24 May 2024)

VoxxedDays: Smaller shows associated with the Devoxx conference series. (02 June 2023)

VSLive: 1105 Media's conference about Microsoft. (14 March 2023)

VSync: A new option for cloud computing that can enable reliable, secure replication of data even in the highly elastic first-tier of the cloud. (16 May 2020)

vtmc (Video Terminal Master of Ceremonies): A terminal-based presentation program. (20 March 2024)

Vue: Page-centric component-based framework for the browser. (06 April 2022)

Vultr: Deploy high performance cloud servers, cloud GPUs, bare metal, and cloud storage worldwide. (01 February 2023)

Vyne: A single API, which automatically connects your services, databases, lambdas and queues. (26 May 2022)

W: A tiny procedural C-inspired compiler, built around machine word-size values. (13 June 2021)

W3M: An open-source terminal web browser (and pager) available for any Unix-like OS. (26 April 2022)

Wa: Wa is a general-purpose programming language designed for developing robustness and maintainability WebAssembly software. Instead of requiring complex toolchains to set up, you can simply go install it - or run it in a browser. (24 May 2024)

Wa: Simple, maintainable, compiled language for developing WebAssembly software. (05 February 2024)

Waba (JVM): A small, efficient and reliable Java Virtual Machine (VM) aimed at portable devices (but also runnable on desktop computers), written by Rick Wild of Wabasoft. (06 April 2022)

WAMR (WebAssembly Micro-Runtime): a lightweight standalone WebAssembly (WASM) runtime with small footprint, high performance and highly configurable features. (17 December 2022)

Wappler: A leading producer of low code, visual productivity tools for creating rich data driven, highly interactive web sites and mobile apps. (11 July 2021)

Wargames: Games played to create simulations of real-world events/environments. (06 April 2022)

Wasabi2D: A game engine for Python, making it easy to use fast, modern graphical effects without low-level OpenGL programming. (10 May 2022)

Wase: WebAssembly made easy (11 May 2024)

wasmCloud: A distributed platform for writing portable business logic in Rust and compiled to WebAssembly. (06 April 2022)

Wasmer: An open-source runtime for executing WebAssembly on the Server. (11 May 2024)

WASM WinForms: C# Winforms for Webassembly. (06 April 2022)

Wasp: Web Application Specification Language. Extensible DSL (domain-specific language) for building modern web apps with less code. (22 May 2024)

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. (27 July 2021)

watc (Where's All The Code?): Displays a “usage” summary of a source tree oriented around line count. (22 December 2022)

Waterbear: Visual block syntax for programming languages. (05 February 2024)

wax: Tiny language that transpiles to C, Java and TypeScript. (24 May 2024)

Weaver: A scalable, fast, consistent graph store. (01 July 2021)

Web analytics: Tools/platforms/notes on gathering metrics about web pages. (06 April 2022)

WebAssembly: A portable multi-environment-targeting bytecode format for the Web. (25 February 2023)

WebAssembly for .NET: Create, read, modify, write and execute WebAssembly (WASM) files from .NET-based applications. (06 April 2022)

WebAssembly Virtual Machine: WebAssembly virtual machine designed for use in non-web applications. (30 July 2021)

WebC: A serializer that generates markup for web components. (25 February 2023)

Web Components: A set of web platform APIs that allow you to create new custom, reusable, encapsulated HTML tags to use in web pages and web apps. Custom components and widgets build on the Web Component standards, will work across modern browsers, and can be used with any JavaScript library or framework that works with HTML. (06 April 2022)

WebDAV: A open protocol for Distributed Authoring and Versioning over the Web (HTTP). (01 January 2023)

WebDSL: A DSL for building Web applications. (01 July 2021)

Webflow: Empowers designers to build professional, custom websites in a completely visual canvas with no code. (11 July 2021)

WebIDL: An interface description language (IDL) format for describing application programming interfaces (APIs) that are intended to be implemented in web browsers. (01 January 2023)

Webiny: Enterprise serverless CMS. (06 April 2022)

Webscript.io: Webscripts are short scripts, written in Lua, that run on our servers. They can respond to HTTP requests or run as cron jobs. (16 May 2020)

WebSharper: Robust, full-stack, client-server/single-page/HTML applications in C# and F#. (24 July 2021)

WebSockets: A computer communications protocol, providing full-duplex communication channels over a single TCP connection. (08 March 2024)

Web Storage: Mechanisms by which browsers can store key/value pairs, in a much more intuitive fashion than using cookies. (15 May 2020)

Web Worker API: A background browser task that can be created via script, which can send messages back to its creator. (06 April 2022)

Well: Well lang is somewhat functional kinda stack based language. This language includes your normal things like variables, mathamatics, loops, etc. It compiles directly to assembly (NASM). (24 May 2024)

wenyan: Esoteric programming language that closely follows the grammar and tone of classical Chinese literature. (22 May 2024)

What Is Strategy?: A summary of strategy (02 June 2021)

What Makes a Leader?: Most effective leaders are alike in one critical way: a high emotional intelligence quotient (EQ). (02 June 2021)

When: The Scientific Secrets of Perfect Timing (06 April 2022)

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. (01 July 2021)

Whiley: Programming Language with Extended Static Checking. (24 May 2024)

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. (01 November 2020)

Whip: Haskell-flavoured LISPish language thingy. (06 April 2022)

WhiteDB: A lightweight NoSQL database library written in C, operating fully in main memory. (07 June 2021)

Why Motivating People Doesn't Work (and What Does): The New Science of Leading, Energizing, and Engaging (06 April 2022)

Windows (OS): Development links and notes on the Microsoft Windows OS. (08 January 2023)

Windows (OS): The Microsoft operating system that has gone through several iterations since its humble beginnings as a standalone graphical user interface system on top of DOS. (08 January 2023)

Windows Debugging: Debugging the Windows operating system. (06 April 2022)

Wing: A cloud-oriented programming language that elevates the developer experience by combining infrastructure and runtime code, minimizing the complexity of the cloud. (13 June 2023)

Winstall/Winget: Windows package manager. (03 May 2022)

WinUI: A native user experience (UX) framework for both Windows desktop and UWP applications. (06 April 2022)

Wireit: Wireit upgrades your npm scripts to make them smarter and more efficient (such as execution in parallel, GitHub Action caching, etc). (10 May 2022)

Wizard: Research WebAssembly Engine. (05 February 2024)

wlang: Not entirely sure what this language wants to be when it grows up. (22 May 2024)

Wolfram Language: A "knowledge-based" programming language. (06 April 2022)

Wolverine: Next Generation .NET Mediator and Message Bus. (30 January 2023)

Workflow Core: A light weight workflow engine targeting .NET Standard. Think: long running processes with multiple tasks that need to track state. It supports pluggable persistence and concurrency providers to allow for multi-node clusters. (06 April 2022)

Working Backwards: An insider look at Amazon's internal practices and philosophies. (30 May 2021)

World Wide Web Consortium (W3C): An international community that develops open standards to ensure the long-term growth of the Web. (21 December 2022)

Wren: Think Smalltalk in a Lua-sized package with a dash of Erlang and wrapped up in a modern syntax. (24 May 2024)

Write your own Tiny Programming System: Online course teaching how fundamental programming language techniques, algorithms, and systems work by writing their miniature verisons. (24 November 2023)

Writing: Notes and links on writing. (13 June 2023)

Writing Tools: 50 Essential Strategies for Every Writer (06 April 2022)

Wu: An expression oriented, gradually typed and mission-critical programming language. (24 May 2024)

Wuffs: Memory-safe programming language (and a standard library written in that language) for wrangling untrusted file formats safely. (24 May 2024)

Wurfel Engine: 2.5D isometric game engine written in Java. (04 May 2020)

WWW-Architecture: Architecture thoughts about the Web itself (24 August 2021)

WyldCard: A clone of Apple's HyperCard and HyperTalk scripting language. (20 June 2021)

Wyvern: A new programming language designed from the ground up to support highly productive development of secure software systems. (24 May 2024)

X#: X# is an open source development language for .NET, based on the xBase language. It comes in different flavours, such as Core, Visual Objects, Vulcan.NET, xBase++, Harbour, Foxpro and more. X# has been built on top of Roslyn, the open source architecture behind the current Microsoft C# and Microsoft Visual Basic compilers. (24 May 2024)

X#: xBase-based language for the CLR. (10 May 2020)

X# (XSharp): A HLA (High Level Assembler) for X86/X64 (ARM coming) assembly language. (06 April 2022)

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. (24 May 2024)

X11 Tools: Cool X11-based tools. (06 April 2022)

x86/x64 Assembly: The native assembly language of the Intel x86 family. (25 February 2023)

x86 Talks: A collection of links of talks/videos on x86 assembly. (06 April 2022)

Xamarin: A cross-platform library for building applications on iOS, Android, etc, using the CLR-based tooling and platform. (06 April 2022)

Xata: Serverless database platform powered by PostgreSQL. (08 March 2024)

XCode (Development tool/platform): Apple's IDE and tools for development on iOS and macOS. (25 April 2022)

XCodebuild (XCode build system): XCode's build system. (01 July 2021)

XCode Instruments: XCode's tool(s) for measuring application performance. (29 April 2022)

XCode Playgrounds: The REPL-like environment for macOS and iOS in Apple's XCode. (11 April 2022)

XForms: Proposed standard for replacing HTML forms in a browser. (06 April 2022)

XIDEK: XIDEK provides technical guidance and source code so that you can readily design and implement an interpreter according to your own requirements. You may need, for example, to create a special interpreter for a domain specific language, script language, or other "little language". XIDEK can save you weeks or months of work. It gives you parsers, support modules, explanations, examples, organization and a framework upon which you can build. (24 May 2024)

XL: Extensible programming language designed to accomodate a variety of programming needs with ease. (24 May 2024)

xlang: A project from Microsoft enabling cross-language/platform API consumption (04 May 2020)

X Language: X Language is a new multi-syntax programming including a portable set of APIs to create console or graphical applications runnable on many platforms (UNIX/X11, Win32, ...). X Language comes with an interpreter, a compiler and a debugger. (24 May 2024)

xlisp: XLISP - an object-oriented LISP (24 May 2024)

XMage: Allows you to play Magic against one or more online players or computer opponents. It includes full rules enforcement for over 20 000 unique cards and more than 50.000 reprints from different editions. (30 December 2022)

XMake: A cross-platform build utility based on Lua. (01 July 2021)

XMLHttpRequest: Enables Web browsers to issue HTTP requests from within a page's lifecycle and consume the result. (30 May 2020)

Xojo: Build Native, Cross-Platform Apps. Rapid application development for Desktop, Web, Mobile & Raspberry Pi. (24 May 2024)

XOOM: DDD naked objects-like platform for low-code to full-code reactive, event-driven apps and microservices. (06 April 2022)

XPL: The XPL programming language is a derivative of PL/I designed for compiler writing. XPL was first announced at the 1968 FJCC in San Francisco, CA. XPL is the name of both the programming language and the compiler generator system (or TWS: translator writing system) based on the language. (24 May 2024)

XSB: XSB is a Logic Programming and Deductive Database system for Unix and Windows. (24 May 2024)

xState: A state management library for Javascript. (01 July 2021)

Xtend: A flexible and expressive dialect of Java, which compiles into readable Java 8 compatible source code. (24 May 2024)

Xtext: A framework for development of programming languages and domain-specific languages. (16 December 2022)

Xv6: A simple Unix-like teaching operating system. (06 April 2022)

Yaade: An open-source, self-hosted, collaborative API development environment. (06 April 2022)

Yab: Yab | yet another Basic for HAIKU. (24 May 2024)

YantraJS: JavaScript Engine for .NET (26 May 2022)

Yao: A low code engine to create web services and dashboard (06 April 2022)

Yarnspinner: A tool for creating interactive dialogue for games. (21 November 2020)

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. (24 August 2021)

YARV (Yet Another Ruby VM): The successor to the original Ruby VM (MRI). (20 December 2022)

YASL (Yet Another Scripting Language): A scripting language implementation. (01 August 2023)

Yasm Modular Assembler Project: A complete rewrite of the NASM assembler. (06 April 2022)

Yatta: Minimalistic, opiniated, (strongly) dynamically typed, strict, functional programming language, with ML-like syntax, for GraalVM. (22 May 2024)

Yeti: An ML-style functional language for the JVM. (17 December 2022)

Ylang: A universal dynamic tracing language that targets various dynamic tracing frameworks and toolchains. (06 April 2022)

Yo: A compiled programming language with strong static typing. (03 November 2022)

Yoix: A high-level, general-purpose, interpreted, dynamic programming language. (10 May 2020)

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. (24 May 2024)

Yuescript: Dynamic language that compiles to Lua. (24 May 2024)

YugaByteDB: An open-source Postgres database loaded with all Postgres native features in a cloud-native environment. (08 March 2024)

yUML: Create and share simple UML diagrams in your wikis, forums and issue trackers. (18 May 2022)

Z#: Z-Sharp is a custom programming language I made because I don't like c++ very much (Z-Sharp's interpreter is written in c++ though). Z-Sharp scripts have the file extension .ZS. The base syntax and formatting I would say is quite similar to C# or Python, but differs as task complexity increases. It also has support for graphics using SDL2. (24 May 2024)

Zang: Zang is a dynamically typed high level programming language. (24 May 2024)

Zenith: Sort of like top or htop but with zoom-able charts, CPU, GPU, network, and disk usage. (06 April 2022)

Zenon: Zenon is a statically typed language that compiles to C++. It offers safe and easy application development thanks to high-level features and fast compile times, while keeping C++'s performance and familiar syntax. (24 May 2024)

Zephir: Zephir - is a high level programming language that eases the creation and maintainability of extensions for PHP. Zephir extensions are exported to C code that can be compiled and optimized by major C compilers such as gcc/clang/vc++. Functionality is exposed to the PHP language. (24 May 2024)

ZeroC: Comprehensive RPC framework with support for C++, C#, Java, JavaScript, Python and more. (01 May 2021)

Zeta: Scripting language designed for efficiency, enabling dynamic extension and modification of high performance software. (22 May 2024)

Zetavm: Multi-Language Platform for Dynamic Programming Languages. (21 November 2020)

ZetScript: ZetScript is a programming language with an API that allows bind C++ code in script side. (24 May 2024)

Zhi# (ZhiSharp): An extension of C# with compiler and runtime support for XSD data types and Web Ontology Language (OWL). (24 August 2021)

Zig: Robust, optimal, and clear programming language. (24 May 2024)

Zilch: Statically-typed, low-level, functional programming language with some focus on runtime performance. (22 May 2024)

Zimbu: Language experiment around wide-scope system-to-application programming. (04 May 2020)

ZIO: Type-safe, composable asynchronous and concurrent programming for Scala (08 March 2024)

Zircon: An extensible, multiplatform and user-friendly tile engine. (04 May 2020)

Z-machine: A specification and numerous engines for Infocom interactive fiction. (01 July 2021)

Zoem: An interpretive macro/programming language. (06 April 2022)

ZOMBIE: A programming language designed for Necromancers, particularly evil ones. ZOMBIE is an acronym, and stands for Zombie-Oriented Machine-Being Interface Engine. (30 May 2024)

Zotonic: The open source, high speed, real-time web framework and content management system, built with Erlang. (06 April 2022)