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

.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)

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

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

8 Pillars of Greek Philosophy: 8 core greek philosophies. (26 April 2022)

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

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

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. (11 August 2021)

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)

Ada: The committee-designed language for government work. (26 May 2022)

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)

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)

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

Agda: A dependent types language. (06 April 2022)

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

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)

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

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

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

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

Alpaca: Functional programming inspired by ML for the Erlang VM. (04 May 2020)

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)

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

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

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: A statically typed curly brace language resembling C++ itself. (18 November 2020)

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

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

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

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

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

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

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)

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

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

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)

ArangoDB: Multi-model database (07 June 2021)

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

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

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)

Aria: Expressive, noiseless, interpreted, toy programming language. (01 November 2022)

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

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)

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)

Assemblers and Loaders: Written during 1985--1992, the book developed from class notes on computer organization. It includes numerous exercises with answers provided, and review questions following each chapter. The book is bound as a paperback with a colorful cover. (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)

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)

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

ATS: Statically typed programming language that unifies implementation with formal specification. It is equipped with a highly expressive type system rooted in the framework Applied Type System, which gives the language its name. (02 June 2021)

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)

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

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)

Awk: Tool for text processing and manipulation. (06 April 2022)

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)

Back4App: Parse backend hosting. (06 April 2022)

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

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

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

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

Baserow: Open source no-code database and Airtable alternative. (01 July 2021)

bash (command-line shell): Command-line shell and associated shell-scripting language. (06 April 2022)

Basic (and variants): Various notes and implementations of the BASIC programming language. (23 December 2022)

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

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

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)

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

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

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)

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

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)

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

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)

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)

Bitsy: the best language to implement when writing your first compiler or interpreter. (01 November 2022)

Blade: A simple, fast, clean, and dynamic language that allows you to develop applications quickly. (01 November 2022)

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

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)

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

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

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)

Bolt: A language with in-built data-race freedom! (31 May 2022)

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)

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)

Boron: An embeddable scripting language similar to Rebol. (18 November 2020)

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

Bosque: A language rethinking intermediate representation/bytecode to be more tool-friendly. (07 June 2021)

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)

Brain Rules: Rules for how the brain works. (26 April 2022)

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)

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

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)

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)

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-X: A collection of links on how to build various things as a learning exercise. (24 July 2021)

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

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)

C: A procedural language intended first as a replacement for assembly, later taking on a life of its own as a systems-level language. (06 April 2022)

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

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)

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)

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

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)

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

Canopy: A PEG parser compiler. (30 December 2022)

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)

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)

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)

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)

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

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

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)

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

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

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)

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

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

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

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

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)

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)

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)

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

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)

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)

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

CLIPS: A forward-chaining rule-based programming language written in C that also provides procedural and object-oriented programming facilities. (08 January 2023)

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)

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)

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)

CLR: A stack-based bytecode virtual machine. (06 April 2022)

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)

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)

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

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

COBOL: Legacy business language that refuses to die. (23 December 2022)

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)

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

CoffeeScript: Unfancy JavaScript. (06 April 2022)

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)

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 Language Runtime (CLR): The execution engine and supporting structure for .NET programs. (29 April 2022)

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. (17 December 2022)

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

Compilers Implementation/Optimization Reading: Collection of articles on implementing languages. (20 December 2022)

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)

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

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

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

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

Core J2EE Patterns: Patterns around enterprise Java circa 2000 (30 May 2021)

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: 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)

Couchbase: A full-featured, multi-service NoSQL database. (01 July 2021)

Couchbase Lite: Lightweight, embedded, syncable NoSQL database engine for variety of platforms. (01 January 2023)

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

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

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

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)

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

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" (16 December 2022)

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

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

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

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)

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

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)

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)

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

Cynefin: A framework for making decisions. (06 April 2022)

Cypher: A graph database query language first popularized by Neo4j. (01 July 2021)

D: a general-purpose programming language with static typing, systems-level access, and C-like syntax. (06 April 2022)

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)

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

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

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

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: A statically-typed performance-oriented scripting language. (18 November 2020)

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)

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

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 (19 December 2022)

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)

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)

Design Patterns (GOF): The "original" patterns book. (30 May 2021)

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

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). (30 December 2022)

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

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

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: (18 May 2022)

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

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

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

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)

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

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)

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

