Uncategorized

• Uncategorized

  • ivy - Ivy is an open-source machine learning framework that
  • Joy - The language Joy is a purely functional programming language. Whereas all other functional programming languages are based on the application of functions to arguments, Joy is based on the composition of functions. All such functions take a stack as argument and produce a stack as value. Consequently much of Joy looks like ordinary postfix notation. However, in Joy a function can consume any number of parameters from the stack and leave any number of results on the stack. The concatenation of appropriate programs denotes the composition of the functions which the programs denote. One of the datatypes of Joy is that of quoted programs, of which lists are a special case. Some functions expect quoted programs on top of the stack and execute them in many different ways, effectively by dequoting.
  • Juliet - A general purpose programming language.
  • Loko - Loko is an interactive interpreter for the Logo programming language targeting MakoVM, an extremely simple stack-based virtual machine intended for the creation of video games. Logo is best known for beginner-oriented "Turtle Graphics" functionality, but internally the language is actually a dynamically-scoped member of the Lisp family. As such, Logo provides sophisticated list manipulation facilities and support for higher-order functions.
  • Maker - Maker, a Forth-inspired compiled language targeting Mako. Mako is an extremely simple stack-based virtual machine intended for the creation of video games.
  • MakoForth - MakoForth is a small Forth dialect targeting MakoVM, an extremely simple stack-based virtual machine intended for the creation of video games. MakoForth should be moderately familiar to anyone who has been exposed to ANS-Forth. The major notable differences are the use of # as line comments, loop...(break)...again|until|while looping constructs and the inclusion of syntax for inline double-quoted string constants. Cells are always 32-bit two's complement signed integers.
  • MASICA - An educational interactive TinyBASIC interpreter targeting MakoVM, an extremely simple stack-based virtual machine intended for the creation of video games. MASICA is designed to provide an absolute minimum of features and complexity while including what is necessary to illustrate core imperative programming concepts such as variables, iteration and conditional branches. Variable names are single letters. The MASICA interface is similar to that of early 8-bit microcomputers- a prompt which can evaluate commands immediately or store a sequence of commands prefixed with line numbers. Several commands for removing or editing existing lines are also provided.
  • Ode - Ode is a stack-based, concatenative, functional programming language ..., with an interactive online development environment written in JavaScript. Ode is inspired primarily by the Joy programming language, which Ode aims to implement fully. You might even think of this language as an 'Ode to Joy'...
  • Stroyent - Stroyent is an infix, procedural systems programming language targeting MakoVM. Stroyent syntax superficially resembles that of C, but there are many important differences in the semantics of these languages.
  • ABS - ABS is a programming language that works best when you're scripting on your terminal. It tries to combine the elegance of languages such as Python, or Ruby, to the convenience of Bash.
  • Adamant - Adamant was to be a general-purpose language with high performance, deterministic safe resource management, and guaranteed thread safety.
  • Aime - aime is an imperative procedural programming language, with a C inspired syntax. It is a high level programming language, with fully automated memory management, and strong static types.
  • Blacklight - blacklight is a general-pupose multithreading concatenative stack-based programming language with first-class queues and objects with delegation.
  • Jule - An effective programming language to build efficient, fast, reliable and safe software.
  • Citrine - The inspiration for the Citrine Programming Language comes from Smalltalk (message-based, pure object oriented programming), JavaScript (prototypal inheritance), and BASIC (dynamic scope). The name Citrine refers to the yellow coloured gem and honours the short lived tradition to name programming languages after shiny minerals like Pe(a)rl and Ruby.
  • Concurnas - Concurnas is an open source JVM programming language designed for building reliable, scalable, high performance concurrent, distributed and parallel systems
  • Crema - Crema is a LLVM front-end that aims to specifically execute in sub-Turing Complete space. Designed to be simple to learn, and practical for the majority of programming tasks needed, Crema can restrict the computational complexity of the program to the minimum needed to improve security
  • Curv - Curv is a programming language for creating art using mathematics. It’s a 2D and 3D geometric modelling tool that supports full colour, animation and 3D printing.
  • Cylvre - Cylvre is a strongly typed, programming language with type inference for the JVM.
  • Fleng - This software is an implementation of "FLENG", a low level concurrent logic programming language descended from Prolog. A compiler is provided to translate programs written in FLENG into assembly language which can subsequently be compiled and linked into a binary executable.
  • 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.
  • Darklang - a combined language, editor, and infrastructure to make it easy to build backends and CLIs.
  • Dashrep - Dashrep™, the text-manipulation programming language that is powerful and fast, yet simple
  • Dhall - Dhall is a programmable configuration language that you can think of as: JSON + functions + types + imports
  • ETAC - ETAC™ (pronounced: E-tack) is a syntactically simple but extremely versatile general purpose dictionary and stack based interpreted script programming language fully capable of traditional high-level block structured language style syntax.
  • evolve - Evolve is an interpreted programming language, it has been designed to be easy to use so anyone can quickly learn how to write a PC program. To this end the instruction set has been kept to a minimum and the commands and syntax have been kept as simple as possible.
  • ghūl - ghūl is a general-purpose, statically-typed, managed programming language. It supports object-oriented programming with functional elements through a quirky syntax reminiscent of ALGOL 68 and Pascal that aims to be both expressive and readable. The language targets .NET and interoperates with the .NET ecosystem. The [self-hosting ghūl compiler](https://github.com/degory/ghul), written entirely in ghūl, shows the language's capabilities and dogfooding philosophy.
  • Dashrep - Dashrep™, the text-manipulation programming language that is powerful and fast, yet simple
  • Formality - Formality is an efficient proof language. An lightweight proof-gramming language. It aims to be:
  • atlantis - a system programming language and ecosystem
  • Atom - A general purpose programming language that easy to use, read and integrated
  • Burro - A digital typesetting language
  • Carth - A Scheme-looking, purely functional programming language
  • Creed - A concatenative language for text processing script, inspired by ed and sam
  • Dusa - a logic programming language that has features of both Datalog and answer set programming.
  • Elijah - a high-level language suitable for replacement of C/C++ and Java. (And of course any other language in existence or non-existence, except FORTRAN and NULL.)
  • Fig - a compiled, statically-typed, garbage collected and expressive programming language.
  • Frost - Frost is a high-level, general-purpose multiparadigm programming language
  • Fuzuli - JFuzuli is the JVM implementation of our programming language Fuzuli which is based on LISP syntax and Algol family programming logic. Fuzuli is a modern collaboration of these two separate family of languages.
  • Kapreolo - an interactive functional programming language.
  • Lake - The Lake programming language: C but sweeter
  • ldetect - execute different commands based on stdin text language
  • Neon - to find out whether a useful programming language can avoid some of the common pitfalls that beginners frequently encounter in other languages. Some of these common errors avoided by design are:
  • Pipa - Programming as fun as flying kite
  • Rhumb - Experimental International Language
  • Scopes - The Scopes Programming Language & Compiler Infrastructure
  • Sunder - a modest systems programming language for Unix-like platforms.
  • Swallow - A minimalist functional programming language
  • Sylvan - A general-purpose programming language that aspires to have support for attribute grammars, managed effects, and efficient pure functional programming.
  • Thon - a small functional language
  • violet - A programming language, half theorem prover
  • Wak - Stack-based text-processing language
  • Cecil - Cecil is a purely object-oriented, type-safe, garbage-collected language intended to support rapid construction of high-quality, extensible software.
  • Cyclone - Cyclone is like C: it has pointers and pointer arithmetic, structs, arrays, goto, manual memory management, and C’s preprocessor and syntax. It adds features such as pattern matching, algebraic datatypes, exceptions, region-based memory management, and optional garbage collection.
  • Diesel - Diesel is a purely object-oriented, type-safe, garbage-collected language intended to support rapid construction of high-quality, extensible software. Diesel is an evolutionary successor to Cecil, retaining Cecil's support for multimethods, first-class function objects, uniform access to all instance variables and methods via dynamically dispatched messages, predicate classes, multiple inheritance, open classes where methods and instance variables are declared separately from their classes, and a constraint-based polymorphic static type system.
  • L.B.Stanza - L.B. Stanza (or Stanza for short) is a new optionally-typed general purpose programming language from the University of California, Berkeley. Stanza was designed to help programmers tackle the complexity of architecting large programs and significantly increase the productivity of application programmers across the entire software development life cycle.
  • Polyglot - Polyglot is a highly extensible compiler front end for the Java programming language. It is implemented as a Java class framework using design patterns to promote extensibility. Using Polyglot, language extensions can be implemented without duplicating code from the framework itself. Polyglot has been used to implement domain-specific languages, to explore language design ideas, to simplify Java for pedagogical purposes, and for various code transformations such as optimization and fault injection.
  • 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.
  • Teal - A typed dialect of Lua
  • Thistle - Thistle is a programming language and compiler, suitable for introductory programming instruction. It creates a single file, compiled executable application. Thistle comes with a code editor, helpfile, sample code, and the FASM assembler. There are two versions of Thistle. Thistle creates a console application. Thistle-Win creates a Windows application.
  • 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.
  • Adept - A blazing fast language for general purpose programming.
  • AdvSys - AdvSys - A Language for Writing Text Adventure Games
  • Agda - Agda is a dependently typed functional programming language. It has inductive families, i.e., data types which depend on values, such as the type of vectors of a given length. It also has parametrised modules, mixfix operators, Unicode characters, and an interactive Emacs interface which can assist the programmer in writing the program.
  • Aith - Low level functional programming language with linear types, Generalized Inline Functions, levity polymorphism and regions. Aith is a perfomant systems programming language with am empathises on type systems. As of now Aith is very early stages and very little is implemented.
  • Alan - Alan is a Autoscalable Programming Language:
  • Alda - Alda is a text-based programming language for music composition. It allows you to compose and play back music using only your text editor and the command line.
  • Alumina - Alumina is an imperative, general-purpose, statically typed, compiled system programming language. Alumina is heavily inspired by Rust, especially in terms of syntax and standard library API. Unlike Rust, however, Alumina is not memory-safe and it requires manual memory management.
  • Ante - Ante is a low-level functional language for exploring refinement types, lifetime inference, and other fun features. In general, ante is low-level (no GC, values aren't boxed by default) while also trying to be as readable as possible by encouraging high-level approaches that can be optimized with low-level details later on.
  • Antimony - Antimony is a general-purpose toy language. Its primary goal is to be simple and easy to understand, not to be efficient.
  • Ape - Ape is an easy to use programming language and library written in C. It's an offspring of Monkey language, but it evolved to be more procedural with variables, loops, operator overloading, modules, and more.
  • April - April (Array Programming Re-Imagined in Lisp) - The APL programming language (a subset thereof) compiling to Common Lisp.
  • Arend - Arend is a theorem prover and a programming language based on Homotopy Type Theory.
  • Argo - Pragmatic functional programming language.
  • Argon - Argon is an interpreted multi-paradigm dynamically typed programming language. Its syntax is mainly influenced by Python, Go and Rust.
  • Ark - Ark is a tiny, fast, and **somewhat** useful programming language focused on runtime stability and simple code syntax. Every instruction is a single character, but it is NOT an esolang. (anymore)
  • Ark - Ark is a systems programming language focused on being practical and pragmatic. We want a language that is simple, easy to write, yet powerful enough to create readable, performant and concise code for any problem
  • ArkScript - ArkScript is a small, fast, functional and scripting language for C++ projects ; the syntax is inspired by Lisp. It's a scripting language aiming for high portability and easily embedding in C++ projects, with a few nice features such as tail call optimization and macros.
  • Arturo - Arturo is an independently-developed, modern programming language, vaguely related to various other ones - including but not limited to Logo, Rebol, Forth, Ruby, Haskell, D, SmallTalk, Tcl, and Lisp. The language has been designed following some very simple and straightforward principles: a) Code is just a list of words and symbols, b) Words and symbols within a block are interpreted - when needed - according to the context, c) No reserved words or keywords - look for them as hard as you can; there are absolutely none.
  • astro - Astro is a fun programming language designed for safe high-performance applications. It is essentially a statically-typed systems language that
  • ATS - ATS is a 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. In particular, both dependent types and linear types are available in ATS.
  • Avail - Avail is a multi-paradigmatic general purpose programming language whose feature set emphasizes support for articulate programming. Avail is an open-source project that comprises a language virtual machine and a standard library.
  • Backlang - A new Rust, C# inspired Language for .Net
  • Bait - Bait is a compiled general purpose programming language with a simple syntax but still powerful feature set and standard library for building reliable software.
  • Ballerina - Ballerina is an open-source programming language for the cloud that makes it easier to use, combine, and create network services.
  • Barn - Barn is a simple programming language written in GoLang and compiled to C++. Syntax is very simple, and Barn can call C/C++ functions natively so creating new bindings should be easy. Barn was written with the goal of being as fast and easy to use as possible. Barn is just a little project with which I can chill and just code.
  • Battlestar - Subset of assembly with an alternative syntax and with support for inline C, specifically for 64-bit x86 Linux, 32-bit x86 Linux and 16-bit x86 DOS.
  • Beanshell - BeanShell is a small, free, embeddable Java source interpreter with object scripting language features, written in Java. BeanShell dynamically executes standard Java syntax and extends it with common scripting conveniences such as loose types, commands, and method closures like those in Perl and JavaScript.
  • Beef - Beef is a performance-oriented compiled programming language.
  • Berry - A ultra-lightweight embedded scripting language optimized for microcontrollers.
  • Beryl - Beryl is a small, interpreted, embeddable scripting language with value semantics and first class functions. The main feature of Beryl is that the core interpreter can run without any dynamic memory allocation*, and it does not need to parse or compile scripts beforehand. It can also be built without any external dependencies, excluding some typedefines and constants needed from stddef.h and limits.h; however these could be provived from a custom header if needed.
  • Bhl - BeHavior Language is a strictly typed programming language specifically tailored for gameplay logic scripting.
  • Bite - Bite is a dynamically typed, object oriented programming language. Dynamically typed, because the type of the content of a variable can change during runtime of the program. Object-oriented, because you can define classes to encapsulate your code and data. Bite uses modules, classes and functions to separate code.
  • BL - The Biscuit Language (BL) is simple imperative programming language using LLVM backend implemented in C. Biscuit is designed to be simple, fast and explicit. Language syntax is inspired by JAI.
  • Blade - Blade is a simple, clean, and embeddable dynamic programming language created to be simple enough for beginners, yet powerful and expressive for professionals. It has a very small syntax set with a very low learning curve. Blade improves upon the best features of JavaScript, Python, and Ruby to give developers a familiar and powerful system that feels native for developers coming from any of these languages and an easy way to leverage the strength of any.
  • Blech - Blech is a language for developing reactive, real-time critical embedded software.
  • BlitzMax - BlitzMax is a fast cross-platform, open-source programming language.
  • Bob - Bob is a simple object-oriented scripting language. Bob’s syntax is similar to C or C++ but it is dynamically typed and has automatic memory management.
  • Bob2 - Revised version of Bob derived from the Nuon work at VM Labs
  • Boba - A general purpose statically-typed concatenative programming language. Key features include:
  • Boo - Boo is an object-oriented, statically typed, general-purpose programming language that seeks to make use of the Common Language Infrastructure's support for Unicode, internationalization, and web applications, while using a Python-inspired syntax[2] and a special focus on language and compiler extensibility. Some features of note include type inference, generators, multimethods, optional duck typing, macros, true closures, currying, and first-class functions.
  • Borealis - Borealis is a small, elegant and consistent scripting language. Includes a C-like syntax that's easy to implement.
  • Bosque - Bosque is an open-source project focused on developing a new Programming Language and Development Tooling Stack. The foundation of this project is the view that mechanization and automated reasoning, along with human and AI agents that leverage them, are the ideas that will define the next era of software development. The foundation of the Bosque language and stack is a carefully constructed core calculus and computation model that are uniquely amenable to automated reasoning. Building on top of this core calculus the Bosque language, as seen by a developer, is a hybrid of functional programming design, ergonomic block & assignment-based syntax, and a number of new features designed to simplify and support writing high reliability code.
  • BQN - An APL-like programming language. Self-hosted!
  • Brython - A Python 3 implementation for client-side web programming.
  • Bulfinch - Just a little toy language to learn about register-based VMs.
  • Buzz - A small/lightweight statically typed scripting language written in Zig.
  • β-Juliet - β-Juliet is a fairly minimal event-oriented language. In β-Juliet, the world is modelled as a set of events which have no inherent organization or order. Each event can be denoted with a symbol, such as DominoFalls, CatMeows, or SunSets, or (in version 2.0) a string of symbols, such as Address Line Six Goes High or Greengrocer Falls Asleep on Subway. Each event can cause other events to occur — these are termed consequences of the event. In addition, this causation may be conditional, but the only condition that is possible to check is: given two events, which one happened more recently?
  • C2 - The C2 project attempts to create a new language, strongly based on C. In a nutshell, the main differences with C are:
  • C3 - C3 is a C-like language trying to be "an incremental improvement over C" rather than a whole new language.
  • Cakelisp - A metaprogrammable, hot-reloadable, non-garbage-collected language ideal for high performance, iteratively-developed programs (especially games).
  • CakeML - CakeML is a verified implementation of a significant subset of Standard ML.
  • Calc4 - Calc4 is a programming language where everything in its code is an operator.
  • Calcit - Calcit is an interpreter built with Rust, and also a JavaScript code emitter. It's inspired mostly by ClojureScript. Calcit-js emits JavaScript in ES Modules syntax.
  • Cane - A small MIDI sequencer DSL designed around vectors and euclidean rhythms.
  • Cant - a programming language descended mainly from E and Scheme.
  • Carbon - Carbon is fundamentally a successor language approach, rather than an attempt to incrementally evolve C++. It is designed around interoperability with C++ as well as large-scale adoption and migration for existing C++ codebases and developers.
  • Carp - A statically typed lisp, without a GC, for real-time applications. Carp is a small programming language designed to work well for interactive and performance sensitive use cases like games, sound synthesis and visualizations.
  • Cassette - A new evolutionary highlevel and readable tape language (unlike brainf), with pattern matching, arity overloading, modules, lambdas (rather quotes) and much more; All topped on with a simple and aesthetic syntax.
  • Cat9 - Cat9 is a user shell script for LASH - a command-line shell that discriminates against terminal emulators, written in Lua. You probably have not heard of LASH before. If you really must know, check the Backstory section below. LASH just provides some basic shared infrastructure and a recovery shell. It then runs a user provided script that actually provides most of the rules for how the command line is supposed to look and behave.
  • ChaiScript - ChaiScript is one of the only embedded scripting language designed from the ground up to directly target C++ and take advantage of modern C++ development techniques, working with the developer how they would expect it to work. Being a native C++ application, it has some advantages over existing embedded scripting languages:
  • Chapel - Chapel is a modern programming language designed for productive parallel computing at scale. Chapel's design and implementation have been undertaken with portability in mind, permitting Chapel to run on multicore desktops and laptops, commodity clusters, and the cloud, in addition to the high-end supercomputers for which it was originally undertaken.
  • Charm - Charm is a data-oriented scripting language.
  • Ciao - Ciao is a modern Prolog implementation that builds up from a logic-based simple kernel designed to be portable, extensible, and modular.
  • Cicada - Cicada language is a dependently typed programming language and an interactive theorem prover. The aim of cicada project is to help people understand that developing software and developing mathematics are increasingly the same kind of activity, and people who practices these developments, can learn from each other, and help each other in very good ways.
  • Circle - Circle is the richest C++ compiler yet. Circle describes a path for evolving C++ to meet the needs of institutional users. The versioning mechanism that accommodated the development of the features above will also accommodate research into critically important areas like memory safety. Rather than insisting on a one-size-fit's-all approach to language development, project leads can opt into collections of features that best target their projects' needs. Features:
  • Cish - A minimal, performant, strongly-typed, and multi-paradigm programming language focused on being practical and pragmatic, yet powerful enough to create readable, performant and concise code for any problem. While Cish has as much to do with Forth as Javascript has with Java, it shares the same minimalist, performance oriented approach and philosophy.
  • CLAIRE4 - Claire is a general-purpose programming language, best suited to application software requiring sophisticated data modeling, rule processing or problem solving. WebClaire adds extensions for fuller integration with the operating system and for programming web applications.
  • clio - Clio is a functional, distributed programming language that compiles to JavaScript. It runs in the browser and on the server and is made to be a suitable language for scientific programming. Clio takes advantage of multiple CPUs and multiple CPU cores (parallelism) by default, is able to use network resources, is easy to run on clusters and on the cloud.
  • Clojure - A dialect of Lisp, and shares with Lisp the code-as-data philosophy and a powerful macro system. Clojure is predominantly a functional programming language, and features a rich set of immutable, persistent data structures. When mutable state is needed, Clojure offers a software transactional memory system and reactive Agent system that ensure clean, correct, multithreaded designs.
  • clprolf - clprolf (CLear PROgramming Language and Framework) has been made for simplify programming, especially OOP. It is a superset of java. The clprolf framework is available for Java, C#, or PHP.
  • Clue - Clue is a programming language that compiles into Lua code with a syntax similar to languages like C or Rust. Clue tries to be almost as simple as Lua (with only a slightly more advanced syntax) but adds many optional features that can make code look better or make some things (like metatables) easier to code. Clue does not compile to a specfic version of Lua: flags can be toggled to alter the output to allow most if not all versions or modifications of Lua to be compiled to with Clue.
  • Cmajor - Cmajor is an experimental programming language strongly influenced by C++ and C#. It is semantically closer to C++ than C# and syntactically closer to C# than C++.
  • Coconut - Simple, elegant, Pythonic functional programming.
  • Cod - Cod is an opensource concatenative stack-based general purpose programming language. Its transpiled to C and then compiled further to a native executable using external compilers like GCC.
  • Cognate - Cognate is a quasi-concatenative stack oriented language that uses embedded comments to read like English prose. It is a dynamic language (yet compiled) and makes great use of combinators and higher order functions. Cognate aims to make functional programming simple, readable, and maintainable.
  • colm - Colm = COmputer Language Machinery. Colm is a programming language designed for the analysis and transformation of computer languages. Colm is influenced primarily by TXL
  • Common Expression Language - The Common Expression Language (CEL) implements common semantics for expression evaluation, enabling different applications to more easily interoperate.
  • Compis - Contemporary systems programming language in the spirit of C.
  • Cone - Cone is a fast, fit, friendly, and safe systems programming language. Ideal for complex, data-rich programs requiring responsive performance (e.g., 3D).
  • Core - A modern, minimal programming language. In a world in which languages add features until they collapse under their own weight, build a language that is content with itself.
  • Cotowali - A statically typed scripting language that transpile into POSIX sh
  • Covariant Script - Covariant Script is an open source, cross-platform programming language. High-performance runtime environment. Self-developed efficient compilation system. Powerful and bloat-free extension system
  • Cowgol - A self-hosted Ada-inspired programming language for very small systems. Cowgol is an experimental, Ada-inspired language for very small systems (6502, Z80, etc). It's different because it's intended to be self-hosted on these devices: the end goal is to be able to rebuild the entire compiler on an 8-bit micro, although we're not there yet.
  • Cppfront - Cppfront is an experimental compiler from a potential C++ 'syntax 2' (Cpp2) to today's 'syntax 1' (Cpp1), to learn some things, prove out some concepts, and share some ideas. This compiler is a work in progress and currently hilariously incomplete... basic functions work, classes will be next, then metaclasses and lightweight exceptions.
  • Crumb - Crumb is a high level, functional, interpreted, dynamically typed, general-purpose programming language, with a terse syntax, and a verbose standard library.
  • Crush - Crush is an attempt to make a traditional command line shell that is also a modern programming language. It has the features one would expect from a modern programming language like a type system, closures and lexical scoping, but with a syntax geared toward both batch and interactive shell usage.
  • Crystal - Crystal is a language with a Ruby like sintax, statically type-checked. It supports compile-time evaluation and code generation. It compiles to efficient native code.
  • CSL - CSL is a simple lisp-like macro language for scripting high-level logic and data structures in a way that interfaces easily to the C programming language
  • Cubiml - Cubiml is a simple ML-like programming language with subtyping and full type inference. You can try it out online in your browser [here](https://storyyeller.github.io/cubiml-demo/demo.html).
  • Cyber - Cyber is a fast, efficient, and concurrent scripting language. You can embed it into your applications, games, or engines on desktop or web. Cyber also comes with a CLI, so you can do scripting on your computer.
  • Céu - Céu is a reactive language that aims to offer a higher-level and safer alternative to C.
  • C∀ - C? (Cforall) is a language design extending ISO C. The purpose of the project is to engineer modern language features into C in an evolutionary rather than revolutionary way. Java is an example of the revolutionary approach of modernizing C/C++, resulting in a new language rather than an extension of its descendents. C++, Fortran 95 and Cobol 9X are examples of the evolutionary approach where modern language features are added and problems fixed within the framework of an existing language.
  • D - General-purpose programming language with static typing, systems-level access, and C-like syntax.
  • Dachs - Dachs is a general-purpose programming language designed to be enjoyable, statically-typed and dog-friendly. Dachs is intended to be used for efficient applications and tools development, not for system programming.
  • Dafny - Dafny is a verification-ready programming language. As you type in your program, Dafny's verifier constantly looks over your shoulder, flags any errors, shows you counterexamples, and congratulates you when your code matches your specifications. When you're done, Dafny can compile your code to C#, Java, JavaScript or Go (more to come!), so it can integrate with your existing workflow.
  • Dale - Dale is a system (no GC) programming language that uses S-expressions for syntax and supports syntactic macros. The basic language is similar to C, with the following additional features:
  • Dark - Darklang is an integrated language, framework, and editor for building web backends: REST API endpoints, asynchronous background workers, scheduled jobs, and persistent storage. Darklang's framework is tightly coupled to the infrastructure, and as you write code you're able to develop from real incoming requests/traces.
  • Dark Basic Pro - Dark Basic Pro is an open source BASIC programming language for creating Windows applications and games.
  • Dart - Dart is a programming language designed for client development, such as for the web and mobile apps. It is developed by Google and can also be used to build server and desktop applications. It is an object-oriented, class-based, garbage-collected language with C-style syntax. It can compile to either native code or JavaScript, and supports interfaces, mixins, abstract classes, reified generics and type inference. Primarally used with the Flutter GUI toolkit.
  • daScript - high-performance statically strong typed scripting language.
  • Daybreak - Programming language that compiles to C
  • Derw - An Elm-inspired language that transpiles to TypeScript. Derw is a type-safe language in the ML family designed to replace or augment your TypeScript and JavaScript code - both on the client and the server. If you've never encountered an ML language before, some of the core principles - which Derw follows - is a clean and concise syntax, paired with a powerful type system.
  • DeviceScript - TypeScript for Tiny IoT Devices (ESP32, RP2040, ...). DeviceScript brings a TypeScript developer experience to low-resource microcontroller-based devices. DeviceScript is compiled to a custom VM bytecode, which can run in very constrained environments. [Tiny, IoT]
  • Dictu - Dictu is a high-level dynamically typed, multi-paradigm, interpreted programming language.
  • Dino - High-Level scripting object-oriented language:
  • Draco - a new .NET programming language under development. If you want further details on the language itself or want to contribute ideas, head over to the [language suggestions repository](https://github.com/Draco-lang/Language-suggestions).
  • DWScript - DWScript is an object-oriented scripting engine for Delphi based on the Delphi language, with extensions borrowed from other Pascal languages (FreePascal, Prism, etc.). It introduces a few Pascal language extensions of its own as well.
  • Dyalect - Dyalect is a dynamic programming language for .NET platform. It is lightweight, fast and modern. Dyalect (or Dy for short) supports Windows, MacOS and Linux. Dy runs on the top of its own high performance virtual machine. It compiles fast and can be used as an embeddable language or as a scripting language of your choice. It is also a good language to learn programming. Dyalect offers modern syntax, inspired by such languages as C#, Swift, Go and Rust, first class functions, coroutines, expressive modules, a dynamic type system with an ability to extend existing types with new methods and much more.
  • 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.
  • Dyon - A rusty dynamically typed scripting language.
  • Easylang - An easy programming language that runs in the browser. Easylang is a rather minimalistic simple programming language. Because of the clear syntax and semantics it is well suited as a teaching and learning language. Functions for graphic output and mouse input are built into the language. The language is written in C and is open source. Main target platform is the web browser using WASM. However, it also runs natively in Windows and Linux. The one-pass parser and compiler is quite fast. In the Web IDE, each time the Enter key is pressed, the program is parsed and formatted up to the current line.
  • eC - An Expressive and Intuitive, C Style Object-Oriented Programming Language. eC comes bundled with the [Ecere SDK](https://ecere.org/), providing a comprehensive API for building apps ranging from games to business, for desktop, mobile and web platforms.
  • Ecstasy - Ecstasy is a new, general-purpose, programming language, designed for modern cloud architectures, and explicitly for the serverless cloud. Actually, to be completely honest, it's the most amazing programming language ever. No, really, it's that awesome.
  • Edina - Edina - A simple stack-oriented compiled programming language. Edina is a simple multi-paradigm programming language. It currently features a JVM compiler, a REPL and an ever expanding standard library. Edina is mostly a hobby project. Due to its stack-oriented design it's a little restrictive and hard to program in, but that's what makes it fun in my opinion.
  • Edward2 - Edward2 is a simple probabilistic programming language. It provides core utilities in deep learning ecosystems so that one can write models as probabilistic programs and manipulate a model's computation for flexible training and inference.
  • Effekt - A research language with effect handlers and lightweight effect polymorphism.
  • Egel - Egel is an untyped concurrent functional scripting language based on eager combinator rewriting with a concise but remarkably powerful syntax.
  • egison - Egison is a functional programming language featuring its expressive pattern-matching facility. Egison allows users to define efficient and expressive pattern-matching methods for arbitrary user-defined data types including non-free data types such as lists, multisets, sets, trees, graphs, and mathematical expressions. This is the repository of the interpreter of Egison.
  • ela - Ela is a simple, yet powerful modern functional language with a state-of-art syntax. Ela combines strict and lazy evaluation, dynamic typing and features, which are normally adopted by statically typed languages, such as algebraic data types and Haskell style type classes.
  • Electra - Electra is an esolang where you code like an electrician. Electra is inspired by AsciiDots. It uses instruction pointers that acts like currents in electricity. [eso]
  • Elena - ELENA is a general-purpose language with late binding. It is multi-paradigm, combining features of functional and object-oriented programming. Rich set of tools are provided to deal with message dispatching : multi-methods, message qualifying, generic message handlers, run-time interfaces.
  • ELFE - ELFE (Extensible Language for Everyday (and the Internet of Things)) is a very simple and small programming language specifcally designed for everyday programming, notably for the Internet of Things. While ELFE is a general-purpose programming language, it is designed to facilitate the configuration and control of swarms of small devices such as sensors or actuators. It can also be used as a powerful, remotely-accessible extension language for larger applications.
  • Elixir - A dynamic, functional language for building scalable and maintainable applications. Elixir leverages the Erlang VM, known for running low-latency, distributed, and fault-tolerant systems. Elixir is successfully used in web development, embedded software, data ingestion, and multimedia processing, across a wide range of industries.
  • Elvish - Elvish is an expressive programming language and a versatile interactive shell, combined into one seamless package. It runs on Linux, BSDs, macOS and Windows.
  • EmojiCode - World's only programming language that's bursting with emojis. Emojicode is an open source, high-level, multi-paradigm programming language consisting of emojis. It features Object-Orientation, Optionals, Generics and Closures.
  • Enterprise - Enterprise™ is a non-deterministic-unnecessarily-statically-typed™ Turing-complete-ish™, Quantum-out-of-the-box™ programming language.
  • Eolang - EO (stands for Elegant Objects or ISO 639-1 code of Esperanto) is an object-oriented programming language based on 𝜑-calculus. We're aware of popular semi-OOP languages and we don't think they are good enough, including Java, Ruby, C++, Smalltalk, Python, PHP, C#: all of them have something we don't tolerate. EO is not planning to become a mainstream language-this is not what we want. Our main goal is 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.
  • Erg - A statically typed language that can deeply improve the Python ecosystem.
  • Erlang - A programming language used to build massively scalable soft real-time systems with requirements on high availability. Some of its uses are in telecoms, banking, e-commerce, computer telephony and instant messaging. Erlang's runtime system has built-in support for concurrency, distribution and fault tolerance.
  • Eta - What is Eta? Eta is a pure, lazy, strongly typed functional programming language on the JVM. It brings two big ecosystems, the JVM and Haskell, together. This allows you to harness the best of both ecosystems to build your applications quickly and effectively. Eta's concurrency support helps you to build highly scalable systems.
  • etalk - A Simple Object-Oriented Language
  • Euphoria - Euphoria is a powerful but easy-to-learn and easy-to-use programming language. It has a simple syntax and structure with consistent rules, and is also easy to read. You can quickly, and with little effort, develop applications big and small for Windows and UNIX variants (Linux, FreeBSD, and OS X).
  • F# - a functional-first, general purpose, strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. Developed by Microsoft for the .NET platform.
  • F* - F* (pronounced F star) is a general-purpose functional programming language with effects aimed at program verification. It puts together the automation of an SMT-backed deductive verification tool with the expressive power of a proof assistant based on dependent types. After verification, F* programs can be extracted to efficient OCaml, F#, C, WASM, or ASM code. This enables verifying the functional correctness and security of realistic applications. The main ongoing use case of F* is building a verified, drop-in replacement for the whole HTTPS stack in Project Everest. This includes verified implementations of TLS 1.2 and 1.3 and of the underlying cryptographic primitives.
  • Fantom - Fantom is a portable language that runs on the JVM and modern web browsers. It features a familiar Java-like syntax, static (and dynamic) typing, elegant system library, closures, immutability, actor concurrency, and much more.
  • Fanx - Fanx is a full-stack programming language base on Fantom. It is an object oriented and static typing language with elegant libraries.
  • Faust - Faust (Functional Audio Stream) is a functional programming language specifically designed for real-time signal processing and synthesis. A distinctive characteristic of Faust is to be fully compiled.
  • fbgc - Small Language and Calculator in C
  • Fe - A tiny, embeddable language implemented in ANSI C.