Uncategorized

• Uncategorized

  • Peridot - An experimental language for exploring the applications of two level type theory to high-performance functional programming
  • Peter - Gemtree Peter is a visual programming tool designed for a simple and fast generation of the programs for Windows 95/98/NT/ME/2000/XP/Vista. Its principal characteristic is the graphical presentation of the program structure. The program sections are assembled using the mouse like a jigsaw puzzle. Thanks to the justification check of the element combinations, carried out already at the time of the program generation, there is no chance of syntactic failure origination. The program presentation by means of a tree structure enables a considerable improvement of the program lucidity. The creation of the program is quickly becoming extraordinary easy and flexible.
  • Pharo - Pharo is a pure object-oriented programming language and a powerful environment, focused on simplicity and immediate feedback (think IDE and OS rolled into one).
  • Phix - Phix is a self-hosted hybrid interpreter/compiler, developed by Pete Lomax. It is very easy to use, and similar to Euphoria.
  • Pico - Pico is a tiny but expressive programming language that was especially designed to teach advance computer science concepts to students in other sciences than computer science (such as Physics and Chemistry). In a sense, Pico can be seen as a non-trivial marriage between the power of languages like Scheme, and, the standard infix notation students are used to from ordinary calculus. A.o., Pico features garbage collected tables (i.e. arrays), higher order functions, objects, meta programming and reflection. But above all, Pico is small! Really small!
  • PicoLisp - PicoLisp is a programming language, a dialect of the language Lisp. Its most prominent features are simplicity and minimalism. It is built on one internal data type: a cell. On the language level, a programmer can use three different data types (numbers, symbols, and lists) being represented by cells and differentiated by bits at the end of the cell.
  • Pihta - a compiled programming language whose purpose is to give the programmer complete control over the environment of his work.
  • Pikt - Pikt is a pixel-based, Turing complete esoteric programming language that generates fast and lightweight programs out of aesthetically pleasant image sources. Indeed, Pikt's most interesting feature is flexibility: every keyword, statement, function, operator and so on is linked to one - or more - color, which can be easily customized via color schemes.
  • Pinafore - Pinafore is a language that allows you to structure information and create user interfaces for it. Currently it's at the "proof of concept" stage. You can build it from source and run it.
  • Pinecone - Pinecone is a brand new, easy to learn, general purpose, multi-paradigm, high performance programming language created by Sophie Winter. Work on the language began on October 4th, 2016. Pinecone can now be interpreted or transpiled to C++. The language is written from scratch (it includes an integrated lexer, parser and interpreter, etc.).
  • Plato - Plato is an efficient and (hopefully!) fun programming language inspired by JavaScript, TypeScript, C#, and Haskell. Plato is designed to be easy to teach and learn while being efficient and robust enough for professional coding, particularly in the realm of 3D graphics. Plato is a statically typed functional language that looks and behaves in many ways like an object-oriented scripting language, but with a lot less complexity.
  • Plutus - Plutus Core is the scripting language embedded in the Cardano ledger and forms the basis of the Plutus Platform, an application development platform for developing distributed applications using the Cardano blockchain.
  • Pocketlang - A lightweight, fast embeddable scripting language. Pocketlang is a small (~3000 semicolons) and fast functional language written in C. It's syntactically similar to Ruby and it can be learned within 15 minutes. Including the compiler, bytecode VM and runtime, it's a standalone executable with zero external dependencies just as it's self descriptive name. The pocketlang VM can be embedded in another hosting program very easily.
  • Polyglot - Experiment with PHP+C polyglot snippets and a transpiler written in OCaml.
  • Pony - Pony is a compiled, actor-model, capabilities-secure, high performance programming language that prevents concurrency mistakes such as data races and deadlocks by design with reasonable syntactic defaults. Its FFI allows Pony to interface with other languages.
  • Power Fx - Microsoft Power Fx is a low-code general purpose programming language based on spreadsheet-like formulas. It is a strongly typed, declarative, and functional language, with imperative logic and state management available as needed.
  • POWER-KI - POWER-KI allows HYBRID PROGRAMMING, i.e. the development of applications with components created with different languages in a single package, making the most of each of them. In fact from POWER-KI it is possible to directly execute PyThon code, C / C ++ code using WRAP and javascript in the Web User Interface. In this way, for example, it is possible to create applications based on Python code that take advantage of the POWER-KI Native Cloud for the user interface or create C / C ++ functions for maximum performance.
  • Preql - Preql is an interpreted, relational programming language, that specializes in database queries and compiles to SQL.
  • Priml - Priml is a stack-oriented scripting language based on Forth and BASIC.
  • Prolog
  • Prowl - The Prowl Language is a statically-typed stack-based programming language that draws from a wide range of inspirations, mainly functional, logic, and stack-based languages. However, the language is unique with its powerful program combinator system. Prowl exploits a homomorphism between string concatenation and concatenative languages that allows regex to be used as a computational and mental model for control flow. This model provides a rigid framework to solve combinatory and constraint problems (in addition to general purpose programming) yet retains performant translations into DFAs due to the regex base. With stacks for data and regex for control flow, Prowl provides a unique but ergonomic way to think about hard problems.
  • Pure - Pure is a modern-style functional programming language based on term rewriting. It offers equational definitions with pattern matching, full symbolic rewriting capabilities, dynamic typing, eager and lazy evaluation, lexical closures, built-in list and matrix support and an easy-to-use C interface.
  • Pure - A pure type system implemented in OCaml.
  • PureScript - A strongly-typed functional programming language that compiles to JavaScript
  • Pycopy - Pycopy - a minimalist and memory-efficient Python dialect. Good for desktop, cloud, constrained systems, microcontrollers, and just everything.
  • Pyret - Pyret is a programming language designed to serve as an outstanding choice for programming education while exploring the confluence of scripting and functional programming. It's under active design and development, and free to use or modify.
  • Pyretic - Python + Frenetic = Pyretic. Pyretic is one member of the Frenetic family of SDN programming languages. As such Pyretic enables network programmers and operators to write succinct modular network applications by providing powerful abstractions. Pyretic is both a programmer-friendly domain-specific language embedded in Python and the runtime system that implements programs written in the Pyretic language on network switches.
  • Qi - Lightweight and fast programming language designed to be written in Chinese.
  • Qogo - This application was developed to teach 5 to 10 year olds the principles of programming via the venerable "Turtle Graphics" paradigm. It is written in TCL so it runs on all computer platforms.
  • Quil - A Portable Quantum Instruction Language.
  • Quirrel - Quirrel - Gaijin Entertainment dynamic script language (former Squirrel).
  • Quorum - Quorum is a general purpose programming language designed for several purposes. First, we regularly run experiments with people at various age and experience ranges, investigating ways to make the language easier to use. Evidence gathered from these studies is filtered back into the design, making quorum an "evidence-based" programming language. Second, as our team is interested in issues of equity for all people, perhaps especially people with disabilities, we are careful to design libraries that are friendly to the broad population. This means many internal libraries in the language have support for accessibility.
  • R3 - R3 is a Colorforth like laneguage, a FORTH dialect, R3 is a 64 bits, very small dictionary and simple working, strong typed, many version for windows/linux/mac and raspberry pi.
  • R4 - R4 is a Colorforth like laneguage, a FORTH dialect, R4 is 32bits, very small dictionary and simple working, strong typed, many version for windows/linux/mac and raspberry pi.
  • Racket - A general-purpose, multi-paradigm programming language and a multi-platform distribution that includes the Racket language, compiler, large standard library, IDE, development tools, and a set of additional languages including Typed Racket (a sister language of Racket with a static type-checker), Swindle, FrTime, Lazy Racket, R5RS & R6RS Scheme, Scribble, Datalog, Racklog, Algol 60 and several teaching languages.
  • Radish - Radish is an easy-to-learn, object-oriented programming language written in C#. If you know JavaScript, you know Radish.
  • Ragel - Ragel compiles executable finite state machines from regular languages. Ragel targets C, C++ and ASM. Ragel state machines can not only recognize byte sequences as regular expression machines do, but can also execute code at arbitrary points in the recognition of a regular language. Code embedding is done using inline operators that do not disrupt the regular language syntax.
  • Raku - A member of the Perl family of programming languages. Formerly known as Perl 6, it was renamed in October 2019. Raku introduces elements of many modern and historical languages. Compatibility with Perl was not a goal, though a compatibility mode is part of the specification.
  • RapidBATCH - A general-purpose scripting language platform for automation.
  • RascalMpl - Rascal Metaprogramming Language. Rascal is a programming language; such that meta programs can be created by, understood by, and debugged by programmers. Rascal primitives include immutable data, context-free grammars and algebraic data-types, relations, relational calculus operators, advanced patterns matching, generic type-safe traversal, comprehensions, concrete syntax for objects, lexically scoped backtracking, and string templates for code generation. It has libraries for integrating language front-ends, for reusing analysis algorithms, for getting typed meta-data out of version management systems, for interactive visualization, etc.
  • Rave - Rave is a statically typed, compiled, procedural, general-purpose programming language.
  • Ravi - Ravi is a dialect of Lua with limited optional static typing and features a JIT compiler powered by MIR as well as support for AOT compilation to native code.
  • Reason - Simple, fast & type safe code that leverages the JavaScript & OCaml ecosystems.
  • Red - Red is a next-generation programming language strongly inspired by Rebol, but with a broader field of usage thanks to its native-code compiler, from system programming to high-level scripting and cross-platform reactive GUI, while providing modern support for concurrency, all in a zero-install, zero-config, single 1MB file!
  • Req - A simple and opinionated HTTP scripting language. It is designed for easily making HTTP requests, and working with their responses. Below is an example that calls out to the GitHub API and displays the user making the call.
  • Restructor - Restructor is a system / algorithm to automatically refactor entire code-bases down to their least-redundant form (normal form). It’s a research project I worked on 2005-2010.
  • Retro - RETRO is a clean, elegant, and pragmatic dialect of Forth. It provides a simple alternative for those willing to make a break from legacy systems.
  • Rhai - Rhai - An embedded scripting language for Rust.
  • Rhovas - Rhovas is a programming language for API design and enforcement. Using Rhovas, developers can better express the contracts and intention of their code to help create correct, maintainable software.
  • Ribbon - Ribbon is a dynamic interpreted programming language. It's inspired by the likes of Python, Javascript and a little bit of Lua.
  • Rickroll lang - A light meme based, process oriented, dynamic, strong, esoteric programming language. All of the keywords/statements are came from Rick Astley's lyrics. I believe that rick roll is not only a way to promote people's communication, it is also one of the most paramount art in the human history. The purpose of the Rickroll Language is to introduce this art to people in a distinctive way - programming.
  • Ring - Simple and flexible programming language for applications development. Ring is a practical general-purpose multi-paradigm language. The supported programming paradigms are Imperative, Procedural, Object-Oriented, Functional, Metaprogramming, Declarative programming using nested structures, and Natural programming. The language is portable (MS-DOS, Windows, Linux, macOS, Android, WebAssembly, etc.) and can be used to create Console, GUI, Web, Games, and Mobile applications. The language is designed to be Simple, Small, and Flexible.
  • Rio - A script-feeling, safe, naturally compatible replacement for C, with no runtime nor std lib of its own.
  • Rivet - A general-purpose programming language, focused on simplicity, safety and stability.
  • Roc - Roc is a language for making delightful software.
  • Rock - Little language made with Rust and LLVM. Aim to follow the enforced safeness of the Rust model with a borrow checker (SoonT) and achieve high native performances thanks to LLVM. Rock is highly inspired from Livescript and Rust, and will also borrow (pun intended) some features from Crystal, from functional languages like Haskell, and even from Rust itself.
  • Roman II - Roman II is a dynamic programming language with a naive mark and sweep garbage collector, all written from the ground up in about 5000 lines of the GNU11 dialect of C.
  • Rowlang - RowLang is a minimalistic esoteric programming language written as an analogy to rowing.
  • rpn - rpn - Reverse Polish Notation CLI calculator. A math functional language using reverse (postfix) polish notation
  • Rune - The Rune Language, an embeddable dynamic programming language for Rust.
  • RustScript - RustScript is a functional scripting language with as much relation to Rust as Javascript has to Java.
  • SATySFi - SATySFi (pronounced in the same way as the verb “satisfy” in English) is a new typesetting system equipped with a statically-typed, functional programming language. It consists mainly of two “layers” ― the text layer and the program layer. The former is for writing documents in LaTeX-like syntax. The latter, which has OCaml-like syntax, is for defining functions and commands. SATySFi enables you to write documents markuped with flexible commands of your own making. In addition, its informative type error reporting will be a good help to your writing.
  • Seed7 - Seed7 is a higher level language compared to Ada, C++ and Java.
  • Senegal - Senegal is a powerful, small-but-fast, concurrent, class-based, and dynamically-typed programming language with a modern syntax.
  • Shiika - Shiika is a statically-typed programming language that makes me most productive.
  • Silice - A language for hardcoding algorithms into FPGA hardware
  • Silq - Silq is a new high-level programming language for quantum computing with a strong static type system
  • ShockScript - An ActionScript 3/ECMAScript-4-like language to be used initially in the [Whack engine](https://github.com/whackengine), featuring easy XML data processing and reactive user interfaces (`whack.ds.*`). Its parser is private, and its type checker and codegen have not been done yet. ShockScript's specification contains many details, though the semantic descriptions are not finished yet.
  • SISC - SISC is an extensible Java based interpreter of the algorithmic language Scheme. SISC uses modern interpretation techniques, and handily outperforms all existing JVM interpreters (often by more than an order of magnitude).
  • Slang - Statically typed scripting language... syntax errors should be catched at design time!
  • SMAL - The machine independant SMAL assembler and linker supports conditional and macro assembly and all linkage editing operations commonly associated with languages such as FORTRAN and C. It comes with a user's manual that also explains how to customize it to support a variety of machine instruction sets.
  • SmallBASIC - SmallBASIC is a fast and easy to learn BASIC language interpreter ideal for everyday calculations, scripts and prototypes. SmallBASIC includes trigonometric, matrices and algebra functions, a built in IDE, a powerful string library, system, sound, and graphic commands along with structured programming syntax.
  • Solidity - Solidity is an object-oriented programming language for implementing smart contracts on various blockchain platforms, most notably, Ethereum.
  • Soul - Soul is an esoteric concatenative one-stack language, a small explorative language with an interpreter written in a day. Most concatenative languages work on a state, often that's another stack. For example, Forth has a data and return stack and Postscript has an extra stack outputting to a page. Soul is a minimalist language that provides one thing, and one thing only, the one sole stack.
  • SOUL - The SOUL language is a small, carefully crafted DSL for writing real-time DSP code. Its design goals are to be fast, secure, safe, and simple for even beginners to learn. The SOUL runtime is a collection of tools and technologies for running SOUL code with very high efficiency, on heterogeneous CPUs and DSPs, both locally and remotely.
  • sparcl - Sparcl: A Language for Partially-Invertible Computation. This is an implementation of a system presented in the paper: Kazutaka Matsuda and Meng Wang: Sparcl: A Language for Partially-Invertible Computation, ICFP 2020.
  • SPARK - SPARK stands for the Scanning, Parsing, and Rewriting Kit. It formerly had no name, and was referred to as the "little language framework." The first version (circa 1998) was described in the paper Little Languages in Python at the 7th International Python Conference.
  • Sphinx - Sphinx is a dynamically typed programming language that is inspired by Lua and Python, and implemented entirely in Rust!
  • Spiral - Functional language with intensional polymorphism and first-class staging.
  • SpécialK - SpécialK, an anaesthetizing algorithmic language. The SpécialK language is a logical and functionnal language similar to Erlang, and used in 2nd year of CS at the university of Nice in algorithmics course of E.Kounalis. SpécialK is a SpécialK to Scheme compiler.
  • Squilu - A scripting language that accepts a subset of javascript and C/C++.
  • Squirrel - Squirrel is a high level imperative, object-oriented programming language, designed to be a light-weight scripting language that fits in the size, memory bandwidth, and real-time requirements of applications like video games.
  • Stab - A multi-paradigm programming language designed for the Java Virtual Machine
  • Stacksmith - An intuitive software erector kit targeted at people new to programming, but with enough potential to stay useful once they've learned, inspired by HyperCard.
  • Stan - Stan is a state-of-the-art platform for statistical modeling and high-performance statistical computation. Many thousands of users rely on Stan for statistical modeling, data analysis, and prediction in the social, biological, and physical sciences, engineering, and business.
  • Star - An experimental programming language that's made to be powerful, productive, and predictable. One of the most important goals of Star is that it's designed to be completely consistent. In other words, Star has been designed to not have edge cases, footguns, or any sort of "magic" that's exclusive to language built-ins.
  • Stark - Stark is a new language and OS with the help of the .NET ecosystem and seL4 micro-kernel.
  • Starlark - Starlark (formerly known as Skylark) is a language intended for use as a configuration language. It was designed for the [Bazel](https://bazel.build/) build system, but may be useful for other projects as well.
  • Strand - "Strand" is an open-source implementation of the identically named parallel Prolog dialect as described in the book "Strand: New Concepts for Parallel Programming" by Ian Foster and Stephen Taylor. Strand represents a very elegant and concise notation for expressing concurrent and distributed algorithms using only a small number of fundamental language constructs and a very simple execution model.
  • Streem - Streem is a stream based concurrent scripting language. It is based on a programming model similar to the shell, with influences from Ruby, Erlang, and other functional programming languages.
  • Stroscot - Stroscot is an imperative programming language designed for modern processors.
  • TableM - A relational language.
  • Taichi - Productive & portable high-performance programming in Python. Taichi Lang is an open-source, imperative, parallel programming language for high-performance numerical computation. It is embedded in Python and uses just-in-time (JIT) compiler frameworks, for example LLVM, to offload the compute-intensive Python code to the native GPU or CPU instructions.
  • Tamgu(탐구) - A FIL Language that combines in one language an imperative paradigm, a functional paradigm and a logical paradigm. Mixes in one code _A Python-like formalism, a Haskell-like formalism and a Prolog-like formalism_.
  • Tamsin - Tamsin is an oddball little language that can't decide if it's a meta-language, a programming language, or a rubbish lister. Its primary goal is to allow the rapid development of parsers, static analyzers, interpreters, and compilers, and to allow them to be expressed compactly. Golf your grammar! (Or write it like a decent human being, if you must.)
  • Tandem - Tandem is an experimental rewriting language where the rewrite rules form a Kleene algebra. The object being rewritten by a Tandem program is a collection of labelled stacks -- a finite mapping from strings to strings. The strings are always rewritten at the left edge, so they are effectively stacks. A Tandem program consists of a single rewrite rule along with zero or more pragmas. The rewrite rule is applied to an initial state to possibly obtain a final state. This rule is applied only once. However, in Tandem, a rule is a composite object which may contain subrules that get applied many times.
  • Tao - A statically-typed functional language with polymorphism, typeclasses, sum types, pattern-matching, first-class functions, currying, good diagnostics, and much more!
  • Tao3D - Tao3D is a dynamic document description language designed specifically for real-time 3D animations. It can be used to present complex information in an entertaining and interactive way.
  • Teal - Teal is a simplified language for teaching program analysis concepts.
  • Terra - Terra is a low-level system programming language that is embedded in and meta-programmed by the Lua programming language
  • Timid - A small programming language that made to be able to quickly solve problems like tedious math homework in as little time as possible (as in runtime). Also, it's possible to compile code once, and run anywhere using the Timid Runtime.
  • Tinymoe - English-like programming language, for DSL (Domain Specific Language) building and embedding, with dynamic typing, multiple dispatching and build-in continuation.
  • Toka - Toka is a concatenative programming language related to Forth. It should be easy to learn, extend, and use. Development is ongoing, and updates occur almost daily.
  • Tokay - Tokay is a programming language to quickly implement solutions for text processing problems. This can either be just simple data extractions, but also parsing entire structures or parts of it, and turning information into structured parse trees or abstract syntax trees for further processing. Therefore, Tokay is both a tool and language for simple one-liners, but can also be used to implement code-analyzers, refactoring tools, interpreters, compilers or transpilers. Actually Tokay's own language parser is implemented in Tokay itself.
  • ToonTalk - ToonTalk is an interpreter for a concurrent constraint programming language. Concurrent constraint programming is a synthesis of concurrent logic programming and constraint logic programming. (See, for example, Saraswat). The class of languages for which programs are roughly interchangeable with ToonTalk programs include Oz, E-Lang, Janus, Flat Guarded Horn Clauses, KL1/KLIC, Flat Concurrent Prolog, Parlog, and Strand. The syntax of all these languages is textual while ToonTalk has an action-oriented video game animation syntax. The programming environment is completely different as well. In ToonTalk, the process of constructing, testing, and debugging programs closely resembles playing a video game. "From Prolog and Zelda to ToonTalk" is a paper discussing these ideas in detail.
  • Toy - The Toy programming language interpreter, written in C.
  • Typst - A new markup-based typesetting system that is powerful and easy to learn.
  • Tyr - Tyr is an experimental minimalistic language. It's meant to be both a programming language and a conlang. Programmers should think of it as a speakable programming language. Conlangers should see it as a logical conlang, which can also be used for programming. To achieve this, this language has clear and simple nesting rules based on the words, but no syntax for nesting. You can write sentences without the need of indentation. Any kind of indent is not even allowed. It's still in an early stage and only supports a few math primitives. Many things will probably be changed. I'll only document the current state here.
  • uiua - Uiua (wee-wuh ) is a general purpose, stack-based, array-oriented programming language with a focus on simplicity, beauty, and tacit code. Uiua lets you write code that is as short as possible while remaining
  • Umka - Umka is a statically typed embeddable scripting language. It combines the simplicity and flexibility needed for scripting with a compile-time protection against type errors. Its aim is to follow the Python Zen principle Explicit is better than implicit more consistently than dynamically typed languages generally do.
  • Unicon - Unicon is a very high level programming language. It runs on many operating systems including most Linux distributions, Windows, macOS, and BSD systems. It also supports most modern CPU architectures such as i386, amd64, armhf, arm64, and ppc64el.
  • Unison - Unison is a modern, statically-typed purely functional language, similar to Haskell, but with the ability to describe entire distributed systems with a single program.
  • Unit - Unit is a General Purpose Visual Programming Language and Environment built with a primary focus on Developer Experience. It is heavily inspired by Live, Data Flow, Reactive, Functional and Object Oriented Programming paradigms. Formally, units are Multi Input Multi Output (MIMO) Finite State Machines (FSM). A program in Unit is represented as a Graph.
  • Ur - Ur is a programming language in the tradition of ML and Haskell, but featuring a significantly richer type system. Ur is functional, pure, statically typed, and strict. Ur supports a powerful kind of metaprogramming based on row types.
  • Ü - Experimental programming language that is compilable, statically-typed C++-like language. It is similar to C++ or Rust. Main goal is a safety, but not with cost of verbosity. [C++ killer, Rust killer]
  • V - Simple, fast, safe, compiled language for developing maintainable software. Compiles itself in <1s with zero library dependencies.
  • V1 - V1 is a simple functional interpreter language with syntax from C, PHP and JavaScript. It was developed from the scratch. The focus is on administrative and experimental programming, but it has enhanced benefits like Multithreading, CGI, Web functions and native function calling. The most buildin functions are compatible with PHP, for example fopen().
  • Vale - Vale is the fast, safe, and easy programming language. It uses single ownership with constraint references for memory safety without garbage collection, and an emphasis on modern, readable syntax.
  • Verona - Project Verona is a research programming language to explore the concept of concurrent ownership. We are providing a new concurrency model that seamlessly integrates ownership.
  • Victim - Victim is dynamically typed interpreted scripting language written in Haskell. The name is inspired by source code of [malloc](https://code.woboq.org/userspace/glibc/malloc/malloc.c.html#3038).
  • Vigil - Vigil, the eternal morally vigilant programming language
  • Vinci - A proof-of-concept compiler targeting SPIR-V for a toy ML functional shading language.
  • Vinegar - Vinegar is a semi-concatenative language where every operation can fail.
  • Virgil - A Fast and Lightweight Programming Language. Its design blends functional and object-oriented programming paradigms for expressiveness without a lot of overhead, either syntactically or at runtime. Its implementation is focused primarily on static compilation to produce native executables that are standalone. It is well-suited to writing small and fast programs. That makes it ideal for building certain kinds of programs like compilers and virtual machines. It is currently being used for virtual machine and programming language research.
  • Vortex - Vortex is a language designed to explore links and relationships between entities. It heavily relies on side effects, and as such it would fall under the Dysfunctional Programming paradigm.
  • Vortex - Vortex is a language-independent optimizing compiler infrastructure for object-oriented and other high-level languages, written entirely in Cecil. It primarily operates as a whole-program optimizer, performing aggressive analyses and optimizations given the whole program. It has front-ends for Cecil, Diesel, Smalltalk, Java, C++, and Modula-3. These front-ends translate into the Vortex RTL intermediate language. Vortex produces either portable C++ code or SPARC assembly code.
  • Vox - Vox is a multiparadigm programming language inspired by D (60%), Jai (30%), and Zig (10%). Vox language compiler. AOT / JIT / Linker. Zero dependencies.
  • Wa - Wa is a general-purpose programming language designed for developing robustness and maintainability WebAssembly software. Instead of requiring complex toolchains to set up, you can simply go install it - or run it in a browser.
  • Wasp - Wasp (Web Application Specification) is a Rails-like framework for React, Node.js, and Prisma. Build your app in a day and deploy it with a single CLI command!
  • Wax - A tiny programming language that transpiles to C, C++, Java, TypeScript, Python, C#, Swift, Lua and WebAssembly 🚀.
  • Well - Well lang is somewhat functional kinda stack based language. This language includes your normal things like variables, mathamatics, loops, etc. It compiles directly to assembly (NASM).
  • Wenyan - 文言文編程語言 A programming language for the ancient Chinese.
  • Whiley - Whiley employs state-of-the-art techniques for ensuring your software is correct. You can specify functions using preconditions and postconditions, and then statically verify your implementation meets its specification.
  • Wing - Winglang is a new open-source programming language designed for the cloud (aka "cloud-oriented"). Wing enables developers to build distributed systems that leverage cloud services as first-class citizens by combining infrastructure and application code in a safe and unified programming model (aka "cloud-oriented"). Wing programs can be executed locally (yes, no internet required) using a fully-functional simulator, or deployed to any cloud provider (yes, Wing programs are portable across providers).
  • WisniaLang - A compiler for an experimental programming language that produces tiny Linux binaries (ELF x86_64) without LLVM dependency!
  • Wisp - Wisp turns indentation into lisp expressions.
  • Wren - Wren is a small, fast, class-based concurrent scripting language.
  • Wu - An expression oriented, gradually typed and mission-critical programming language.
  • Wuffs - Wuffs (Wrangling Untrusted File Formats Safely) is a memory-safe programming language (and a standard library written in that language) for wrangling untrusted file formats safely. Wrangling includes parsing, decoding and encoding. Example file formats include images, audio, video, fonts and compressed archives.
  • Wyvern - Wyvern is a new general-purpose programming language designed to support adaptation and assurance. Key features of Wyvern's evolving design include:
  • X# - X# is an open source development language for .NET, based on the xBase language. It comes in different flavours, such as Core, Visual Objects, Vulcan.NET, xBase++, Harbour, Foxpro and more. X# has been built on top of Roslyn, the open source architecture behind the current Microsoft C# and Microsoft Visual Basic compilers.
  • X10 - X10 is a statically-typed object-oriented language, extending a sequential core language with places, activities, clocks, (distributed, multi-dimensional) arrays and struct types. All these changes are motivated by the desire to use the new language for high-end, high-performance, high-productivity computing.
  • XIDEK - XIDEK provides technical guidance and source code so that you can readily design and implement an interpreter according to your own requirements. You may need, for example, to create a special interpreter for a domain specific language, script language, or other "little language". XIDEK can save you weeks or months of work. It gives you parsers, support modules, explanations, examples, organization and a framework upon which you can build.
  • xlisp - XLISP - an object-oriented LISP
  • XPL - The XPL programming language is a derivative of PL/I designed for compiler writing. XPL was first announced at the 1968 FJCC in San Francisco, CA. XPL is the name of both the programming language and the compiler generator system (or TWS: translator writing system) based on the language.
  • xpl - eXample Programming Language. C-like language syntax; arithmetic and conditional expressions; dynamically typed; 3 data-types: integer, float, string; simple control structures (conditionals, iterations); 6 build-in functions
  • Xylo - Xylo is a functional programming language for procedural art. It is written in Rust with no_std support, so it can be used to generate art almost anywhere.
  • Yab - Yab | yet another Basic for HAIKU.
  • Yeti - Yeti is ML style functional programming language, that runs on the JVM.
  • Yuji - tiny scripting language in C
  • Z# - Z-Sharp is a custom programming language I made because I don't like c++ very much (Z-Sharp's interpreter is written in c++ though). Z-Sharp scripts have the file extension .ZS. The base syntax and formatting I would say is quite similar to C# or Python, but differs as task complexity increases. It also has support for graphics using SDL2.
  • Zang - Zang is a dynamically typed high level programming language.
  • Zenon - Zenon is a statically typed language that compiles to C++. It offers safe and easy application development thanks to high-level features and fast compile times, while keeping C++'s performance and familiar syntax.
  • Zephir - Zephir - is a high level programming language that eases the creation and maintainability of extensions for PHP. Zephir extensions are exported to C code that can be compiled and optimized by major C compilers such as gcc/clang/vc++. Functionality is exposed to the PHP language.
  • zeptoforth - zeptoforth is a Cortex-M Forth, currently targeted at RP2040 boards such as the Raspberry Pi Pico, the Raspberry Pi Pico W, the Arduino Nano RP2040 Connect, the Cytron Maker Nano RP2040, the SeeedStudio XIAO RP2040, and the WIO RP2040 (which it has been tested with) using 25Q Quad SPI flash compatible with the Winbond Quad SPI flash on the Raspberry Pi Pico, RP2350 boards such as the Raspberry Pi Pico 2 and the Pimoroni Pico Plus 2, the STM32L476, STM32F407, and STM32F746 DISCOVERY boards, and the STM32F411 "Black Pill" board. Ports to more platforms are on hold due to the current chip shortage (aside from a possible port to an STM32H7 board I have lying around somewhere). A hack exists for getting zeptoforth to work properly on STM32F411 Nucleo 64 boards using the binaries compiled for STM32F411 "Black Pill" boards.
  • Zig - General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.
  • Zngr L Compiler - Zngr L Compiler is the first Compiler for the theoretical language L , in the world , which used in the computation theory that teaches in the computer science departments in any faculty of since , as a basic language for computations .
  • Awesome Basic - A curated list of awesome BASIC dialects, IDEs, and tutorials.
  • Awesome Lisp languages - A list of Lisp-flavored programming languages.
  • Lua languages - Languages that compile to Lua.
  • Awesome Scheme - A curated list of awesome Scheme libraries and resources.
  • Awesome low level programming languages
  • PL catalog - A catalog of programming languages.
  • Programming languages - Awesome Programming Languages.
  • Langs written in Rust - A list of programming languages implemented in Rust, for inspiration. This is a (probably incomplete) list of languages implemented in Rust. It is intended as a source of inspiration and comparison, and as a directory of potentially interesting projects in this vein.
  • Programming Language Database - PLDB: a Programming Language Database. A computable encyclopedia about programming languages.
  • History of Programming Languages - HOPL: Online Historical Encyclopaedia of Programming Languages.
  • ISLISP - The ISLISP programming language is a member of the Lisp family of programming languages. It attempts to bridge the gap between the various incompatible members of the Lisp family of languages (most notably Common Lisp, Eulisp, LeLisp, and Scheme) by focusing on standardizing those areas of widespread agreement. It is a small language, closer to the size of Scheme than to Common Lisp, for example.
  • BAIK - BAIK is a scripting language which syntax is in Indonesian for Windows and Linux on Server, Desktop, Laptop and Embedded Computer, including IoT. It supports GPIO, Animation, PDF, UTF8, Printer, OOP, GUI, CGI, Databases, Graphics and TCP/IP.
  • Enchilada - Enchilada is optimized to efficiently and consistently share huge amounts of data (and code) in a distributed environment. Possible use cases:
  • Forest - Forest is a domain-specific language for describing filestores.
  • friend - 1)Compiler/interpreter for a simple OO language. The language allows to use networking very easily, including such protocols as TCP, UDP, Raw Sockets 2) Library for reading/manipulating Java bytecode
  • Gofolio - the programming language for the ATARI portfolio
  • gura - A programming language that comes with powerful operation on iterators.
  • Herschel - Herschel is an general-purpose multiparadigm programming language. It is strongly typed, offering type inference and parametric polymorphism ("generics"). It is consequently object oriented (everything is a object, even functions), while its consequent multiple dispatch approach keeps a strong functional touch. The object model is class-oriented, supporting multiple inheritance as well as the separation of types ("protocols", "interfaces") and classes.
  • HicEst - Integrated development environment with graphical user interface designed for immediate results in the development of Windows applications.
  • IBAL - IBAL is a functional language for specifying probabilistic models. Models in IBAL look like programs in a functional programming language. In the functional approach, a model is a description of a computational process. The process stochastically generates a value, and the meaning of the model is the distribution over the value generated by the process.
  • IENJINIA - IPL is the IENJINIA Programming Language used in the IENJINIA Devkit to write games for the IENJINIA Virtual Console. It is a very simple interpreted language with dynamic typing, static scoping and automatic garbage collection.
  • Incanter - Incanter is a Clojure-based, R-like platform for statistical computing and graphics.
  • Janino - Janino is a super-small, super-fast Java compiler. Janino can not only compile a set of source files to a set of class files like JAVAC, but also compile a Java expression, a block, a class body, one .java file or a set of .java files in memory, load the bytecode and execute it directly in the running JVM.
  • Kal - Kal is a highly readable, easy-to-use language that compiles to JavaScript. It's designed to be asynchronous and can run both on node.js and in the browser. Kal makes asynchronous programming easy and clean by allowing functions to pause and wait for I/O, replacing an awkward callback syntax with a clean, simple syntax.
  • kalimat - Kalimat is an educational programming language for Arabic-speaking children. It aims for readability and an easy to understand syntax while providing enough features to allow for complex, interesting and fun programs.
  • Key - a dynamic language that allowed both class abstraction and object description.
  • Kite - Kite is a programming language designed to minimize as much of the programmer experience as possible — quick development and running time and low CPU and memory usage. As this is a new project, we're just getting things started. Feel free to poke around and learn more!
  • klisp - klisp is an implementation of the Kernel Programming Language, a Scheme-like programming language by John N. Shutt in which all objects are first-class.
  • Larceny - Larceny is a simple and efficient implementation of the Scheme programming language. Created originally as a test vehicle for research on garbage collection and compiler optimizations, Larceny has grown into a major multiplatform system. Larceny supports the four most important standards for Scheme: IEEE/ANSI, R5RS, R6RS, and R7RS. Development of Larceny has been supported by NSF, Sun Microsystems, and Microsoft.
  • Lever - Lever is a loosely specified general purpose programming language, and a runtime implementation of that language. Many tradeoffs have been made to obtain high plasticity worthy of pride. To make use of this every feature is tried in practice to level out prickly details in the language before a major release.
  • LHDL - LHDL - while not a hardware description language, may be seen as the first step in that direction. Check out the README for more information. Also see the ChangeLog. LHDL is Open Source -- released under an MIT-style license. See included LICENSE file for more information.
  • Libretto - a dynamic general purpose object-oriented programming language
  • LIL - LIL (stands for Little Interpreted Language) is a small highly dynamic scripting language inspired by Tcl and unix shells. LIL has two implementations, one written in C, which consists of a pair of .c and .h files and one in Free Pascal, which consists of a single pas file (a unit). Also a Lazarus package for the latter is provided.
  • Lingo - Lingo makes it easy to learn to program for Windows. If you're new to programming, you can download Lingo and write your first program very easily. And experienced programmers benefit because Lingo is quick to install and simple to use! Lingo includes a Developer Environment for designing forms, managing projects and debugging.
  • Little - Little is a statically typed, C-like scripting language.
  • Little Man Computer - The Little Man Computer (LMC) is a simplified example of computer hardware and software which can be used to explain the fundamental principles of computer engineering. The LMC contains all of the components of modern computers: Memory, a Central Processing Unit (CPU), and input/output capability. A small but powerful programming language is used which allows the programmer to define a computation or operation for the Little Man to perform. By writing and executing simple programs, the student is able to understand the function of each component of the hardware. Writing, debugging and executing LMC programs is supported by a color menu-driven software package written in the C programming language for the DOS environment. This paper describes the organization of the LMC, the machine language of the LMC, the LMC assembly language, the LMC Assembler, and the menu-driven user interface for the LMC.
  • Luban - Luban is a component oriented scripting language. Luban is free and open source. Luban is named after a legendary ancient Chinese civil engineer and carpenter two thousand year ago whose constructions are still in use today.
  • m80 - A build-tool independant framework for linking builds for a complete one touch system deployment in multiple environments. Includes a centralized metadata repository, code-generator framework, scripting language, re-usable macro libraries, and more.
  • Manticore - Manticore is a high-level parallel programming language aimed at general-purpose applications running on multi-core processors. Manticore supports parallelism at multiple levels: explicit concurrency and coarse-grain parallelism via CML-style constructs and fine-grain parallelism via various light-weight notations, such as parallel tuple expressions and NESL/Nepal-style parallel array comprehensions.
  • Matita - Matita (that means pencil in italian) is an experimental, interactive theorem prover under development at the Computer Science Department of the University of Bologna.
  • Crow - - Crow programs can be run directly from source.
  • Elle - Elle is a procedural programming language built in Rust which compiles to the QBE backend. It focuses on simplicity and ease of use.
  • Merlin - Merlin is a new network management framework that allows administrators to express policies in a high-level, declarative language based on regular expressions. The compiler automatically partitions those policies into components that can be placed on a variety of devices including switches, middleboxes, and end hosts. The compiler uses a constraint-solver to determine the optimal placement strategy using paramaterizable heuristics. Sub-policies may be further constrained by network tenants, facilitating management of federated networks. Merlin provides techniques for verifying that both the partitioned program components and the delegated sub-policies conform to the global network policy. Overall, Merlin simplifies the task of network administration by providing high-level abstractions for specifying network policies and scalable infrastructure for enforcing them.