DoIt: It's Git for Data. (30 March 2021)

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

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

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

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)

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)

Dragonruby: A zero dependency, cross platform, Ruby runtime built on top of mRuby, libSDL, and LLVM. (06 April 2022)

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

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

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)

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)

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

DWScript: A statically typed Delphi/Free Pascal-like language. (18 November 2020)

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

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)

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

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

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)

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

ECMAScript (aka Javascript): A dynamic, object-oriented script language. (20 January 2023)

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)

Ecstasy (XTC): An object-ish language designed to be cloud native from the ground up. (01 July 2021)

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)

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

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)

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

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

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)

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

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

Elixir: A dynamic, functional language designed for building scalable and maintainable applications (26 April 2022)

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)

Elm: A functional language for reliable webapps. (30 May 2020)

Elmish: (Nothing yet) (05 July 2021)

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

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)

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

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

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

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

Erlang/OTP: An actors-based message-passing functional language running on BEAM. (06 April 2022)

Esoteric Programming Languages: Languages that are silly, ridiculous, or out to punish innocent programmers. (06 October 2022)

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

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

Essays on Programming: Random collection of long-form thoughts. (30 December 2022)

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

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

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

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)

Evolving Frameworks: A paattern language for evolving object-oriented frameworks. (30 May 2021)

exa: A modern replacement for "ls". (06 April 2022)

Excel LAMBDA: Define custom functions using Excel's formula language. (06 April 2022)

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

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. (09 December 2022)

F* (F-star): A general-purpose functional programming language with effects aimed at program verification. (01 July 2021)

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)

Factor: A concatenative, stack-based programming language with high-level features including dynamic types, extensible syntax, macros, and garbage collection. (01 July 2021)

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

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

Farmer: F-sharp bindings to Azure management APIs? (03 October 2022)

Farnam Street Blog: (No summary) (26 April 2022)

fasm (Flat Assembler): The Flat Assembler (06 April 2022)

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

Fay: A proper subset of Haskell that compiles to JavaScript. (01 July 2021)

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

Feral: Dynamically-typed, imperative, interpreted programming language revolving around minimalism. (03 November 2022)

Fetlang: Fetish-themed programming language. (15 November 2020)

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)

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

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)

FJ (Functional Java): Functional library for Java. (06 April 2022)

Fjord: F# for the JVM (01 November 2020)

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)

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. (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)

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)

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

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)

Flyway: Relational(ish) database evolution and migration tool. (04 May 2020)

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)

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)

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)

Forth: Entirely stack-oriented programming language. (06 April 2022)

FORTRAN (FORmula TRANslator): An older language focused on mathematics. (06 April 2022)

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)

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

FreePascal: A mature, versatile, open source Pascal compiler. (06 April 2022)

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: A functional language heavily Haskell-inspired for the JVM. (17 December 2022)

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

Froebel: A strictly typed utility library. (27 May 2022)

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)

fuite: A tool for finding memory leaks in web apps. (06 April 2022)

Fun: Programming language for the realtime web. (01 July 2021)

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

FunctionSimSearch: Example C++ code to demonstrate how to do SimHash-based similarity search over CFGs extracted from disassemblies (16 May 2020)

Futhark: A purely functional data-parallel programming language in the ML family. (19 June 2021)

Fuzzing (as part of testing): A collection of reading and links on "fuzzing" during testing. (19 May 2022)

FX: Command-line tool and terminal JSON viewer. (06 April 2022)

fzf: A command-line fuzzy (search) finder. (19 May 2022)

Gambas: A free development environment and a full powerful development platform based on a Basic interpreter with object extensions, as easy as Visual Basic. (06 April 2022)

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 Frame: Using games as strategy for success. (27 November 2020)

GameMonkeyScript: Similar to Lua, multithreaded. (18 November 2020)

Game Programming Patterns: Source repo for the book. (30 December 2022)

Gamification and Game Mechanics Made Simple: Notes on the book. (06 April 2022)

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)

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)

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: 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)

Giraffe: A functional ASP.NET Core micro web framework for building rich web applications. (06 April 2022)

Git: Distributed version-control system. (06 April 2022)

Github: Popular open-source cloud repository built around Git. (10 April 2022)

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)

