{"id":55253,"url":"https://github.com/ChessMax/awesome-programming-languages","name":"awesome-programming-languages","description":"The list of awesome programming languages that you might be interested in.","projects_count":971,"last_synced_at":"2026-06-08T16:00:20.052Z","repository":{"id":37538410,"uuid":"277155531","full_name":"ChessMax/awesome-programming-languages","owner":"ChessMax","description":"The list of awesome programming languages that you might be interested in.","archived":false,"fork":false,"pushed_at":"2026-06-04T12:27:10.000Z","size":4088,"stargazers_count":803,"open_issues_count":0,"forks_count":74,"subscribers_count":20,"default_branch":"master","last_synced_at":"2026-06-04T14:11:32.608Z","etag":null,"topics":["awesome","awesome-list","language","programming-language"],"latest_commit_sha":null,"homepage":"","language":"Markdown","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/ChessMax.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2020-07-04T17:25:46.000Z","updated_at":"2026-06-04T12:27:14.000Z","dependencies_parsed_at":"2022-07-09T10:00:40.614Z","dependency_job_id":"2cf85ae2-7641-4e60-bd63-24de357eac3e","html_url":"https://github.com/ChessMax/awesome-programming-languages","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/ChessMax/awesome-programming-languages","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ChessMax%2Fawesome-programming-languages","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ChessMax%2Fawesome-programming-languages/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ChessMax%2Fawesome-programming-languages/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ChessMax%2Fawesome-programming-languages/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/ChessMax","download_url":"https://codeload.github.com/ChessMax/awesome-programming-languages/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/ChessMax%2Fawesome-programming-languages/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34069501,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-08T02:00:07.615Z","response_time":111,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"created_at":"2024-01-24T15:26:07.254Z","updated_at":"2026-06-08T16:00:20.053Z","primary_language":null,"list_of_lists":false,"displayable":true,"categories":["Uncategorized","Related:"],"sub_categories":["Uncategorized"],"readme":"# Awesome programming languages\nThe list of **952** programming languages that you might be interested in.\nIf you like exploring programming languages, or you are making your own programming language,\nthen it's place for you. Here you can find interesting programming languages that are not well known or promote your own programming language. Also, it's the place to look for a new ideas and inspiration. Feel free to make a contribution.\n\n## Related: \n- [Awesome Programming Languages articles](awesome-pl-articles.md);\n- [See also section](#see-also);\n \n[![GitHub forks](https://badgen.net/github/forks/ChessMax/awesome-programming-languages/)](https://GitHub.com/ChessMax/awesome-programming-languages/network/)\n[![GitHub stars](https://badgen.net/github/stars/ChessMax/awesome-programming-languages)](https://GitHub.com/ChessMax/awesome-programming-languages/stargazers/)\n[![GitHub contributors](https://badgen.net/github/contributors/ChessMax/awesome-programming-languages)](https://GitHub.com/ChessMax/awesome-programming-languages/graphs/contributors/)\n\n## Contents\n\n\u003ca href=\"#A\"\u003eA\u003c/a\u003e \u003ca href=\"#B\"\u003eB\u003c/a\u003e \u003ca href=\"#C\"\u003eC\u003c/a\u003e \u003ca href=\"#D\"\u003eD\u003c/a\u003e \u003ca href=\"#E\"\u003eE\u003c/a\u003e \u003ca href=\"#F\"\u003eF\u003c/a\u003e \u003ca href=\"#G\"\u003eG\u003c/a\u003e \u003ca href=\"#H\"\u003eH\u003c/a\u003e \u003ca href=\"#I\"\u003eI\u003c/a\u003e \u003ca href=\"#J\"\u003eJ\u003c/a\u003e \u003ca href=\"#K\"\u003eK\u003c/a\u003e \u003ca href=\"#L\"\u003eL\u003c/a\u003e \u003ca href=\"#M\"\u003eM\u003c/a\u003e \u003ca href=\"#N\"\u003eN\u003c/a\u003e \u003ca href=\"#O\"\u003eO\u003c/a\u003e \u003ca href=\"#P\"\u003eP\u003c/a\u003e \u003ca href=\"#Q\"\u003eQ\u003c/a\u003e \u003ca href=\"#R\"\u003eR\u003c/a\u003e \u003ca href=\"#S\"\u003eS\u003c/a\u003e \u003ca href=\"#T\"\u003eT\u003c/a\u003e \u003ca href=\"#U\"\u003eU\u003c/a\u003e \u003ca href=\"#V\"\u003eV\u003c/a\u003e \u003ca href=\"#W\"\u003eW\u003c/a\u003e \u003ca href=\"#X\"\u003eX\u003c/a\u003e \u003ca href=\"#Y\"\u003eY\u003c/a\u003e \u003ca href=\"#Z\"\u003eZ\u003c/a\u003e\n\n\u003ca name=\"A\"\u003e\u003c/a\u003e\n# A (52):\n- [A+](https://web.archive.org/web/20170102191459/http://www.aplusdev.org/index.html) - A+ is a powerful and efficient programming language. It is freely available under the GNU General Public License. It embodies a rich set of functions and operators, a modern graphical user interface with many widgets and automatic synchronization of widgets and variables, asynchronous execution of functions associated with variables and events, dynamic loading of user compiled subroutines, and many other features. Execution is by a rather efficient interpreter. A+ was created at Morgan Stanley. Primarily used in a computationally-intensive business environment, many critical applications written in A+ have withstood the demands of real world developers over many years. Written in an interpreted language, A+ applications tend to be portable. \n- [ABC](https://homepages.cwi.nl/~steven/abc/) - ABC is an interactive programming language and environment for personal computing, originally intended as a good replacement for BASIC. It was designed by first doing a task analysis of the programming task.ABC is easy to learn (an hour or so for someone who has already programmed), and yet easy to use. Originally intended as a language for beginners, it has evolved into a powerful tool for beginners and experts alike.\n- [ABCL](http://web.yl.is.s.u-tokyo.ac.jp/pl/abcl.html) - ABCL: An Object-Oriented Concurrent System. The tenet of our ABCL research project is to exploit both paralle. lism and object orientation. Parallelism is ubiquitous in our problem domains; parallelism is not only the source of computational power, but also promotes structural simplicity/naturalness in design and algorithm. Object-orientation accompanying parallelism, enhances system modularity, flexibility, and safety.\n- [ABS](https://www.abs-lang.org/) - 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.\n- [ACCEPT](https://sampa.cs.washington.edu/accept/) - ACCEPT, an approximate compiler for C and C++ programs based on Clang. Think of it as your assistant in breaking your program in small ways to trade off correctness for performance.\n- [Ada](https://ada-lang.io/) - A programming language for readable, correct, and performant software. Get started with Alire, the Ada package manager.\n- [Adamant](https://adamant-lang.org/) - Adamant was to be a general-purpose language with high performance, deterministic safe resource management, and guaranteed thread safety.\n- [Adept](https://github.com/AdeptLanguage/Adept) - A blazing fast language for general purpose programming.\n- [Adept3x](https://github.com/IsaacShelton/Adept3x) - A language designed to help maximize developer productivity and safety\n- [AdvSys](https://github.com/dbetz/advsys) - AdvSys - A Language for Writing Text Adventure Games\n- [Aergia](https://github.com/las-r/aergia) - Aergia is a programming language designed with the aim of having incredibly minimal, esolang-style syntax while still being readable enough to be considered a usable programming language.\n- [Agda](https://github.com/agda/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.\n- [Agena](https://sourceforge.net/projects/agena/) - Agena is an easy-to-learn procedural programming language suited to be used in scientific, mathematical, scripting, networking, and many other applications. Binaries are available for Solaris, Windows, Linux, OS/2, Mac OS X, Raspberry Pi and DOS.\n- [Aime](https://aime-embedded.sourceforge.net/) - 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.\n- [Aith](https://github.com/Superstar64/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.\n- [Alan](https://github.com/alantech/alan) - Alan is a Autoscalable Programming Language:\n  - 🔭 Predictable runtime for all computations - A program is represented as DAG(s) where the running time for all computations can be predicted because there is no unbounded recursion or iteration;\n  - ⛓ Automatic IO concurrency and parallelism across events and arrays - Alan exploits opportunities for IO concurrency or CPU parallelization across machines in a cluster via arrays and a static event loop without threads, channels, promises, futures, locks, etc;\n  - ✅ Almost no runtime errors - No deadlocks, livelocks, undefined variables, divide-by-zero, integer under/overflow, array out-of-bounds access, etc;\n  - ⚡️ No GC pauses - Alan’s runtime manages memory allocation, access, and deallocation for you like Java, Python, or Javascript. However, Alan’s static event system and automatic event-oriented memory model does so without garbage collector pauses.\n- [Alain](https://sr.ht/~carlomonte/Alain/) - Symbolic logic/relational programming from first principles : structural types emerge from unification of pervasive list structures (including strings), first-class predicates enable meta-programming without side effects (assert/retract), deterministic OR-parallel search, equality and disequality through variable naming alone.\n- [Albatross](https://albatross-lang.sourceforge.net/) - Albatross is\n  - A Programming Language with Static Verification: You can develop programs and algorithms and prove them to be correct in Albatross. \n  - A Proof Assistant: Arbitrary mathematical theories can be expressed and proved in Albatross\n  - A Theorem Prover: It has a proof engine which supports you significantly in doing proofs. \n- [Alda](https://github.com/alda-lang/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.\n- [Alumina](https://github.com/tibordp/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.\n- [Amiga E](https://strlen.com/amiga-e/) - E is an object-oriented/procedural/unpure functional/whatever language with quite a popular implementation on the amiga. It’s mainly influenced by languages such as C++, Ada, Lisp etc., and features extremely fast compilation, inline assembler, large set of integrated functions, powerful module concept, flexible type-system, quoted expressions, immediate and typed lists, parametric and object polymorphism, exception handling, inheritance, data-hiding, methods, multiple return values, default arguments, register allocation, fast memory management, unification, LISP-Cells, macro-preprocessing, a very powerful source-level debugger, gui-toolkit, library linker, and then some.\n- [AMPL](https://ampl.com/) - AMPL is the most powerful and intuitive tool for developing and deploying complex optimization solutions in business \u0026 scientific applications. AMPL connects to most commercial and open-source solvers and allows you to switch easily between them.\n- [AngelScript](https://sourceforge.net/projects/angelscript/) - AngelScript is an extremely flexible cross-platform scripting library designed to allow applications to extend their functionality through external scripts. It has been designed from the beginning to be an easy to use component.\n- [Ante](https://github.com/jfecher/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.\n- [Antimony](https://github.com/antimony-lang/antimony) - Antimony is a general-purpose toy language. Its primary goal is to be simple and easy to understand, not to be efficient.\n- [Ape](https://github.com/kgabis/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.\n- [Apex](https://apexlang.io/) - Apex is an interface definition language (IDL) for modeling software. Generate source code, documentation, integration, everything automatically.\n- [APL](https://en.wikipedia.org/wiki/APL_(programming_language)) - APL (named after the book A Programming Language) is a programming language developed in the 1960s by Kenneth E. Iverson. Its central datatype is the multidimensional array. It uses a large range of special graphic symbols to represent most functions and operators, leading to very concise code. It has been an important influence on the development of concept modeling, spreadsheets, functional programming, and computer math packages. It has also inspired several other programming languages.\n- [APLX](https://microapl.com/APL/index.html) - is an advanced, second generation implementation of the APL language, closely based on IBM's APL2, but with a number of important enhancements.\n- [April](https://github.com/phantomics/april) - April (Array Programming Re-Imagined in Lisp) - The APL programming language (a subset thereof) compiling to Common Lisp.\n- [Arianna Method Language](https://github.com/ariannamethod/ariannamethod.ai) - A machine learning language for transformers, implemented in C. [AI]\n- [Arend](https://github.com/JetBrains/Arend) - Arend is a theorem prover and a programming language based on Homotopy Type Theory.\n- [Argo](https://github.com/sviperll/argo) - Pragmatic functional programming language.\n- [Argon](https://github.com/argonlang/argon) - Argon is an interpreted multi-paradigm dynamically typed programming language. Its syntax is mainly influenced by Python, Go and Rust.\n- [Aria](https://github.com/egranata/aria) - Aria is a modern, dynamic scripting language. It is meant to be a \"sweet spot\" language, easy to pick-up and enjoyable to use. It comes with a familiar C-style syntax, a feature set inspired by well-beloved languages such as Python and Rust and a focus on getting stuff done. The standard library, while simple, has enough basic features to get you started on interesting problems.\n- [Ark](https://github.com/spargle/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)\n- [Ark](https://github.com/ark-lang/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\n- [ArkScript](https://github.com/ArkScript-lang/Ark) - 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.\n- [Arturo](https://github.com/arturo-lang/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.\n- [ASPL](https://github.com/aspl-lang/aspl) - ASPL is a modern programming language featuring beautiful simplicity, seamless cross-compilation, advanced mobile support, powerful C-interoperability, and so much more. It has been designed to be practical for both beginners and experienced programmers and to help you build better software, quicker.\n- [astro](https://github.com/astrolang/astro) - Astro is a fun programming language designed for safe high-performance applications. It is essentially a statically-typed systems language that\n  - facilitates rapid prototyping,\n  - features high-level abstractions with zero overhead,\n  - ensures memory safety without a (tracing) Garbage Collector, and\n  - supports data-race-free concurrency.\n- [atto](https://github.com/zesterer/atto) - self-hosted functional programming language \n- [atlantis](https://sr.ht/~yieldsfalsehood/atlantis/) - a system programming language and ecosystem\n- [Atom](https://atomvm.sourceforge.net/) - is a programmable, register based virtual machine for Win32 computers. The program is a text-base console application. The VM can be programmed using a neo-assembler language called Atom Assembler. This document discusses the VM and explains each opcode in Atom Assembler.\n- [Atom](https://sr.ht/~spywhere/atom-language/) - A general purpose programming language that easy to use, read and integrated\n- [ATS](https://github.com/githwxi/ATS-Postiats) - 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.\n- [Austral](https://github.com/austral/austral/) - A systems programming language that uses linear types to provide memory safety and capability-secure code. [linear types]\n- [AutoIt v3](https://www.autoitscript.com/site/autoit/) - is a freeware BASIC-like scripting language designed for automating the Windows GUI and general scripting. It uses a combination of simulated keystrokes, mouse movement and window/control manipulation in order to automate tasks in a way not possible or reliable with other languages (e.g. VBScript and SendKeys). AutoIt is also very small, self-contained and will run on all versions of Windows out-of-the-box with no annoying \"runtimes\" required! AutoIt was initially designed for PC \"roll out\" situations to reliably automate and configure thousands of PCs. Over time it has become a powerful language that supports complex expressions, user functions, loops and everything else that veteran scripters would expect.\n- [Aver](https://github.com/jasisz/aver) - A minimal, statically typed functional language for auditable AI-written code. No if/else, no loops, no mutable state — just match, recursion, and explicit effects. Verify blocks and architectural decisions are first-class syntax. Compiles to Rust, exports proofs to Lean 4.\n- [Avail](https://github.com/AvailLang/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.\n- [AWKA](https://awka.sourceforge.net/index.html) - Awka is an open-source implementation of the AWK programming language. Awka is not an interpreter like Gawk, Mawk or Nawk, but instead it converts the program to ANSI-C, then compiles this using gcc or a native C compiler to create a binary executable. This means you must have an ANSI C compiler present on your system for Awka to work.\n- [Axe](https://axelang.org) - Axe is a modern, open source, compiled programming language with builtin parallelism, and no garbage collector. It prioritizes concurrent features as a core language construct, and provides a clean syntax to allow for writing explicit, understandable code.\n\u003ca name=\"B\"\u003e\u003c/a\u003e\n# B (44):\n- [B4X](https://www.b4x.com/) - Simple, powerful and modern development tools. With B4X, anyone who wants to, can develop real-world solutions.\n- [BabyCobol](https://slebok.github.io/baby/) - BabyCobol is a project in language design aimed at creating a language that is, on one hand, small enough to be quickly implementable (fully or partially) within any framework that can support its features, and, on the other hand, complex enough to cover typical problems of legacy language processing. If you learn how to compile MiniJava, you stand a good chance of implementing a reasonably good compiler for any contemporary programming language. If you show how your language extension works on Featherweight Java, it has a good chance of being applicable to any reasonable modern object-oriented programming language. If you can handle BabyCobol with your tool and with your skills, you are ready to face the challenges of software modernisation, codebase migration and legacy language processing in general. At this day and age, being future proof means being able to handle software of the past.\n- [Backlang](https://github.com/Backlang-Org/Backlang) - A new Rust, C# inspired Language for .Net\n- [BAIK](https://sourceforge.net/projects/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.\n- [Bait](https://github.com/tiabeast/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.\n- [Ballerina](https://github.com/ballerina-platform/ballerina-lang) - Ballerina is an open-source programming language for the cloud that makes it easier to use, combine, and create network services.\n- [Barn](https://github.com/barn-lang/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.\n- [Battlestar](https://github.com/xyproto/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.\n- [Bau](https://github.com/thomasmueller/bau-lang) - Bau is a simple, concise, safe, powerful and fast programming language. Features: Easy to learn; Concise syntax; Memory-safe; Statically typed; Fast compilation and execution (transpiles to C).\n- [BCPL](https://www.cl.cam.ac.uk/~mr10/BCPL.html) - BCPL (\"Basic Combined Programming Language\") is a procedural, imperative, and structured programming language. A stripped down and syntactically changed version of BCPL, called B, was the language on which the C programming language was based. BCPL introduced several features of many modern programming languages, including using curly braces to delimit code blocks.\n- [Beads](https://beadslang.org/) - The Beads project is a daring attempt to generate a new language that will replace the current popular toolchain stack of HTML/CSS/JS/+Frameworks+Database, with a single language.\n- [Beanshell](https://github.com/beanshell/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.\n- [Beef](https://github.com/beefytech/Beef) - Beef is a performance-oriented compiled programming language.\n- [Benoit](https://github.com/SanTiepi/benoit) - Benoit is a programming language that transpiles to JavaScript, optimized for human-AI pair programming. It features inline test assertions as first-class syntax, pattern matching with guards and ranges, a pipe operator, and achieves ~68% token reduction versus equivalent JS. Zero dependencies, ~500 lines, MIT licensed. [AI]\n- [Berry](https://github.com/berry-lang/berry) - A ultra-lightweight embedded scripting language optimized for microcontrollers.\n- [Beryl](https://github.com/KarlAndr1/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.\n- [BETA](https://beta.cs.au.dk/) - BETA is a modern language in the Simula tradition. The resulting language is smaller than Simula in spite of being considerably more expressive. BETA is a strongly typed language like Simula, Eiffel and C++, with most type checking being carried out at compile-time. It is well known that it is not possible to obtain all type checking at compile time without sacrificing the expressiveness of the language. BETA has optimum balance between compile-time type checking and run-time type checking.\n- [Bhl](https://github.com/bitdotgames/bhl) - BeHavior Language is a strictly typed programming language specifically tailored for gameplay logic scripting.\n- [Bite](https://github.com/Maximilian-Winter/Bite-Programming-Language) - 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.\n- [BL](https://github.com/travisdoor/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.\n- [Bla](https://strlen.com/bla-language/) - We investigate an (unpure) functional language whose concept of environment is not implicit as in traditional languages, but made available explicitly as a first class value. This results in a semantics for environments that is best known from the object oriented paradigm, and gives us a united function/class concept in a very orthogonal way. We also look at the language as a real-world general purpose language, considering semantics (of type-inference, for example), implementation issues, and practical experience in using the compiler.\n- [Blacklight](http://blog.anthonymcook.com/blacklight/) - blacklight is a general-pupose multithreading concatenative stack-based programming language with first-class queues and objects with delegation.\n- [Blade](https://github.com/blade-lang/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.\n- [Bleach](https://github.com/vmmc2/Bleach) - Bleach: a programming language aimed for teaching introductory 'Compilers' courses.\n- [Blech](https://github.com/boschresearch/blech) - Blech is a language for developing reactive, real-time critical embedded software.\n- [BlitzMax](https://github.com/bmx-ng/bmx-ng) - BlitzMax is a fast cross-platform, open-source programming language.\n- [Blue](https://github.com/BlueTechnologies/Blue) - The Blue Programming Language, A powerful, V E R Y Easy to use language, that can compile to eight of your favourite languages. A compiled, dynamically typed, object oriented programming language. Coming in at only 30 keywords, this is an easy to use language with unseen compiler speed. Blue is extremely powerful thanks to it's small, compact, file size. It was written in only 3200 lines of Haxe code.\n- [Bob](https://github.com/dbetz/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.\n- [Bob2](https://github.com/dbetz/bob2) - Revised version of Bob derived from the Nuon work at VM Labs\n- [Boba](https://github.com/glossopoeia/boba) - A general purpose statically-typed concatenative programming language. Key features include:\n  - Expressive, mostly implicit static types and kinds\n  - Language-incorporated unit and property tests + runners\n  - Algebraic effects via scoped effect handlers\n  - Algebraic data types and pattern matching on constructors\n  - Compile-time resolved function overloading\n  - Structurally typed tuples, records and variants\n  - Byte-code VM-in-Go backend with straight-forward first-order FFI access\n  - Familiar looping, branching, and variable definition syntax constructs\n- [Bolin](https://bolinlang.com/index.html) - A general purpose language that is:\n  - Designed to be readable;\n  - Automatic memory management (no gc, no rc);\n  - Has features not found in any other language (See a few on the highlights page)\n  - Matches C execution speed, occasionally Bolin is faster;\n  - Has a more optimal standard library;\n  - Compiles 2.5 million lines per second on a laptop (MacBook Air with an M2 chip).\n- [Boo](https://github.com/boo-lang/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. \n- [Borealis](https://github.com/Usbac/borealis) - Borealis is a small, elegant and consistent scripting language. Includes a C-like syntax that's easy to implement.\n- [Boron](https://urlan.sourceforge.net/boron/) - Boron is a scripting language similar to REBOL. The interpreter is a C library which may be copied under the terms of the LGPLv3.\n- [Bosque](https://github.com/BosqueLanguage/BosqueCore) - 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 \u0026 assignment-based syntax, and a number of new features designed to simplify and support writing high reliability code.\n- [BQN](https://github.com/mlochbaum/BQN) - An APL-like programming language. Self-hosted!\n- [Bracmat](https://github.com/BartJongejan/Bracmat) - Programming language for symbolic computation with unusual combination of pattern matching features: Tree patterns, associative patterns and expressions embedded in patterns.\n- [Brain](https://brain.sourceforge.net) - Brain is a high-level, purely object-oriented, prototype based scripting language, mostly similar to the Self language.\n- [BRL](https://brl.sourceforge.net) - The Beautiful Report Language. A language designed for server-side WWW-based applications, particularly database applications. It is based on Scheme, which makes the syntax extremely simple yet powerful. This implementation is a Java Servlet using the Kawa Scheme compiler.\n- [Brython](https://github.com/brython-dev/brython) - A Python 3 implementation for client-side web programming.\n- [Bulfinch](https://github.com/munificent/bulfinch) - Just a little toy language to learn about register-based VMs.\n- [Burro](https://sr.ht/~reesmichael1/burro/) - A digital typesetting language\n- [Buzz](https://github.com/buzz-language/buzz) - A small/lightweight statically typed scripting language written in Zig.\n- [β-Juliet](https://github.com/catseye/beta-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?\n\u003ca name=\"C\"\u003e\u003c/a\u003e\n# C (76):\n- [C2](https://github.com/c2lang/c2compiler) - The C2 project attempts to create a new language, strongly based on C. In a nutshell, the main differences with C are:\n  - no more header files (too much typing)\n  - no includes\n  - packages (needed if we can't have includes)\n  - compiled per target (not per file)\n  - more logical keywords (public/local replaces static)\n  - integrated build system\n- [C3](https://github.com/c3lang/c3c) - C3 is a C-like language trying to be \"an incremental improvement over C\" rather than a whole new language.\n- [C3](https://www.c3compiler.com/) - C3 is a xBase language compiler for 16, 32 and 64 bit's. It generates OBJs that may be directly linked to create an executable application for Windows.\n- [CafeOBJ](https://cafeobj.org/) - CafeOBJ is a language for writing formal (i.e. mathematical) specifications of models for wide varieties of software and systems, and verifying properties of them. CafeOBJ implements equational logic by rewriting and can be used as a powerful interactive theorem proving system. Specifiers can write proof scores also in CafeOBJ and doing proofs by executing the proof scores.\n- [Cakelisp](https://github.com/makuto/cakelisp) - A metaprogrammable, hot-reloadable, non-garbage-collected language ideal for high performance, iteratively-developed programs (especially games).\n- [CakeML](https://github.com/CakeML/cakeml) - CakeML is a verified implementation of a significant subset of Standard ML.\n- [Calc4](https://github.com/proprowataya/calc4) - Calc4 is a programming language where everything in its code is an operator.\n- [Calcit](https://github.com/calcit-lang/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.\n- [Camelot](https://groups.inf.ed.ac.uk/mrg/camelot/Gentle-Camelot/camelot-gentle-intro.html) - Camelot is a language of the ML family. It is strict, first-order but allows for use-only higher-order functions. It includes object-oriented extensions, mainly for creating and using objects in an existing class hierarchy. Programmers familiar with ML or Ocaml should have no problems understanding the basic language promitives. `\n- [Cane](https://github.com/Jackojc/cane) - A small MIDI sequencer DSL designed around vectors and euclidean rhythms.\n- [Cant](https://github.com/darius/cant) - a programming language descended mainly from E and Scheme.\n- [Carbon](https://github.com/carbon-language/carbon-lang) - 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.\n- [Carp](https://github.com/carp-lang/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.\n- [Carth](https://sr.ht/~jojo/Carth/) - A Scheme-looking, purely functional programming language\n- [CASL](https://www.caslsoft.com/) - CASL (Compact Application Solution Language) is an easy to use Windows Integrated Development Environment (IDE) that allows you to build applications for the PalmOS®, PocketPC / Windows Mobile and Windows using a single set of code.  You can easily create applications that target multiple operating systems using a high-level programming language (similar to BASIC) that will only take a small investment of your time to learn.  Even if you have never created software before, CASL can help make your idea a reality.  \n- [Cassette](https://github.com/cassette-lang/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.\n- [Castile](https://codeberg.org/catseye/Castile) - A simple imperative language with union types (and a compiler for same, with multiple targets)\n- [Cat](http://web.archive.org/web/20120316200108/http://www.cat-language.com/) - Cat is a functional stack-based programming language inspired by the Joy programming language. The primary differences is that Cat provides a static type system with type inferencing (like ML or Haskell), and a term rewriting macro language extension language called MetaCat. Cat is a high-level intermediate language translation that can also be used as a stand alone language for simple application development. In this way it occupies a similar niche to PostScript. Cat is also an appropriate language for teaching of basic programming concepts. \n- [Cat9](https://github.com/letoram/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.\n- [Cecil](http://projectsweb.cs.washington.edu/research/projects/cecil/www/cecil.html) - Cecil is a purely object-oriented, type-safe, garbage-collected language intended to support rapid construction of high-quality, extensible software.\n- [ChaiScript](https://github.com/ChaiScript/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: \n  - It uses a header-only approach, which makes it easy to integrate with existing projects.\n  - It maintains type safety between your C++ application and the user scripts.\n  - It supports a variety of C++ techniques including callbacks, overloaded functions, class methods, and stl containers.\n- [Chalice](https://www.microsoft.com/en-us/research/project/chalice/?from=https://research.microsoft.com/en-us/projects/chalice/\u0026type=exact) - Chalice is an experimental language that explores specification and verification of concurrency in programs. The language supports dynamic object creation, dynamic thread creation (fork and join), mutual-exclusion and readers-writers locks, monitor invariants, thread pre- and postconditions. The language allows fine-grained locking via specifications that track fractional permissions for memory locations. The research project also includes an automatic static program verifier for Chalice.\n- [Chapel](https://github.com/chapel-lang/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.\n- [Charm](https://github.com/tim-hardcastle/Charm) - Charm is a data-oriented scripting language.\n- [Chibicc](https://github.com/rui314/chibicc) - Chibicc is yet another small C compiler that implements most C11 features. Even though it still probably falls into the \"toy compilers\" category just like other small compilers do, chibicc can compile several real-world programs, including Git, SQLite, libpng and chibicc itself, without making modifications to the compiled programs. Generated executables of these programs pass their corresponding test suites. So, chibicc actually supports a wide variety of C11 features and is able to compile hundreds of thousands of lines of real-world C code correctly.\n- [Ciao](https://github.com/ciao-lang/ciao) - Ciao is a modern Prolog implementation that builds up from a logic-based simple kernel designed to be portable, extensible, and modular.\n- [Cicada](https://github.com/cicada-lang/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.\n- [Circle](https://github.com/seanbaxter/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:\n   - choice types;\n   - pattern matching;\n   - interfaces and impls;\n   - language type erasure;\n   - as-expressions for safer conversions;\n   - a modern declaration syntax with fn and var keywords to make clearer, less ambiguous declarations;\n   - a simpler syntax for binary expressions, greatly reducing the likelihood of bugs caused by confusing operator precedences;\n   - a forward keyword to take the complexity and bugginess out of forwarding references;\n   - safer initializer lists, which address ambiguities when calling `std::initializer_list` constructors and non-`std::initializer_list` constructors;\n   - lifting lambdas to pass overload sets as function arguments;\n   - nine kinds of template parameters to make templates far more comprehensive;\n   - reflection traits to access packs of information about class types, enum types, function types, class specializations, and so on;\n   - pack traits for pack-transforming algorithms, like sort, unique, count, erase, difference, intersection, and so on.\n- [Circom](https://iden3.io/circom) - Circom is a circuit programming language and a compiler that allows programmers to design and create their own arithmetic circuits for ZK proofs.\n- [Cish](https://github.com/TheRealMichaelWang/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.\n- [Citrine](http://citrine-lang.org/) - 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.\n- [CLAIRE4](https://github.com/ycaseau/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.\n- [clio](https://github.com/clio-lang/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.\n- [Clip](https://sourceforge.net/projects/x-clip/) - Clip is CA-Clipper 5.3 compatible compiler for Linux-UNIX and Cygwin with new OO-model, FiveWin and GTK compatible GUI and many other useful features.\n- [CLIPS](https://clipsrules.net/) - Developed at NASA’s Johnson Space Center from 1985 to 1996, the C Language Integrated Production System (CLIPS) is a rule‑based programming language useful for creating expert systems and other programs where a heuristic solution is easier to implement and maintain than an algorithmic solution. Written in C for portability, CLIPS can be installed and used on a wide variety of platforms. Since 1996, CLIPS has been available as public domain software.\n- [Clojure](https://github.com/clojure/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.\n- [clprolf](https://github.com/charleskoffler/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.\n- [Clue](https://github.com/ClueLang/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.\n- [Cmajor](https://github.com/slaakko/cmajorm) - 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++.\n- [Cmajor](https://github.com/SoundStacks/cmajor) - Cmajor is a programming language for writing fast, portable audio software. Cmajor specifically designed for writing DSP signal processing code.\n- [CMOC](http://perso.b2b2c.ca/~sarrazip/dev/cmoc.html) - CMOC is a 6809-generating cross-compiler for a large subset of the C language. It generates assembly language code for the Motorola 6809 processor and targets the Tandy Color Computer, the Dragon computer, the Vectrex video game console, the Thomson MO and TO computers, and the OS-9 and FLEX operating systems. It runs under GNU/Linux and other Unix-like environments like Darwin and Cygwin. It requires the LWTOOLS assembler (lwasm) and linker, by William Astle. \n- [COBOL](https://en.wikipedia.org/wiki/COBOL) - COBOL is a compiled English-like computer programming language designed for business use. It is an imperative, procedural and, since 2002, object-oriented language.\n- [Coconut](https://github.com/evhub/coconut) - Simple, elegant, Pythonic functional programming.\n- [Cod](https://github.com/justlucdewit/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.\n- [Coderive](https://github.com/coderive-lang/Coderive) - Coderive is a modern multiparadigm programming language that tries to make a loop even with a stagerring 1 quintillion range in O(1) by analyzing its structure and converting it into a formula and technically flattening the loop if it doesn't have a side-effect. It has less keyword and have more uniform syntax which is very easy to undertand making the source visually clean to read. It is developed to be both compiled and interpreted with a safe/unsafe feature mode for safety level ensuring you do what you can handle.\n- [Cognate](https://github.com/stavromulabeta/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.\n- [colm](https://github.com/phorward/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\n- [Common Expression Language](https://github.com/google/cel-spec) - The Common Expression Language (CEL) implements common semantics for expression evaluation, enabling different applications to more easily interoperate.\n- [Common Lisp](https://lisp-lang.org/) - A dialect of the Lisp programming language, published in ANSI standard document ANSI INCITS 226-1994. Common Lisp is not an implementation, but rather a language specification. Several implementations of the Common Lisp standard are available, including free and open-source software and proprietary products. Common Lisp is a general-purpose, multi-paradigm programming language. It supports a combination of procedural, functional, and object-oriented programming paradigms.\n- [Compis](https://github.com/rsms/compis) - Contemporary systems programming language in the spirit of C.\n- [Component Pascal](https://en.wikipedia.org/wiki/Component_Pascal) - Component Pascal is a programming language in the tradition of Niklaus Wirth's Pascal, Modula-2, Oberon and Oberon-2. It bears the name of the language Pascal and preserves its heritage, but is incompatible with Pascal. Instead, it is a minor variant and refinement of Oberon-2 with a more expressive type system and built-in string support.\n- [Concurnas](https://concurnas.com/) - Concurnas is an open source JVM programming language designed for building reliable, scalable, high performance concurrent, distributed and parallel systems\n- [Cone](https://github.com/jondgoodwin/cone) - Cone is a fast, fit, friendly, and safe systems programming language. Ideal for complex, data-rich programs requiring responsive performance (e.g., 3D).\n- [Coq](https://github.com/coq/coq) - Coq is a formal proof management system. It provides a formal language to write mathematical definitions, executable algorithms and theorems together with an environment for semi-interactive development of machine-checked proofs.\n- [Core](https://codeberg.org/core-lang/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.\n- [Cotowali](https://github.com/cotowali/cotowali) - A statically typed scripting language that transpile into POSIX sh\n- [Covariant Script](https://github.com/covscript/covscript) - 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\n- [Cowgol](https://github.com/davidgiven/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.\n- [Cppfront](https://github.com/hsutter/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.\n- [Creed](https://mrms.cz/creed/) - A concatenative language for text processing script, inspired by ed and sam\n- [Crema](https://github.com/ainfosec/crema/wiki) - 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\n- [Crow](https://crow-lang.org) -   - Crow programs can be run directly from source.\n  - You can also build your program to a standalone executable. In either case, you don't need a build system.\n  - You can directly call C functions.\n  - Data is garbage collected. Don't worry about what's by-reference or by-value.\n  - Crow is statically typed. There's no subtyping or implicit conversion. There are no null references. Overload resolution is unambiguous.\n  - I/O is controlled. Normal functions can't do I/O except by invoking a lambda from a parameter.\n  - You can launch parallel tasks and get the result as a future.\n  - Mutability is controlled. The type system tracks whether a type allows access to mutable data. This ensures that mutable data is not shared across threads.\n  - Syntax is expression-based. Function bodies are expressions with no return needed.\n  - Even if and for are expressions.\n  - Code is flat. Most declarations are not nested inside of anything.\n  - Expressions are type-checked with an expected type. The same syntax like (1, 2) could be a list, tuple, vector, etc. This saves you from having to write new Foo().\n  - There are discriminated unions, including option types.\n  - There are templates; these are type-checked abstractly, not at each instantiation.\n  - All crow code goes in modules. There are no global declarations.\n- [Crumb](https://github.com/liam-ilan/crumb) - Crumb is a high level, functional, interpreted, dynamically typed, general-purpose programming language, with a terse syntax, and a verbose standard library.\n  It features:\n  - Strictly no side effects* to help you write functional code\n  - The ability to localize the effects of imported Crumb files.\n  - Dynamic typing and garbage collection.\n  - 0 keywords, everything is a function.\n- [Crush](https://github.com/liljencrantz/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.\n- [Crystal](https://github.com/crystal-lang/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.\n- [CSL](https://github.com/lelanthran/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\n- [CSL](http://www.edm2.com/index.php/C_Scripting_Language) - The C Scripting Language (CSL) is a programming language available for Windows, OS/2 and UNIX systems. CSL follows the C syntax very closely. It is used like an interpreter: a program written with an editor can be run directly like any shell script. The CSL scripting engine can be integrated into own applications as a macro language. CSL offers two programming interfaces: A \"C\" API for 32-bit C compilers, and C++ class interface for selected compilers. \n- [Cubiml](https://github.com/Storyyeller/cubiml-demo) - 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).\n- [Curv](http://www.curv3d.org/) - 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.\n- [Cxy](https://github.com/dccarter/cxy) - Cxy is a statically typed programming language that is transpiled to C. Some of the feature supported by Cxy\n  - Reference counting memory manager\n  - Compile time evaluation\n  - Compound types - tuples, unions, structs and classes\n  - Builtin unit testing framework\n  - Exception handling\n  - Standard library\n- [Cyber](https://github.com/fubark/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.\n- [Cyclone](http://cyclone.thelanguage.org/) - 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.\n- [Cylvre](https://cylvre-language.github.io/CylvreHome.html) - Cylvre is a strongly typed, programming language with type inference for the JVM.\n- [cypher](https://neo4j.com/docs/cypher-manual/current/introduction/) - Cypher is Neo4j’s declarative query language, allowing users to unlock the full potential of property graph databases.\n- [Céu](https://github.com/ceu-lang/ceu) - Céu is a reactive language that aims to offer a higher-level and safer alternative to C.\n- [C∀](https://github.com/cforall/cforall) - 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.\n\u003ca name=\"D\"\u003e\u003c/a\u003e\n# D (30):\n- [D](https://github.com/dlang/dmd) - General-purpose programming language with static typing, systems-level access, and C-like syntax.\n- [Dachs](https://github.com/rhysd/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.\n- [Dafny](https://github.com/dafny-lang/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.\n- [Dale](https://github.com/tomhrr/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:\n  - local type deduction;\n  - overloaded functions;\n  - anonymous functions;\n  - reference parameters;\n  - initializers and destructors;\n  - variants;\n  - namespaces;\n  - modules;\n  - concepts; and\n  - compiler introspection.\n- [Dark](https://github.com/darklang/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.\n- [Dark Basic Pro](https://github.com/TheGameCreators/Dark-Basic-Pro) - Dark Basic Pro is an open source BASIC programming language for creating Windows applications and games.\n- [Darklang](https://darklang.com/) - a combined language, editor, and infrastructure to make it easy to build backends and CLIs.\n- [Dart](https://github.com/dart-lang/sdk) - 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.\n- [daScript](https://github.com/GaijinEntertainment/daScript) - high-performance statically strong typed scripting language.\n- [Dashrep](http://www.dashrep.org/) - Dashrep™, the text-manipulation programming language that is powerful and fast, yet simple\n- [Daybreak](https://github.com/ExoKomodo/Daybreak) - Programming language that compiles to C\n- [Derw](https://github.com/eeue56/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.\n- [DeviceScript](https://github.com/microsoft/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]\n- [Dhall](https://dhall-lang.org/) - Dhall is a programmable configuration language that you can think of as: JSON + functions + types + imports\n- [Dialect](https://dialect.sourceforge.net/) - Dialect is an interpreted programming language with GUI, networking, and object oriented capabilities. The Dialect language (a.k.a. Aristar Dialect Pro) source code has been released to the public under an Apache style Open Source license. The source code is available on sourceforge.net directly from the CVS repository and also as a separate zip package file.\n- [Dictu](https://github.com/dictu-lang/Dictu) - Dictu is a high-level dynamically typed, multi-paradigm, interpreted programming language.\n- [Diesel](https://wasp.cs.washington.edu/wasp_diesel.html) - 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.\n- [Dino](https://github.com/dino-lang/dino) - High-Level scripting object-oriented language:\n  - Multi-precision integers\n  - Heterogeneous extensible arrays, array slices\n  - Associative tables with possibility to delete elements\n  - Powerful and safe class composition operation for (multiple) inheritance and traits description\n  - First class functions, classes, and fibers with closures, anonymous functions, classes, fibers\n  - Exception handling\n  - Concurrency\n  - Pattern matching\n  - Unicode 8 support\n- [DML](https://dmlbuild.sourceforge.net/) - DML is a simple templating language designed for managing web sites based in static HTML files (no CGI, SSI, etc.). It has been obsoleted by DML2 which has in turn been obsoleted by XSLT.\n- [DML2](https://dml2.sourceforge.net/) - DML2 is an object-oriented content storage and document formatting framework. Using a fairly simple, object-oriented language and a few templates, generating different types of media from the same source content is made easy. This tool has been obsoleted by XSLT.\n- [Draak](https://draak.sourceforge.net/) - Draak is a Multilanguage Macro compiler. What does that mean? Draak is a compiler that has the ablity to compile any language for any platform by being a generic compiler. It reads in a language description file and uses it to compile a program. It has two parts: parser and macros. The parser replaces Yacc and Lex, and the macros replaces the code generation for traditional compilers.\n- [Draco](https://github.com/Draco-lang/Compiler) - 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).\n- [Dragon](https://dragon-lang.org/) - The Dragon is an innovative and practical general-purpose language. The supported programming paradigms are imperative, object-oriented, declarative using nested structures, functional and natural programming. The language is portable (Windows, Linux, macOS, etc.) and can be used to create Console and GUI. The language is designed to be simple, small, flexible and fast.\n- [Dream Maker](http://www.byond.com/docs/ref/#/DM) - The DM (Dream Maker) language uses a syntax similar to C/C++ to build networked multi-user worlds. This reference and the accompanying guide discuss the structure and function of DM.\n- [Dusa](https://sr.ht/~robsimmons/dusa/) - a logic programming language that has features of both Datalog and answer set programming.\n- [DustyScript](https://dustyscript.sourceforge.net/) - The intent of this project is to write a programming language powerful enough to retain a 8/9-yr old's interest but simple enough... that the syntax can be grasped by them\n- [DWScript](https://github.com/EricGrange/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.\n- [Dyalect](https://github.com/vorov2/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.\n- [Dylan](https://github.com/dylan-lang/opendylan) - 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.\n- [Dyon](https://github.com/PistonDevelopers/dyon) - A rusty dynamically typed scripting language.\n\u003ca name=\"E\"\u003e\u003c/a\u003e\n# E (38):\n- [E](http://www.erights.org/) - E is an object-capability programming language and platform for writing distributed, secure, and robust software.\n- [Easylang](https://github.com/chkas/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.\n- [eC](https://github.com/ecere/ecere-sdk) - 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.\n- [Ecstasy](https://github.com/xtclang/xvm) - 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.\n- [Edina](https://github.com/cerus/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.\n- [Edward2](https://github.com/google/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. \n- [EEL](http://eelang.org/) - EEL is a scripting and programming language, designed specifically for hard real time applications. The primary target areas of application are control engineering and audio synthesis, but EEL should also be suitable for game scripting and for adding scripting capabilities to real time multimedia applications. The syntax is C-like, but the language is higher level than C, and \"safe\" in the sense that EEL programs should not be able to crash the virtual machine or the host application. EEL has dynamic typing, automatic memory management, exception handling and built-in high level data types such as vectors, arrays and tables. New such data types can be added at run time by host applications. EEL compiles into byte-code that runs on a virtual machine, which means that no explicit support for specific architectures is needed for portability. The implementation is deliberately very self contained and has few dependencies, so that it can be easily integrated into \"strange\" environments, such as embedded devices running real time operating systems.\n- [Effekt](https://github.com/effekt-lang/effekt) - A research language with effect handlers and lightweight effect polymorphism.\n- [Egel](https://github.com/egel-lang/egel) - Egel is an untyped concurrent functional scripting language based on eager combinator rewriting with a concise but remarkably powerful syntax.\n- [egison](https://github.com/egison/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.\n- [Eiffel](https://www.eiffel.org/) - Based on a set of principles, including design by contract, command-query separation, the uniform-access principle, the single-choice principle, the open-closed principle, and option-operand separation.\n- [ela ](https://github.com/vorov2/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.\n- [elastiC](http://www.elasticworld.org/) - elastiC is a portable high-level object-oriented interpreted language with a C like syntax.\n- [Electra](https://github.com/DolphyWind/Electra-Lang) - 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]\n- [Elena](https://github.com/ELENA-LANG/elena-lang) - 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.\n- [ELFE](https://github.com/c3d/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. \n- [Elijah](https://sr.ht/~tripleo/el-fluffy-umbrella/) - 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.)\n- [Elixir](https://github.com/elixir-lang/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.\n- [Elle](https://github.com/acquitelol/elle) - Elle is a procedural programming language built in Rust which compiles to the QBE backend. It focuses on simplicity and ease of use.\n- [Elm](https://github.com/elm/compiler/) - Elm is a functional language that compiles to JavaScript. It helps you make websites and web apps. It has a strong emphasis on simplicity and quality tooling.\n- [Elvish](https://github.com/elves/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.\n- [EML](https://homepages.inf.ed.ac.uk/dts/eml/) - Extended ML (EML) is a framework for specification and formal development of Standard ML (SML) programs. EML specifications look just like SML programs except that axioms are allowed in signatures and in place of code in structures and functors. Some EML specifications are executable, since SML function definitions are just axioms of a certain special form. This makes EML a \"wide-spectrum\" language which can be used to express every stage in the development of a SML program from the initial high-level specification to the final program itself and including intermediate stages in which specification and program are intermingled. \n- [EmojiCode](https://github.com/emojicode/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.\n- [emu](https://sourceforge.net/projects/emulang/) - Emu (The EMbeddable Utility Language) is a clean, fast, flexible and free programming language. It is designed to be embedded into other files, such as text documents, web page etc\n- [Enchilada](http://www.enchiladacode.nl/) - Enchilada is optimized to efficiently and consistently share huge amounts of data (and code) in a distributed environment. Possible use cases:\n    - Distributed and authenticated computation/code;\n    - Distributed and authenticated dependency management. \n- [Enterprise](https://github.com/joaomilho/Enterprise) - Enterprise™ is a non-deterministic-unnecessarily-statically-typed™ Turing-complete-ish™, Quantum-out-of-the-box™ programming language.\n- [Eolang](https://github.com/objectionary/eo) - 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.\n- [Erg](https://github.com/erg-lang/erg) - A statically typed language that can deeply improve the Python ecosystem.\n- [ErgoAI](https://flora.sourceforge.net/) - Flora-2  (now ErgoAI) is an advanced object-oriented knowledge representation and reasoning system. It is a dialect of F-logic with numerous extensions, including meta-programming in the style of HiLog, logical updates in the style of Transaction Logic, and defeasible reasoning. Applications include intelligent agents, Semantic Web, knowledge-based networking, ontology management, integration of information, security policy analysis, and more. \n- [Erlang](https://github.com/erlang/otp) - 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.\n- [Eta](https://github.com/typelead/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.\n- [ETAC](https://www.victella.me/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.\n- [etalk](https://github.com/dbetz/etalk) - A Simple Object-Oriented Language\n- [Euphoria](https://github.com/OpenEuphoria/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).\n- [Evlan](https://evlan.org/) - Evlan is a programming language and a virtual machine, similar to Java/JVM or C#/.NET, but with many advantages. While Java and C# are essentially small extensions to the 35-year-old C/C++ software paradigm, Evlan makes a point of being very different.\n- [evolve](https://sites.google.com/site/evolvecoding/) - 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.\n- [execline](http://www.skarnet.org/software/execline/) - execline is a (non-interactive) scripting language, like sh - but its syntax is quite different from a traditional shell syntax. The execlineb program is meant to be used as an interpreter for a text file; the other commands are essentially useful inside an execlineb script. execline is as powerful as a shell: it features conditional loops, getopt-style option handling, filename globbing, and more. Meanwhile, its syntax is far more logical and predictable than the shell's syntax, and has no security issues. \n- [Expr](https://github.com/antonmedv/expr) - Expression language and expression evaluation for Go.\n\u003ca name=\"F\"\u003e\u003c/a\u003e\n# F (62):\n- [F](http://www.nsl.com/k/f/f.htm) - F is a pure functional concatenative language originally designed as an extension of False. F contains the list-operations of K3 and the dip combinator of Joy. Floating-point and symbolic datatypes are supported. One-time assignment is enforced in syntax. A theory of function-valence and -charge is outlined. F also contains a general continuation primitive $, and the pattern sublanguage of XY. G is a variant of F in which the K3 adverbs are implemented as primitives.\n- [F#](https://github.com/dotnet/fsharp) - 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.\n- [F*](https://github.com/FStarLang/FStar) - 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.\n- [Fabric](https://www.cs.cornell.edu/Projects/fabric/) - Fabric is a high-level programming language for building open distributed applications with strong security. Fabric enables securely computing and storing information, and sharing code and data across trust boundaries. It is being developed by the Applied Programming Languages Group at Cornell University.\n- [Factor](https://github.com/factor/factor/) - Factor is a concatenative, stack-based programming language with high-level features including dynamic types, extensible syntax, macros, and garbage collection.\n- [Falcon](https://github.com/falconpl) - Falcon is an Open Source, simple, fast and powerful programming language, easy to learn and to feel comfortable with, and a scripting engine ready to empower mission-critical multithreaded applications. Falcon provides six integrated programming paradigms: procedural, object oriented, prototype oriented, functional, tabular and message oriented. And you don't have to master all of them; you just need to pick the ingredients you prefer, and let the code follow your inspiration.\n- [FALSE](https://strlen.com/false-language/) - I designed this language in ‘93 with two particular objectives: confusing everyone with an obfuscated syntax, and designing an as powerful language as possible with a tiny implementation: in this case a compiler executable of just 1024 bytes (!), written in pure 68000 assembler.\n- [Fantom](https://github.com/fantom-lang/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.\n- [Fanx](https://github.com/fanx-dev/fanx) - Fanx is a full-stack programming language base on Fantom. It is an object oriented and static typing language with elegant libraries.\n- [FAST](https://web.archive.org/web/20040605062546/http://www-lehre.inf.uos.de/~fsuchane/fast.htm) - FAST is a new programming language, which combines the advantages of other programming languages:\n  - FAST supports functions as data types\n  - FAST is fully object-oriented and knows multiple inheritance\n  - FAST has dynamical memory management and garbage collection\n  - FAST includes library units on its own\n  - FAST speaks Assembler\n  - FAST knows macros\n  - FAST has a clear and consequent syntax\n  - FAST compiles within tenths of seconds and creates efficient code\n  - FAST has lots of useful features such as e.g. the prevention of the Division by Zero error\nFAST programs are written as plain text and then sent thru the FAST compiler. Small and efficient code is created and a COM-File results. Up to now, FAST only compiles for MS-DOS (I just have not yet found out how to assemble a binary executable for WINDOWS). \n- [FAST](https://www.microsoft.com/en-us/research/publication/fast-a-transducer-based-language-for-tree-manipulation/?from=https://research.microsoft.com/apps/pubs/default.aspx?id=179252\u0026type=exact) - FAST: A Transducer-Based Language for Tree Manipulation\n- [Faust](https://github.com/grame-cncm/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.\n- [Fay](https://github.com/faylang/fay/wiki) - A proper subset of Haskell that compiles to JavaScript.\n- [fbgc](https://fbgencer.github.io/fbgc/) - Small Language and Calculator in C\n- [FBSL](https://sites.google.com/site/adventuresinfbsl) - Freestyle Basic Script Language (FBSL) is a programming language.\n  - It's powerful.\n  - It's easy to learn.\n  - It can produce GUI or console-based applications.\n  - It can produce standalone executables.\n  - It's free for non-commercial use.\n- [Fe](https://github.com/rxi/fe) - A tiny, embeddable language implemented in ANSI C.\n- [Felix](https://github.com/felix-lang/felix) - An advanced, statically typed, high performance scripting language with native C++ embedding.\n- [Fennel](https://github.com/bakpakin/Fennel) - Fennel is a lisp that compiles to Lua. It aims to be easy to use, expressive, and has almost zero overhead compared to writing Lua directly.\n- [Feral](https://github.com/Feral-Lang/Feral) - Feral is a dynamically typed, imperative, interpreted language which revolves (to most extent) around the idea of minimalism.\n- [ferite](https://ferite.sourceforge.net/) - ferite is a scripting language and engine all in one managable chunk. It is designed to be easily extended in terms of API, and to be used within other applications making them more configurable and useful to the end user. It has a syntax similiar to a number of other langauges but remains clean and it's own language.\n- [ferite](https://ferite.sourceforge.net/about.html) - ferite is a scripting language and engine all in one managable chunk. It is designed to be easily extended in terms of API, and to be used within other applications making them more configurable and useful to the end user. It has a syntax similiar to a number of other langauges but remains clean and it's own language. It's origins are from one of those \"it seems like a good idea\", the good idea was provoked by finding perl a real pain in the arse to embed (from what I gather it's easier nowadays). It started in the summer of 2000 (with various tries and fails within the pre-ceding two years). It is slowly maturing and should be fit for general consumption by the first quarter of 2003, by which point we start to add more exotic features.\n- [FermaT](http://www.gkc.org.uk/fermat.html) - The FermaT Transformation System is a powerful industrial-strength program transformation system based on the WSL language. FermaT has been used sucessfully in several major assembler to C and assembler to COBOL migration projects involving the conversion of millions of lines of hand-written assembler code to efficient and maintainable C or COBOL code. \n- [Fermat](http://home.bway.net/lewis/) - Fermat is a computer algebra system for Macintosh, Windows, Linux, and Unix by me, Robert H. Lewis of Fordham University, that does arithmetic of arbitrarily long integers and fractions, multivariate polynomials, symbolic calculations, matrices over polynomial rings, graphics, and other numerical calculations. It is extremely fast and extremely economical of space. \n- [Ficl](https://ficl.sourceforge.net/) - Ficl is an acronym for \"Forth Inspired Command Language\". Ficl is a programming language interpreter designed to be embedded into other systems as a command, macro, and development prototyping language.\n- [Fig](https://git.sr.ht/~lawson/fig) - a compiled, statically-typed, garbage collected and expressive programming language.\n- [Figaro](https://github.com/charles-river-analytics/figaro) - Figaro is a probabilistic programming language that supports development of very rich probabilistic models and provides reasoning algorithms that can be applied to models to draw useful conclusions from evidence. Both model representation and reasoning algorithm development can be challenging tasks. Figaro makes it possible to express probabilistic models using the power of programming languages, giving the modeler the expressive tools to create a wide variety of models. Figaro comes with a number of built-in reasoning algorithms that can be applied automatically to new models. In addition, Figaro models are data structures in the Scala programming language, which is interoperable with Java, and can be constructed, manipulated, and used directly within any Scala or Java program.\n- [FIJI](https://fiji.sourceforge.net/) - FIJI the ForthIsh Java Interpreter is an interactive environment with a procedural syntax similar to the Forth programming language. FIJI can load, introspect, and execute Java classes and methods. FIJI's main use is for unit and component testing of Java, or for an interpreter in an all-Java environment.\n- [Finch](https://github.com/munificent/finch) - Finch is a simple bytecode interpreted, purely object-oriented, prototype-based, dynamically-typed programming language. It's mostly inspired by Smalltalk, Self, and Javascript.\n- [Finitio](https://github.com/enspirit/finitio) - Finitio is a data language. For now, it is limited to a data definition language (DDL). Think \"JSON/XML schema\", but a slightly different way, that puts the emphasis on precision. Finitio comes with a dedicated type system for defining data and a theory, called information contracts, for interoperability with programming and data exchange languages.\n- [FiveTran](https://github.com/JohnEarnest/Mako/tree/master/tools/Fivetran) - Fivetran, a FORTRAN language targeting Mako. Mako is an extremely simple stack-based virtual machine intended for the creation of video games. \n- [FixScript](https://www.fixscript.org/) - FixScript is an extensible scripting language designed for simple implementation and strong support for both backward and forward compatibility. You can use FixScript both as a standalone and embedded programming language. You can build standalone native executables for any supported platform from every platform. The best results are obtained when combined with the C language to get a very powerful tool. This way you can use the best of the two worlds, using the language for the high-level stuff and C doing the interoperability and fast stuff while having a good integration between both languages.\n- [Flavor](https://flavor.sourceforge.net/) - Flavor (Formal Language for Audio-Visual Object Representation) is an object-oriented media representation language designed for simplifying the development of applications that involve a significant media processing component (encoding, decoding, editing, manipulation, etc.). It provides a formal way for describing any coded audio-visual or general multimedia bitstream, and it comes with a translator that can automatically generate C++/Java code from the Flavor description. The generated code can readily be used as a bitstream parser, generator or tracing tool.\n- [Fleng](http://www.call-with-current-continuation.org/fleng/fleng.html) - 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.\n- [Flix](https://github.com/flix/flix) - Next-generation reliable, safe, concise, and functional-first programming language. Flix is a principled functional, imperative, and logic programming language developed at Aarhus University, at the University of Waterloo, and by a community of open source contributors. Flix is inspired by OCaml and Haskell with ideas from Rust and Scala. Flix looks like Scala, but its type system is based on Hindley-Milner. Two unique features of Flix are its polymorphic effect system and its support for first-class Datalog constraints. Flix compiles JVM bytecode, runs on the Java Virtual Machine, and supports full tail call elimination. A VSCode plugin for Flix is available.\n- [Florid](https://web.archive.org/web/20231003200324/http://dbis.informatik.uni-freiburg.de/index.php?project=Florid) - FLORID (F-LOgic Reasoning In Databases) is a deductive object-oriented database system employing F-Logic as data definition and query language. The development was supported by the Deutsche Forschungsgemeinschaft (project La 598/3-2). With the increasing interest in semistructured data, Florid has been extended for handling semistructured data in the context of Information Integration from the Semantic Web.\n- [Flow](https://github.com/area9innovation/flow9) - a safe, functional strongly-typed programming language.\n- [Floyd](https://github.com/Floydlang/floyd) - Floyd is a general-purpose programming language designed for making very large and robust programs that run really fast, while ducking many of the problems of older languages. Floyd wants to become a better choice than C++, Rust, C#, Python and Javascript for any project.\n- [Flux](https://github.com/influxdata/flux) - Flux is a lightweight scripting language for querying databases (like InfluxDB) and working with data. It's part of InfluxDB 1.7 and 2.0, but can be run independently of those. \n- [Foma](https://code.google.com/archive/p/foma/) - Foma is a compiler, programming language, and C library for constructing finite-state automata and transducers for various uses. It has specific support for many natural language processing applications such as producing morphological analyzers. Although NLP applications are probably the main use of foma, it is sufficiently generic to use for a large number of purposes.\n- [Forest](http://forestproj.org/) - Forest is a domain-specific language for describing filestores.\n- [Formality](https://github.com/moonad/Formality) - Formality is an efficient proof language. An lightweight proof-gramming language. It aims to be:\n  * Fast: no garbage-collection, optimal beta-reduction, massively parallel compilers.\n  * Secure: a powerful type system capable of proving mathematical theorems.\n  * Portable: the entire language desugars to a 500 lines core type-theory.\n- [Formula 2.0](https://www.microsoft.com/en-us/research/project/formula-modeling-foundations/?from=https://research.microsoft.com/en-us/projects/formula/\u0026type=exact) - FORMULA 2.0 is framework for formally specifying domain-specific languages (DSLs) and model transformations. FORMULA specifications are succinct descriptions of DSLs, and specifications can be immediately connected to state-of-the-art analysis engines without additional expertise. FORMULA provides: (1) succinct specifications of DSLs and compilers, (2) efficient compilation and execution of input programs, (3) program synthesis and compiler verification.\n- [Forscape](https://github.com/JohnDTill/Forscape) - Scientific computing language. Forscape solves engineering problems with an unprecedented level of abstraction so you get reliable results quickly. This high-level approach starts with intuitive syntax. Program with the same notation you use to write equations thanks to our innovative math rendering with semantic formatting. Matrices, fractions, symbols- write code using the same notation you use to think through problems on the whiteboard.\n- [Forth](https://forth-standard.org/) - A procedural, stack-oriented programming language and interactive environment. Forth is used in the Open Firmware boot loader, in space applications such as the Philae spacecraft, and in other embedded systems which involve interaction with hardware. Multiple implementaitons, both proprietary and FOSS.\n- [Fortran](https://fortran-lang.org/) - A general-purpose, compiled imperative programming language that is especially suited to numeric computation and scientific computing. It has been in use for over six decades in computationally intensive areas such as numerical weather prediction, finite element analysis, computational fluid dynamics, geophysics, computational physics, crystallography and computational chemistry. It is a popular language for high-performance computing and is used for programs that benchmark and rank the world's fastest supercomputers.\n- [frawk](https://github.com/ezrosent/frawk) - an efficient awk-like language\n- [FreeBASIC](https://github.com/freebasic/fbc) - FreeBASIC is a completely free, open-source, multi-platform BASIC compiler, with syntax similar to MS-QuickBASIC, that adds new features such as pointers, object orientation, unsigned data types, inline assembly, and many others.\n- [FreeOberon](https://github.com/kekcleader/FreeOberon) - Cross-platform IDE for development in Oberon programming language made in the classical FreePascal-like pseudo-graphic style.\n- [FreePascal](https://gitlab.com/freepascal.org/fpc/source) - Free Pascal is a mature, versatile, open source Pascal compiler. It can target many processor architectures: Intel x86 (16 and 32 bit), AMD64/x86-64, PowerPC, PowerPC64, SPARC, SPARC64, ARM, AArch64, MIPS, Motorola 68k, AVR, and the JVM. Supported operating systems include Windows (16/32/64 bit, CE, and native NT), Linux, Mac OS X/iOS/iPhoneSimulator/Darwin, FreeBSD and other BSD flavors, DOS (16 bit, or 32 bit DPMI), OS/2, AIX, Android, Haiku, Nintendo GBA/DS/Wii, AmigaOS, MorphOS, AROS, Atari TOS, and various embedded platforms. Additionally, support for RISC-V (32/64), Xtensa, and Z80 architectures, and for the LLVM compiler infrastructure is available in the development version. Additionally, the Free Pascal team maintains a transpiler for pascal to Javascript called pas2js.\n- [Frege](https://github.com/Frege/frege) - Frege is a Haskell for the JVM. It brings purely functional programing to the Java platform. Like any Haskell, it is purely functional, enjoys a strong static type system with global type inference and non-strict - also known as lazy - evaluation. Frege compiles to Java, runs on the JVM, and uses any Java library you want. It can be used inside any Java project.\n- [Frenetic](https://github.com/frenetic-lang/frenetic) - Frenetic is an open-source Software Defined Network (SDN) controller platform designed to make SDN programming easy, modular, and semantically correct\n- [friend](http://web.archive.org/web/20041128035625/http://sourceforge.net/projects/myfriend/) - 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\n- [Frost](https://www.frostlang.org/) - Frost is a high-level, general-purpose multiparadigm programming language\n- [FScript](https://fscript.sourceforge.net/) - FScript is an extremely simple scripting language. Its intended use is as an embedded language in other Java programs. It is very simple to embed - it can be as simple as sub-classing one class to add your own functionality. However is not a complete programming language, as it has no library of standard functions (such as IO and string processing). FScript supplies a base functionality (such as flow control, variable handling and basic math operations) that can extended by the host application.\n- [Ftwalk](https://ftwalk.sourceforge.net/) - Ftwalk is a general purpose script programming language. It is based on the concepts of Awk, but has been extended to support features such as are found in languages like Perl, Python, and Ruby.\n- [FUN](http://funlang.org/) - FUN is a simple, structured, imperative, dynamic, object-oriented, functional and high-level programming language. FUN was developed by Wisdom ZHANG in 2010 as a scripting language to reuse resources of Pascal. FUN's syntax is simple and clear, it comes from Ada and was changed for easy to use and input. FUN's exception handling syntax is similar to Delphi. FUN is dynamic typing and supports type conversions automatically when needed. FUN supports class-based object-oriented programming. FUN supports first-class functions functional programming, looks like Lisp and Javascript. FUN implements a simple and lightweight reference counting garbage collector. FUN's regular expressions handling is Perl-Compatible. FUN provides simple and powerful list process, it looks like arrays, associative arrays, hash tables, dictionaries or mappings too.\n- [Funnel](https://lampwww.epfl.ch/funnel/) - Funnel is a programming language based on Functional Nets. Functional Nets combine key ideas of functional programming and Petri nets to yield a simple and general programming notation. They have their theoretical foundation in Join calculus. \n- [Fusion](https://github.com/fusionlanguage/fut) - Fusion is a programming language which can be translated automatically to C, C++, C#, D, Java, JavaScript, Python, Swift, TypeScript and OpenCL C. Instead of writing code in all these languages, you can write it once in Fusion. [Transpiler]\n- [Futhark](https://github.com/diku-dk/futhark) - High-performance purely functional data-parallel array programming on the GPU. Futhark is a small programming lan","projects_url":"https://awesome.ecosyste.ms/api/v1/lists/chessmax%2Fawesome-programming-languages/projects"}