Gleam: A statically typed functional programming language for building scalable concurrent systems. (10 May 2020)

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)

Glimesh: Live streaming platform. (06 April 2022)

Glinda: Combines live programming, GUIs, and a DSL for data science. (06 April 2022)

Glulx: An interpreter for interactive fiction games written in Inform7. (01 July 2021)

Gluon: Inspired by Lua, Haskell, and OCaml. Each executing gluon thread gets a separate heap. (18 November 2020)

Glush: A new parser compiler based on Glushkov’s construction algorithm. (30 December 2022)

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: Programming language from Google emphasizing coroutines. (03 October 2022)

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)

Goby: An object-oriented interpreter language deeply inspired by Ruby as well as its core implementation by 100% pure Go. (30 May 2020)

Godot Engine: A free and open source community-driven 2D and 3D game engine. (06 April 2022)

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: 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)

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: 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)

GraphDB(Lite): Fully Featured RDF Database for Massive Data and Moderate Query Loads. (07 June 2021)

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)

Gravity: A class-based concurrent scripting language with a Swift-like syntax; embeddable; no external dependencies; register-based virtual machine. (06 April 2022)

Greenfoot: Visual and interactive programming tutorial tool built on top of Java. (06 April 2022)

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)

GUILE: The GNU Ubiquitous Intelligent Language for Extensions. (06 April 2022)

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)

h: A simple, fast, open-source, complete, (satirical) and safe language for developing modern software for the web. (06 April 2022)

Hack: An object-oriented application language influenced by PHP. (04 May 2020)

Haiku: The open-source flag-bearer for the now-defunct Be operating system. (31 December 2022)

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)

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 2021)

Haskell: Pure-functional language. (06 April 2022)

Haste: an implementation of the Haskell functional programming language, geared towards web applications; compiler generates JavaScript code from Haskell. (06 April 2022)

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: A modern, high-level, strictly-typed programming language (06 April 2022)

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

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)

Hecl: Mobile scripting language for the JVM. (30 November 2022)

Helios: An extensible open-source mobile backend framework with particular integration with iOS Core Data. (31 December 2022)

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)

Heroku: Cloud host, owned by Salesforce, offering developer-friendly cloud deployment. (16 May 2020)

Heron: A pure functional type-inferred language based on JavaScript. (30 July 2021)

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)

Hexagons in Game Development: A collection of links around using hex-based maps in games. (06 April 2022)

Hexagony: A two-dimensional, hexagonal programming language. (01 November 2022)

Hexo: Javascript-based static site generator (01 July 2021)

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)

HLA (High Level Assembler): A higher-level assembler for a variety of different targets. By Randall Hyde. (06 April 2022)

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)

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

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)

How to Design Programs: (06 April 2022)

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)

Humanizer: All your .NET needs for manipulating and displaying strings, enums, dates, times, timespans, numbers and quantities. (01 January 2023)

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)

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

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)

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)

Hyperscript: A scripting language designed for modern front-end web development, inspired by Hypercard, and Hypertalk. (20 June 2021)

HyperSQL: Relational database written in Java. (06 May 2021)

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

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

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)

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)

ImGui: Bloat-free GUI for C++ with minimal dependencies. (12 May 2022)

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

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

InfiniteGraph: Advanced Graph Database and Analytics for Enterprises and Government. (06 April 2022)

Influence: The Psychology of Persuasion. (03 May 2022)

InfluxDB: Platform for building time series applications. (06 April 2022)

Inform6: A natural-language interactive fiction game development language and platform. (10 May 2022)

Inform7: A natural-language interactive fiction game development language and platform. (10 May 2022)

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

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

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

Internal: Web application builder optimized/intended for internal enterprise use. (05 July 2021)

Interviewing: Collection of links and ideas around tech intervews. (31 December 2022)

Inweb: Literate programming language used for Inform7 development. (29 April 2022)

Io: Inspired by Self, Smalltalk and LISP. (21 November 2020)

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)

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)

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

J (programming language): A high-level, general-purpose programming language that is particularly suited to the mathematical, statistical, and logical analysis of data. (02 June 2021)

JAMStack: Javascript, APIs, and Markdown presentation layer (06 April 2022)

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

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)

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)

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

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

Java Concurrency in Practice: Goetz's seminal work on how concurrency works and operates on the JVM. (03 May 2022)

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)

Java Platform Specifications: A collection of the various specifications (JavaEE, etc) that make up the Java platform (06 April 2022)

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)

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)

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)

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)

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)

Jinx: Designed for use in realtime applications such as video games. (18 November 2020)

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)

JLex: A Lexical Analyzer Generator for Java. (16 May 2020)

jMonkeyEngine: A modern developer friendly game engine written primarily in Java. (06 April 2022)

JMPLib: (01 January 2023)

Job search links and articles: A collection of links and articles about the candidate side of the recruiting process. (10 April 2022)

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

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)

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)

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)

js-queue: An ES6 stack which allows for Last In First Out (LIFO) queuing. (06 April 2022)

Julia: A flexible dynamic language, appropriate for scientific and numerical computing, with performance comparable to traditional statically-typed languages. (11 April 2022)

June: What ordinary Java would look like if it were simpler. (27 July 2021)

Jurassic: A .NET library to parse and execute JavaScript code. (06 April 2022)

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

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)

Jython: Python implementation on the JVM. (20 December 2022)

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)

kalk.dev: A powerful command-line calculator application for developers. (06 April 2022)

Katahdin: A programming language where the syntax and semantics are mutable at runtime. (27 July 2021)

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)

Ki: A Lisp for your JavaScript (24 August 2021)

Kind: A modern proof language. (06 April 2022)

Kinto: A generic JSON document store with sharing and synchronisation capabilities. (06 April 2022)

Kitten: A statically typed concatenative systems programming language. (21 November 2020)

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)

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

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)

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)

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)

langcc: (18 December 2022)

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. (21 December 2022)

Languages reading: A collection of links and articles on different programming languages. (08 January 2023)

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)

LDPL: A free, powerful, compiled, open-source programming language designed from the ground up to be excessively expressive, readable, fast and easy to learn. (06 April 2022)

Leading Change: How to not fail at digital transformation efforts. (02 June 2021)

Lean: A functional programming language that makes it easy to write correct and maintainable code. (06 April 2022)

Learn X in Y Minutes: Website collection of numerous "Learn You" style tutorials. (06 April 2022)

Lemon: An LALR(1) parser generator maintained as part of the SQLite project. (06 April 2022)

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. (16 December 2022)

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)

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. (31 March 2021)

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)

LibObjectFile: A .NET library to read, manipulate, and write linker and executable object files (ELF, DWARF, ar). (01 July 2021)

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)

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)

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

linq2db: LINQ to database provider. (06 April 2022)

Linux (OS): The original open-source operating system. (08 January 2023)

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

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 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)

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)

LLJVM (Low Level Java Virtual Machine): A set of tools and libraries for running comparatively low level languages (such as C) on the JVM. (27 July 2021)

LLVM: A compiler and back-end native compilation/linking toolchain. (05 July 2022)

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)

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

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

LokiJS: Super fast in-memory javascript document oriented database. (06 April 2022)

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

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

Lowdefy: An open-source low-code framework to build web apps, admin panels, BI dashboards, workflows, and CRUD apps with ease. (07 June 2021)

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)

Lua: Scripting language often embedded into game engines for extensibility. (06 April 2022)

Lua VM: Implementation docs and notes for the Lua virtual machine. (06 April 2022)

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)

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: 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)

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. (22 December 2022)

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

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

macOS (OS) Virtual Machine Notes: Running the Apple desktop operating system (on top of the open-source Darwin kernel) in a virtual machine. (30 March 2021)

macOS Open Source: A collection of macOS-related OSS links (06 April 2022)

macOS Setup: macOS Setup tools and scripts. (06 April 2022)

Magic-trace: High-resolution traces of what a process is doing (26 April 2022)

Magpie: A toy language interpreter, written in Go. It has C-style syntax, and is largely inspired by Ruby, Python, Perl and c#. (18 November 2020)

MailChimp: Email/marketing platform. (16 May 2020)

Make: A build tool with some dependency-based tracking available. (06 April 2022)

Malbolge: A programming language designed to be difficult (or impossible) to program in. (06 April 2022)

MAME: A multi-purpose "vintage" software emulation framework. (01 July 2021)

Management frameworks: A collection of leadership/management frameworks/scaffolding, for thinking about how to frame steps and thinking. (20 January 2023)

Management reading: Collection of thoughts/essays/etc on managing people. (20 January 2023)

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)

Mantra: (Might be a TParr class assignment?) (02 August 2021)

Marco: Safe, Expressive Macros for Any Language (30 May 2021)

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)

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)

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)

Maxine-VM: A meta-circular research VM; a next generation, highly productive platform for virtual machine research.. (01 May 2021)

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)

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)

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)

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

Mermaid: Generation of diagram and flowchart from text in a similar manner as markdown. (06 April 2022)

Meson: (01 July 2021)

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)

Metadata-Connect: A massively scalable metadata (data about the data) management platform hosted in the cloud. (06 April 2022)

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)

MicroPython: Implements the Python 3.4 syntax and some of the core datatypes. (18 November 2020)

Microservices: Reading on microservices architecture. (05 July 2022)

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: A Prototype-based language with syntax inspired by Io and Ruby, topped with Python's indentation (but only when you want to). (06 April 2022)

MingW32: Win32 port of GCC and other utilities for running on the Win32 platform. (06 April 2022)

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)

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)

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

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. (30 December 2022)

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)

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)

ML: A strictly-functional language that later inspired OCaML and others. (06 April 2022)

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)

Modern Compiler Implementation: This book covers compiler theory, design, and implementation. (19 December 2022)

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

Mond: A scripting language for .NET Core. (15 November 2020)

MongoDB: Document-oriented network storage. (18 May 2022)

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

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

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)

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

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

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 December 2022)

Mun: A programming language empowering creation through iteration. (21 November 2020)

Mux: An API that enables developers to build unique live and on-demand video experiences. (06 April 2022)

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)

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)

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)

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. (11 August 2021)

Neko (VM): The NekoVM is a target for several compilers, including Haxe. (20 December 2022)

Nelua: Minimal, simple, efficient, statically typed, compiled, meta programmable, safe and extensible systems programming language with a Lua flavor. (21 November 2020)

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

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)

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

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)

Never: A statically typed functional programming language. (18 November 2020)

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

Nim: A compiled, garbage-collected systems programming language with a design that focuses on efficiency, expressiveness, and elegance (in that order of priority). (09 December 2022)

Ninja: A small build system with a focus on speed. (01 July 2021)

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/NixOS/nixpkgs: A tool that takes a unique approach to package management and system configuration. (06 April 2022)

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

NocoDB: The Open Source Airtable alternative. (07 June 2021)

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

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

No One Understands You: and What To Do About It (06 April 2022)

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)

Noulith: Browser-based visual programming language and platform for sound synthesis. (14 December 2022)

NRefactory: Currently unmaintained parser/compiler frontend for C#. (01 July 2021)

Nu: An interpreted Lisp that builds on the Objective-C runtime and Foundation framework. (01 July 2021)

Nuklear: A single-header ANSI C immediate mode cross-platform GUI library. (21 February 2021)

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)

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)

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

Object-capability model: A capability describes a transferable right to perform one (or more) operations on a given object. (06 April 2022)

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-S: Objective-S is the first general purpose programming language. It makes creating well-architected and efficient programs not only straightforward, but easy, fun and fast. (30 March 2021)

Objectivity/DB: A scalable, high performance, distributed Object Database (ODBMS). (06 April 2022)

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

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)

Octokit: A GitHub API client library with various bindings. (01 July 2021)

OData: OASIS standard for data over HTTP-based communication. (01 January 2023)

Odin: Designed with the intent of creating an alternative to C around simplicity, high performance, built for modern systems, and joy of programming. (21 November 2020)

OhMyForm: Create stunning embedable forms for recruiting, market research, surveys and more; open source alternative to TypeForm, TellForm, or Google Forms. (11 August 2021)

Oilpan: A mark-sweep tracing GC library hosted by the V8 ECMAScript engine for C++ applications. (06 April 2022)

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

OmniSharp: A family of open-source projects for .NET. (06 April 2022)

OMR: Reliable components for building language runtimes. (04 May 2020)

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)

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

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: 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)

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 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 Linux Games: A collection of Linux open-source games; capturing them here for play and research purposes. (06 April 2022)

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)

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: A Modular Application Framework for Blazor (.NET WebAssembly). (06 April 2022)

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)

Orchard Framework: Open-source, modular, multi-tenant application framework and CMS for ASP.NET Core. (06 April 2022)

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)

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)

Owin: Open Web Interface for .NET. (06 April 2022)

Owncloud: A personal cloud which runs on your own server. (06 April 2022)

Oxide: An interpreted scripting language with a Rust influenced syntax. (01 November 2022)

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

P: A statically-compiled research language from Microsoft around explicit state machine management. (04 May 2020)

P#: A statically-compiled research language from Microsoft around explicit state machine management. (01 November 2020)

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)

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

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 December 2022)

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. (19 December 2022)

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

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

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)

Payload: Free and Open-source Headless CMS and Application Framework built with TypeScript, Node.js, React and MongoDB. (05 July 2022)

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)

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)

Performance tools and research: A collection of links around performance tools (06 April 2022)

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)

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

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. (06 May 2021)

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)

Piet: A language where the programs are works of modern art. (06 April 2022)

Pikachu: (06 October 2022)

Pin: A Dynamic Binary Instrumentation Tool. (01 July 2021)

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)

PingCAP: NewSQL database that supports HTAP workloads. (06 April 2022)

Pipedream: Workflow automation and API integration platform. (06 April 2022)

Pipelines: An experimental programming language for data flow. (15 November 2020)

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: 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)

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)

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)

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

Pogo, Pogoscript: Little language that emphasizes readability, DSLs, and asynchronous primitives. (03 October 2022)

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: Extensible compiler front end framework for language implementation on the JVM. (04 May 2020)

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: A statically-compiled research language from Microsoft around actors and concurrency. (10 May 2020)

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

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

PouchDB: Open-source JavaScript database inspired by CouchDB. (01 July 2021)

PowerFX: Low-code language (13 May 2021)

PowerShell: A proposed replacement for shell languages like bash. (30 May 2020)

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. (09 December 2022)

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)

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)

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

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

Program analysis: A collection of links around program analysis (06 April 2022)

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. (16 December 2022)

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)

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

Prompto: Platform and differing-syntax languages for cloud development. (10 May 2020)

Prose: A simple language inspired by Io and Ioke that compiles to Clojure and ClojureScript. (30 March 2021)

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

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)

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. (06 May 2021)

PureScript: A strongly-typed language that transpiles to JavaScript. (06 April 2022)

PursuedPyBear: (10 May 2022)

PuzzleScript: A language/environment for creating turn-based, keyboard-controlled games where you're moving a thing, or several things around. (18 November 2020)

PyAutoGui: Lets Python scripts control the mouse and keyboard to automate interactions with other applications. (24 August 2021)

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)

Python: A dynamic language and platform. (01 January 2023)

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)

Q (Scripting Language): Q is a scripting engine that implements C-like language, compiler, and bytecode interpreter. (24 August 2021)

QBDI (QuarkslaB Dynamic binary Instrumentation): A Dynamic Binary Instrumentation framework based on LLVM. (01 July 2021)

Qiew: Hex/File format viewer. (16 May 2020)

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)

QuestDB: Database designed to process time series data. (06 April 2022)

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)

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)

Racket: Racket language/platform is a Lisp, but has numerous language implementations built on it. (24 August 2021)

Railo: An open-source CFML server. (18 November 2020)

Raku: Perl-themed object and functional language. (04 May 2020)

RapidAPI: World’s largest API marketplace. (01 July 2021)

RascalMPL: An experimental domain specific language for metaprogramming, such as static code analysis, program transformation, program generation and implementation of domain specific languages. (24 July 2021)

Ratchet: Build mobile apps with simple HTML‚ CSS‚ and JS components. (25 April 2022)

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)

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 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)

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

Reading in Artificial Intelligence: A collection of language-agnostic links on AI and Machine Learning. (08 January 2023)

Reading in mathematics: A collection of notes, articles, and free books on maths. (30 December 2022)

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)

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)

ReasonML: A syntax over OCaml that is easier to get started for programmers who are familiar with C-style syntax like JavaScript. (06 April 2022)

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

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)

Redux: State management for React. (06 April 2022)

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)

Relate: Website builder (11 July 2021)

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

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)

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)

Replicant: A mobile operating system focusing more on older devices. (03 October 2022)

Representational State Transfer (REST): Collection of links and reading and notes on Fielding's dissertation. (06 April 2022)

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. (19 December 2022)

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)

Rexx: A structured, high-level programming language designed for ease of learning and reading. (18 November 2020)

Rhai: An embedded scripting language for Rust inspired by ChaiScript. (18 November 2020)

Riak: Highly available, operationally simple, distributed database. (06 April 2022)

Rich CLI: A command line toolbox for fancy output in the terminal. (06 April 2022)

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

Rintagi: Open-source low-code development platform for mission-critical applications. (07 June 2021)

RISC-V Assembly: Assembly language for the RISC-V architecture. (06 April 2022)

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)

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)

RocketMQ: A unified messaging engine, lightweight data processing platform. (06 April 2022)

Rockstar: A dynamically typed computer programming language, designed for creating programs that are also song lyrics. (15 November 2020)

ROFLKODE: An imperative, block structured, statically-typed programming language that is very similar to Adam Lindsay's language LOLCODE. (06 October 2022)

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)

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)

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)

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

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)

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)

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)

Scapy: Python-based interactive packet manipulation program & library. (10 May 2022)

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)

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

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

Self: An object-oriented programming language based on the concept of prototypes. (03 November 2022)

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

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)

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? (06 October 2022)

ShapeCrawler: A .NET library for manipulating PowerPoint presentations. (01 January 2023)

sharedb: Realtime database backend based on Operational Transformation (OT). (31 December 2022)

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)

Ship It!: A collection of ideas for how to get software shipped. (06 April 2022)

Shoelace: A forward-thinking library of web components. (06 April 2022)

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

Silos, Politics, and Turf Wars: How to eliminate silos in organizations. (31 December 2020)

Silq: A high-level quantum language. (01 July 2021)

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

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)

Singularity: From-scratch re-imagination of an operating system from Microsoft Research. (06 April 2022)

SiteJS: (No summary) (30 March 2021)

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)

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)

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)

Small Basic: A stripped-down/"lean" version of Basic for learning programming. (06 April 2022)

Smalltalk: The original object-oriented programming language, emphasizing multiple inheritance and message-passing. (01 January 2023)

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

SOA Design Patterns: A collection of patterns specific to service-orientation. (07 June 2021)

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 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)

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)

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)

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: A documentation tool written in Python (used to make Python website docs). (03 May 2022)

Spider: A programming language that compiles to JavaScript (ES5 and ES6 targets). (24 August 2021)

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)

Spry: A Smalltalk and Rebol inspired language implemented as an AST interpreter in Nim. (01 November 2022)

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)

SQLite: A C-language library that implements a small, fast, self-contained, high-reliability, full-featured, SQL database engine. (18 December 2022)

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)

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

SSCLI Essentials: by Stutz, Shilling, Pobar and myself on the Shared Source CLI, the predecessor to the .NET Core CLR. (30 July 2021)

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

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

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)

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)

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)

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)

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

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)

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)

Sugar: A language to make JavaScript programming sweeter. (01 July 2021)

Sulu: Modern Symfony based CMS. (06 April 2022)

Supabase: Backend server with REST APIs to manage core backend needs. (06 April 2022)

Superblocks: A programmable IDE for developers to build any internal app, workflow, or scheduled job. (03 October 2022)

Surprising Science of Meetings: Notes from the book. (22 December 2022)

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)

Switch: How to Change Things When Change Is Hard (06 April 2022)

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 December 2022)

Systems Thinking: Collection of notes links, articles, blog posts and other resources on systems thinking. (06 April 2022)

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: Langauge for high-performance, sparse & differentiable graphics computing. (06 April 2022)

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)

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

Tcl/Java: Implementation of Tcl on the JVM. (30 November 2022)

Tcl (Tool Control Language): A high-level scripting language vaguely object-like. (06 April 2022)

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)

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)

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

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

TextBundle: A file format for bundling text (Markdown) and binary (images, etc) in one file. (24 August 2021)

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 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. (05 July 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 Essence of Compiling with Continuations: A paper on compilation using continuations as a key element. (16 December 2022)

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. (09 December 2022)

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 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)

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

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)

Tina: Visual editor for React websites. (06 April 2022)

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)

Tiny Actor RunTime (tart): Tiny actor runtime. (06 April 2022)

Tiny Actor RunTime in Javascript (tartjs): JavaScript implementation of Tiny Actor Run-Time. (06 April 2022)

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

TinyC: A considerably stripped down version of C and it is meant as a pedagogical tool for learning about compilers. (07 June 2021)

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

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

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)

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)

TopazRuby: A high performance Ruby, written in RPython (20 December 2022)

To Sell Is Human: The Surprising Truth about Moving Others (06 April 2022)

Tovie: An Advanced Programming Language (Compiler + Interpreter + Transpiler ). (01 November 2022)

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)

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)

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)

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)

Turbo Vision: Reimplementations of Borland's old Character User Interface framework. (18 May 2022)

Turin: A language built "for fun". (01 July 2021)

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)

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). (17 December 2022)

TypeScript: A superset of JavaScript with strong compile-time typechecking that transpiles to clean JavaScript output. (17 January 2023)

Typhon: A virtual machine for the Monte programming language. (20 December 2022)

Ubuntu Touch: A mobile version of the Ubuntu operating system for mobile devices. (03 October 2022)

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)

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

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)

Unison: A modern, statically-typed purely functional language with the ability to describe entire distributed systems using a single program. (03 January 2023)

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 programming language. Nothing remarkable there. The originality of Unlambda is that it stands as the unexpected intersection of two marginal families of languages: functional programming languages (like Scheme) and obfuscated programming languages (like Intercal). Unlambda uses a functional approach to programming: the only form of objects it manipulates are functions. Each function takes a function as argument and returns a function. (06 April 2022)

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)

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

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)

V: Simple, fast, safe, compiled language for developing maintainable software. (26 May 2022)

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)

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 August 2021)

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

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 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)

Verasco: A formally verified C static analyzer (01 July 2021)

Vercel.com: Static and JAMstack deployment workflow/infrastructure. (06 April 2022)

Vim: The vi tool, continuing to make its presence felt. (06 April 2022)

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)

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)

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

Vonage (Developer): Integrate sms, voice, video and two-factor authentication into your apps with Vonage communication APIs. (29 September 2022)

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)

Vue: Page-centric component-based framework for the browser. (06 April 2022)

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)

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)

wasmCloud: A distributed platform for writing portable business logic in Rust and compiled to WebAssembly. (06 April 2022)

WASM WinForms: C# Winforms for Webassembly. (06 April 2022)

Wasp: A programming language that understands what a web app is. (05 July 2022)

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)

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

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)

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

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)

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: 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)

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)

Wolfram Language: A "knowledge-based" programming language. (06 April 2022)

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

Writing Tools: 50 Essential Strategies for Every Writer (06 April 2022)

Wu: An expression oriented, gradually typed and mission-critical programming language. (21 November 2020)

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

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

X11 Tools: Cool X11-based tools. (06 April 2022)

x86/x64 Assembly: The native assembly language of the Intel x86 family. (06 April 2022)

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)

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)

xlang: A project from Microsoft enabling cross-language/platform API consumption (04 May 2020)

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)

XOOM: DDD naked objects-like platform for low-code to full-code reactive, event-driven apps and microservices. (06 April 2022)

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

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)

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): (06 October 2022)

Yasm Modular Assembler Project: A complete rewrite of the NASM assembler. (06 April 2022)

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 August 2021)

yUML: Create and share simple UML diagrams in your wikis, forums and issue trackers. (18 May 2022)

Zenith: Sort of like top or htop but with zoom-able charts, CPU, GPU, network, and disk usage. (06 April 2022)

ZeroC: Comprehensive RPC framework with support for C++, C#, Java, JavaScript, Python and more. (01 May 2021)

Zetavm: Multi-Language Platform for Dynamic Programming Languages. (21 November 2020)

Zhi# (ZhiSharp): An extension of C# with compiler and runtime support for XSD data types and Web Ontology Language (OWL). (24 August 2021)

Zig: Another C replacement nominee, that aims to have "no hidden functions". (06 April 2022)

Zimbu: Language experiment around wide-scope system-to-application programming. (04 May 2020)

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

Zotonic: The open source, high speed, real-time web framework and content management system, built with Erlang. (06 April 2022)