Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/learn-anything/programming-languages

Awesome Programming Languages
https://github.com/learn-anything/programming-languages

List: programming-languages

awesome awesome-list curated-list learning programming-languages

Last synced: about 1 month ago
JSON representation

Awesome Programming Languages

Awesome Lists containing this project

README 

        
# Programming languages [![Lists](https://img.shields.io/badge/-more%20lists-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://github.com/learn-anything/curated-lists)



_Please read [contribution guidelines](contributing.md) before contributing._



- [Functional](#functional)

- [Lisp](#lisp)

- [Object-Oriented](#object-oriented)

- [Explicit logical parallelism](#explicit-logical-parallelism)

- [Multi paradigm](#multi-paradigm)

- [Funny](#funny)

- [Other](#other)

- [Related](#related)



## Functional



- [Accelerate](https://github.com/AccelerateHS/accelerate) - Embedded language for high-performance array computations.

- [Agda](https://github.com/agda/agda) - Dependently typed functional language.

- [Alice ML](https://github.com/aliceml/aliceml) - Functional programming language based on Standard ML, extended with support for concurrent, distributed, and constraint programming.

- [Amulet](https://github.com/amuletml/amulet) - ML-like functional programming language.

- [Amulet](https://github.com/tmpim/amulet) - Simple functional programming language in the ML tradition, with support for higher-rank parametric polymorphic types and row-polymorphic records, pattern matching with algebraic data types, and tail recursion elimination.

- [Atto](https://github.com/zesterer/atto) - Insanely simple self-hosted functional programming language.

- [Beluga](https://github.com/Beluga-lang/Beluga) - Functional programming language designed for reasoning about formal systems.

- [Bosatsu](https://github.com/johnynek/bosatsu) - Python-ish pure and total functional programming language.

- [Braid](https://github.com/joshsharp/braid) - Functional language with Reason-like syntax that compiles to Go.

- [Bright ML](https://github.com/elpinal/bright-ml) - Statically-typed programming language based on "F-ing modules".

- [Calypso](https://github.com/calypso-lang/calypso) - Mostly imperative language with some functional influences that is focused on flexibility and simplicity.

- [Clio](https://github.com/clio-lang/clio) - Functional, parallel, distributed programming language. ([Web](https://clio-lang.org/))

- [cur](https://github.com/wilbowma/cur) - Powerful meta-programming for powerful types.

- [Derw](https://github.com/eeue56/derw) - Elm-inspired language that transpiles to TypeScript.

- [Discus](https://github.com/discus-lang/ddc) - Experimental dialect of Haskell which investigates static typing and program transformation in the presence of computational effects.

- [Ditto](https://github.com/ditto-lang/ditto) - Functional, statically typed, and pure.

- [Dynasty](https://github.com/aionescu/dynasty) - Interpreted, dynamically-typed, lazily evaluated, purely functional programming language.

- [Eff](http://www.eff-lang.org/) - Functional language with handlers of not only exceptions, but also of other computational effects such as state or I/O.

- [Effekt](https://github.com/effekt-lang/effekt) - Research language with effect handlers and lightweight effect polymorphism. ([Web](https://effekt-lang.org/))

- [Enki](https://github.com/ReedOei/Enki) - Intended to be a logic language for teaching programming to people with no programming experience.

- [Eta](https://github.com/typelead/eta) - Dialect of Haskell on the JVM.

- [Eve](https://github.com/witheve/Eve) - Programming language based on years of research into building a human-first programming platform.

- [Expresso](https://github.com/willtim/Expresso) - Simple expressions language with polymorphic extensible row types. ([HN](https://news.ycombinator.com/item?id=23501981))

- [F\*](https://fstar-lang.org/#introduction) - General-purpose functional programming language with effects aimed at program verification.

- [F#](https://github.com/dotnet/fsharp) - Open-source, cross-platform functional programming language for .NET.

- [Facet](https://github.com/facet-lang/facet) - Call-by-value functional language with algebraic effects, quantitative type theory, and staging.

- [Fika](https://github.com/fika-lang/fika) - Statically typed functional programming language for the web.

- [Flix](https://github.com/flix/flix) - Statically typed functional- and logic programming language inspired by Scala, OCaml, F#, Haskell, and Datalog. ([Web](https://flix.dev/))

- [Functa](https://github.com/dragostis/Functa) - Flexible, fully functional dynamic programming language.

- [Futhark](https://github.com/diku-dk/futhark) - Purely functional data-parallel programming language. Its optimising compiler is able to compile it to typically very performant GPU code.

- [Gluon](https://github.com/gluon-lang/gluon) - Static, type inferred and embeddable language written in Rust.

- [Grace](https://github.com/Gabriel439/grace) - Ready-to-fork interpreted, typed, and functional language.

- [Granule](https://github.com/granule-project/granule) - Statically typed functional language with graded modal types for fine-grained program reasoning via types.

- [Haskell](https://www.haskell.org/) - Advanced, purely functional programming language.

- [Hemlock](https://github.com/BranchTaken/Hemlock) - Synthesizes the expressive type and module systems of ML-family languages, a unified parametric effects/mutability/type system, and the shared-nothing message-passing parallelism of Erlang.

- [Ink](https://github.com/thesephist/ink) - Minimal programming language inspired by modern JavaScript and Go, with functional style. ([Ink By Example](https://inkbyexample.com/))

- [Keli](https://github.com/KeliLanguage/compiler) ([Motivations](https://keli-language.gitbook.io/doc/)) ([HN](https://news.ycombinator.com/item?id=24331635))

- [Ko](https://github.com/kocircuit/kocircuit) - Generic type-safe language for concurrent, stateful, deadlock-free systems and protocol manipulations.

- [Koka](https://github.com/koka-lang/koka) - Function-oriented language with effect inference.

- [Labrys](https://github.com/kit-ty-kate/labrys) - Toy language based on LLVM that implements the System Fω type-system.

- [lambda-ski](https://github.com/thma/lambda-ski) - Small functional language with a combinator based graph-reduction machine.

- [Lasca](https://github.com/nau) - LLVM-based statically or dynamically typed strict functional programming language. Simplified OCaml if you will.

- [Lawvere](https://github.com/jameshaydon/lawvere) - Categorical programming language with effects.

- [Leo](https://github.com/AleoHQ/leo) - Functional, statically-typed programming language built for writing private applications.

- [LinearML](https://github.com/pikatchu/LinearML) - Functional language for parallel programming.

- [lviv](https://github.com/kwantam/lviv) - Stack-based RPN functional programming language. Written in Scheme.

- [Mlatu](https://github.com/brightly-salty/mlatu) - Statically typed, stack-based purely functional programming language designed for simplicity, speed, and safety.

- [morloc](https://github.com/morloc-project/morloc) - Typed, polyglot, functional language.

- [Nazo ML](https://github.com/cannorin/nml) - Experimental implementation of temporal-logic-based Hindley-Milner type system.

- [Neut](https://github.com/u2zv1wx/neut) - Dependently-typed programming language based on the Calculus of Constructions. ([HN](https://news.ycombinator.com/item?id=23283880))

- [Never](https://github.com/never-lang/never) - Statically typed, embedded functional programming language.

- [OCaml](https://ocaml.org/) - Industrial strength language supporting functional, imperative and object-oriented styles.

- [Pikelet](https://github.com/pikelet-lang/pikelet) - Small, functional, dependently typed programming language.

- [Salt](https://github.com/discus-lang/salt) - Compilation target that functional programmers always wanted.

- [Silt](https://github.com/silt-lang/silt) - An in-progress fast, dependently typed, functional programming language implemented in Swift.

- [Sixten](https://github.com/ollef/sixten) - Experimental functional language where all data is unboxed by default. Functional programming with fewer indirections.

- [Spiral](https://github.com/mrakgr/The-Spiral-Language) - Functional language with intensional polymorphism and first-class staging.

- [TAMGU](https://github.com/naver/tamgu) - FIL programming language: Functional, Imperative, Logical all in one for annotation and data augmentation.

- [Tao](https://github.com/zesterer/tao) - Statically-typed functional programming language.

- [TiML](http://adam.chlipala.net/papers/TimlOOPSLA17/) - Functional Language for Practical Complexity Analysis with Invariants.

- [TopShell](https://github.com/topshell-language/topshell) - Purely functional, reactive scripting language.

- [Tyrade](https://github.com/willcrichton/tyrade) - Pure functional language for type-level programming in Rust.

- [Unison](https://github.com/unisonweb/unison) - Modern, statically-typed purely functional language, similar to Haskell, but with a unique ability to describe entire distributed systems with a single program.

- [Unlambda](http://www.madore.org/~david/programs/unlambda/) - Minimal, "nearly pure" functional programming language invented by David Madore. Based on combinatory logic. ([Wiki](https://en.wikipedia.org/wiki/Unlambda))

- [Ur/Web](https://github.com/urweb/urweb) - Implementation of a domain-specific functional programming language for web applications.

- [Verve](https://github.com/tadeuzagallo/verve-lang) - Functional language for the working hacker.

- [Yeti](https://github.com/mth/yeti) - ML-like functional language for the JVM. ([Web](http://mth.github.io/yeti/))

- [Zilch](https://github.com/zilch-lang/zilch) - Statically-typed, low-level, functional programming language with some focus on runtime performance.



## Lisp



- [Carp](https://github.com/carp-lang/Carp) - Statically typed lisp, without a GC, for real-time applications. ([Snippets](https://github.com/carpentry-org/snippets))

- [Clojure](https://github.com/JeffBezanson/femtolisp) - Dynamic, general-purpose, combining the approachability and interactive development of a scripting language with an efficient and robust infrastructure for multithreaded programming.

- [Common Lisp](https://lisp-lang.org/) - Modern, multi-paradigm, high-performance, compiled, ANSI-standardized, most prominent (along with Scheme) descendant of the long-running family of Lisp programming languages.

- [Emacs Lisp](https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html) - dialect of the Lisp programming language used as a scripting language by Emacs with some later influence from Common Lisp. Created by GNU it supports imperative and functional programming methods.

- [femtolisp](https://github.com/JeffBezanson/femtolisp) - Lightweight, robust, scheme-like lisp implementation.

- [Fennel](https://github.com/bakpakin/Fennel) - Lua Lisp Language.

- [Hime](https://github.com/hime-lang/Hime) - A general programming language running on the JVM platform.

- [Janet](https://github.com/janet-lang/janet) - Functional and imperative programming language and bytecode interpreter.

- [Ketos](https://github.com/murarth/ketos) - Lisp dialect scripting and extension language for Rust programs. ([HN](https://news.ycombinator.com/item?id=28616475))

- [Liz](https://github.com/dundalek/liz) - Lisp-flavored general-purpose programming language (based on Zig).

- [llrl](https://github.com/yubrot/llrl) - Lisp-like programming language powered by Rust + LLVM.

- [Lux](https://github.com/LuxLang/lux) - Functional, statically-typed Lisp that will run on several platforms, such as the Java Virtual Machine and JavaScript interpreters.

- [PicoLisp](https://picolisp.com/wiki/) - Simple and lightweight and encourages clean, concise code.

- [Ren](https://github.com/ren-lang/compiler) - Cleaner, clearer JavaScript. Modern scripting language for the Web.

- [Urn](https://urn-lang.com/) - Lisp implementation for Lua. ([Code](https://github.com/SquidDev/urn)) ([Lobsters](https://lobste.rs/s/qzubyo/urn_lisp_implementation_for_lua))



## Object-Oriented



- [Inko](https://github.com/YorickPeterse/inko) - Statically-typed, safe, object-oriented programming languages for writing concurrent programs.

- [Pharo](https://github.com/pharo-project/pharo) - A pure object-oriented programming language and a powerful environment derived from Squeak Smalltalk.

- [Smalltalk-72](https://smalltalkzoo.thechm.org/HOPL-St72.html) - A pure message-oriented programming language and its environment implemented in '72 to test Alan Kay's idea of "programming by messaging".



## Explicit logical parallelism



- [Ceu](https://github.com/ceu-lang/ceu) - Reactive language that aims to offer a higher-level and safer alternative to C. ([Web](http://www.ceu-lang.org/))

- [Estérel](https://en.wikipedia.org/wiki/Esterel) - Synchronous reactive language that allows simple expression of parallelism and preemption and is based on logical instants and zero time hypothesis. ([Web](http://www-sop.inria.fr/meije/esterel/esterel-eng.html))

- [FuncSug](https://github.com/cl4cnam/funcSug) - Language for GUI programming that allows program codes to follow the same order as the scenario.

- [Pendulum](https://github.com/remyzorg/pendulum) - Synchronous reactive language (OCaml extension) to program reactive systems on the Web.

- [Reactive ML](https://github.com/reactiveml/rml) - Synchronous reactive language that combines the temporal expressiveness of synchronous languages with the power of functional programming.([Web](https://reactiveml.org/))

- [SugarCubes](https://github.com/LordManta/SugarCubesJS) - Synchronous (à la Boussinot) reactive language that allows to write reactive parallel/concurrent programs on top of sequential JavaScript.



## Multi paradigm



- [Ada](https://ada-lang.io/) - General-purpose, strongly typed, performant, readable and safe language.

- [Ante](https://antelang.org/) - Low-level functional language for exploring refinement types, lifetime inference, and other fun features. ([Code](https://github.com/jfecher/ante)) ([HN](https://news.ycombinator.com/item?id=31775216)) ([Lobsters](https://lobste.rs/s/02tu4z/ante_low_level_functional_language))

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

- [Chaos](https://github.com/chaos-lang/chaos) - Strongly typed, dynamic yet compilable, test-oriented procedural programming language that achieves zero cyclomatic complexity. ([HN](https://news.ycombinator.com/item?id=22940265))

- [D](https://dlang.org/) - General-purpose programming language with static typing, systems-level access, and C-like syntax.

- [Go](https://github.com/golang/go) - Compiled, statically typed in the tradition of Algol and C, with garbage collection, limited structural typing, memory safety features and CSP-style concurrent programming features added.

- [Haxe](https://github.com/HaxeFoundation/haxe) - High-level and strictly-typed, cross-compiles to many different targets.

- [JavaScript](http://en.wikipedia.org/wiki/JavaScript) - High-level, dynamic, weakly typed, prototype-based, multi-paradigm, and interpreted.

- [Julia](https://github.com/JuliaLang/julia) - High-level, high-performance dynamic language for technical computing.

- [Nim](https://github.com/nim-lang/nim) - Both high-level and systems-level language, with productivity of Python, performance of C and meta-programming of Lisp.

- [Objective C](http://en.wikipedia.org/wiki/Objective-C) - General-purpose and object-oriented, adds Smalltalk-style messaging to the C programming language.

- [Python](https://github.com/python/cpython) - Interpreted high-level language for general-purpose programming.

- [Ring](https://github.com/ring-lang/ring) - Innovative and practical general-purpose multi-paradigm language.

- [Swift](https://github.com/apple/swift) - General-purpose, multi-paradigm, compiled programming language.

- [TypeScript](https://github.com/Microsoft/TypeScript) - Strict syntactical superset of JavaScript that adds optional static typing to the language.



## Funny



- [ArnoldC](https://github.com/lhartikk/ArnoldC) - Programming language based on the one-liners of Arnold Schwarzenegger.

- [C-plus-Equality](https://github.com/ErisBlastar/cplusequality) - Feminist programming language.

- [dogescript](https://github.com/dogescript/dogescript) - Wow so syntax very doge much future.



## Other



- [ABS](https://github.com/abs-lang/abs) - Programming language that works best when you're scripting on your terminal.

- [Acton](https://github.com/actonlang/acton) - Compiled language, offering the speed of C but with a considerably simpler programming model.

- [Alan](https://github.com/alantech/alan) - Programming language that does concurrency for you and can thus separate how the software is written from how it runs.

- [Antimony](https://github.com/antimony-lang/antimony) - Language that gets out of your way. ([Docs](https://antimony-lang.github.io/antimony/))

- [Arturo](https://github.com/arturo-lang/arturo) - Simple, modern and powerful interpreted programming language for efficient scripting. ([Web](http://arturo-lang.io/))

- [Astro](https://github.com/astrolang/astro) - Fun safe language for rapid prototyping and high performance applications.

- [Austral](https://github.com/austral/austral) - Systems language with linear types.

- [Bagel](https://github.com/brundonsmith/bagel) - Statically typed, reactive language with pure and impure functions. ([Article](https://www.brandons.me/blog/the-bagel-language))

- [Ballerina](https://github.com/ballerina-platform/ballerina-lang) - Open-source programming language for the cloud that makes it easier to use, combine, and create network services. ([Web](https://ballerina.io/))

- [Basil](https://github.com/basilTeam/basil) - Fast and flexible language exploring partial evaluation, context-sensitive parsing, and metaprogramming. Compiles JIT or AOT to native code.

- [Beef](https://github.com/beefytech/Beef) - Open source performance-oriented compiled programming language which has been built hand-in-hand with its IDE environment.

- [BIPLAN](https://github.com/gioblu/BIPLAN) - Byte coded Interpreted Programming language.

- [BlazeX](https://github.com/BlazifyOrg/blazex) - AOT compiled object oriented programming language.

- [Bog](https://github.com/Vexu/bog) - Small, strongly typed, embeddable language. Written in Zig.

- [Bolt](https://github.com/mukul-rathi/bolt) - Research language with finer-grained concurrency than Rust. ([HN](https://news.ycombinator.com/item?id=23122973))

- [Boson](https://github.com/Narasimha1997/boson-lang) - Hybrid programming language written in Rust.

- [Bosque](https://github.com/Microsoft/BosqueLanguage) - Experiment in regularized design for a machine assisted rapid and reliable software development lifecycle. ([HN](https://news.ycombinator.com/item?id=23175280))

- [Butter](https://github.com/neverRare/butter) - Aims to be a concise and friendly language for building efficient software.

- [buzz](https://github.com/giann/buzz) - Small/lightweight typed scripting language written in Zig.

- [Cairo](https://github.com/starkware-libs/cairo-lang) - Programming language for writing provable programs. ([Web](https://www.cairo-lang.org/))

- [Caledon](https://github.com/mmirman/caledon) - Dependently typed, polymorphic, higher order logic programming language.

- [Cane](https://github.com/Jackojc/cane) - A small vector language designed for making beats with realtime MIDI.

- [Cant](https://github.com/darius/cant) - Programming language descended mainly from E and Scheme.

- [Charity](http://pll.cpsc.ucalgary.ca/charity1/www/home.html) - Categorical programming language. ([Code](https://github.com/mietek/charity-lang))

- [Ć](https://github.com/pfusik/cito) - Language which can be translated automatically to C, C++, C#, Java, JavaScript, Python, Swift, TypeScript and OpenCL C. ([HN](https://news.ycombinator.com/item?id=28805825))

- [Ciao](https://github.com/ciao-lang/ciao) - Programming language that builds up from a logic-based simple kernel, and is designed to be extensible and modular.

- [Clay](https://github.com/jckarter/clay) - Programming language designed for Generic Programming.

- [CLU](https://codelani.com/languages/clu.html) - Programming language created at MIT.

- [Cognate](https://github.com/stavromulabeta/cognate) - Quasi-concatenative stack language that uses embedded comments to read like English prose.

- [Compose](https://github.com/samskivert/compose) - Experimental programming language. It aims to be teachable, scalable, modern, powerful & precise.

- [Concurnas](https://concurnas.com/) - Open source JVM programming language designed for building reliable, scalable, high performance concurrent, distributed and parallel systems. ([HN](https://news.ycombinator.com/item?id=23321096))

- [Cone](https://github.com/jondgoodwin/cone) - Fast, fit, friendly, and safe systems programming language. ([Web](https://cone.jondgoodwin.com/))

- [Copper](https://tibleiz.net/copper/index.html) - Experimental programming language that can be used as a replacement to C and C++.

- [Cotowali](https://github.com/cotowali/cotowali) - Statically typed scripting language that transpile into POSIX sh.

- [Crunch](https://github.com/Kixiron/crunch-lang) - Strongly & statically typed systems level language focused on ease of use, portability and speed.

- [CUP](https://github.com/mustafaquraish/cup) - Simple, C-like programming language.

- [DaCE](https://github.com/spcl/dace) - Data-Centric Parallel Programming.

- [daScript](https://dascript.org/) - High-performance statically strong typed scripting language. ([HN](https://news.ycombinator.com/item?id=24166505))

- [Dictu](https://github.com/dictu-lang/Dictu) - High-level dynamically typed, multi-paradigm, interpreted programming language. ([Docs](https://dictu-lang.com/))

- [Dip](http://www.dip-lang.org/) - Dynamically typed interpreted programming language written in Python, which gives emphasis to readability and ease of use, while also providing the power of all of python’s libraries. ([Code](https://github.com/raghavnautiyal/Dip))

- [Disco](https://github.com/disco-lang/disco) - Functional teaching language for use in a discrete mathematics course.

- [Ditto](https://github.com/ditto/ditto) - Super Kawaii Dependently Typed Programming Language.

- [Dora](https://github.com/dinfuehr/dora) - JIT-compiler for the programming language Dora implemented in Rust.

- [Egison](https://www.egison.org/) - Programming language that features extensible efficient non-linear pattern matching with backtracking for non-free data types. ([Code](https://github.com/egison/egison))

- [Ein](https://github.com/ein-lang/ein) - Functional programming language for scalable development.

- [Ella](https://github.com/lukechu10/ellalang) - Computer programming language interpreter written in Rust.

- [Elsa](https://github.com/elsaland/elsa) - Minimal, fast and secure QuickJS wrapper written in Go. ([HN](https://news.ycombinator.com/item?id=24626655))

- [Emojicode](https://www.emojicode.org/) - Open-source, full-blown programming language consisting of emojis. ([Code](https://github.com/emojicode/emojicode))

- [Enso](https://github.com/enso-org/ide) - Visual and textual functional programming language.

- [EO](https://github.com/cqfn/eo) - Experimental Object-Oriented Programming Language Based on 𝜑-Calculus. ([HN](https://news.ycombinator.com/item?id=28423328))

- [FaCT](https://github.com/PLSysSec/FaCT) - Flexible and Constant Time Programming Language.

- [Factor](https://factorcode.org/) - Practical stack language. ([Lobsters](https://lobste.rs/s/sv9jw7/factor_programming_language))

- [fe](https://github.com/rxi/fe) - Tiny, embeddable language implemented in ANSI C. ([HN](https://news.ycombinator.com/item?id=22785137))

- [Felix](https://github.com/felix-lang/felix) - Advanced, statically typed, high performance scripting language with native C++ embedding.

- [F--](https://github.com/raviqqe/fmm) - Uncurried minimal functional programming language.

- [Flax](https://github.com/flax-lang/flax) - Level, general-purpose language with high level syntax and expressibility.

- [Foolang](https://github.com/nikodemus/foolang) - Smalltalk-inspired language. ([Web](https://foolang.org/#/))

- [Fractran](https://en.wikipedia.org/wiki/FRACTRAN) - Turing-complete esoteric programming language invented by the mathematician John Conway. ([Notes](https://wiki.xxiivv.com/site/fractran.html)) ([Fractran Interpreter](https://merveilles.town/web/statuses/105357795783765822))

- [Ghost](https://github.com/ghost-language/ghost) - Small, class-based scripting language. ([Web](https://ghostlang.org/))

- [GLICOL](https://github.com/chaosprint/glicol) - Graph-oriented live coding language written in Rust. Make music with code. ([Web](https://glicol.org/))

- [Gosu](https://gosu-lang.github.io/) - Pragmatic language for the JVM. ([Code](https://github.com/gosu-lang/gosu-lang))

- [Gravity](https://marcobambini.github.io/gravity/#/) - Embeddable programming language. ([Code](https://github.com/marcobambini/gravity)) ([HN](https://news.ycombinator.com/item?id=23467289))

- [Gwion](https://github.com/Gwion/Gwion) - Strongly-timed language aimed at music creation. Heavily inspired by ChucK.

- [Hamler](https://www.hamler-lang.org/) - Haskell-style functional programming language running on Erlang VM. ([Code](https://github.com/hamler-lang/hamler)) ([Article](https://www.emqx.io/news/open-source-functional-programming-language-hamler))

- [Hare](https://harelang.org/) - Systems programming language designed to be simple, stable, and robust. ([Code](https://sr.ht/~sircmpwn/hare/))

- [Hascal](https://github.com/hascal/hascal) - General purpose and open source programming language designed to build optimal, maintainable, reliable and efficient software.

- [Hazure](https://github.com/azur1s/hazure) - ML-Inspired programming language that transpiles to Typescript.

- [Hedy](https://github.com/Felienne/hedy) - Gradual programming language, which increases in syntactic elements level by level. ([Web](https://www.hedycode.com/))

- [Hexagony](https://esolangs.org/wiki/Hexagony) - Two-dimensional stack-based programming language. ([Hexagony IDE](https://hexagony.net/))

- [Hook](https://github.com/hook-lang/hook) - Cross-platform scripting language with a C-like syntax, dynamic typing, mutable value semantics approach, and memory management through reference counting.

- [Horse64](https://github.com/horse64/core.horse64.org) - Simple & versatile high-level programming language. ([Web](https://horse64.org/))

- [Hugorm](https://github.com/nilq/hugorm) - Mission-critical scripting language.

- [Husky](https://github.com/ancient-software/husky) - Programming language designed for many difficult tasks which haven't yet been seen as programmable at all.

- [\_hyperscript](https://github.com/bigskysoftware/_hyperscript) - Small scripting language for the web.

- [Icon](https://www2.cs.arizona.edu/icon/ftp/doc/lb1up.pdf) - Programming language with a focus on string manipulation. ([Lobsters](https://lobste.rs/s/qendox/icon_programming_language))

- [Inko](https://gitlab.com/inko-lang/inko) - Statically-typed, safe, object-oriented programming language for writing concurrent programs.

- [IntercalScript](https://github.com/Storyyeller/IntercalScript) - Systems programming language for the web that combines a simple and consistent syntax with a static type system that completely eliminates runtime type errors.

- [io](https://github.com/IoLanguage/io) - Programming language. Inspired by Self, Smalltalk and LISP. ([Web](https://iolanguage.org/))

- [Jai](https://github.com/BSVino/JaiPrimer/blob/master/JaiPrimer.md) - High-level programming language developed by Jonathan Blow.

- [jakt](https://github.com/awesomekling/jakt) - Memory-safe systems programming language. Currently transpiles to C++.

- [Kara](https://github.com/1whatleytay/kara) - Statically typed, LLVM-based programming language. It's designed to be fast and easy to use.

- [Kara](https://github.com/MaxDesiatov/Kara) - Experimental programming language inspired by Swift and Idris.

- [Kempe](https://github.com/vmchale/kempe) - Compiled stack-based language.

- [Kernel](https://web.cs.wpi.edu/~jshutt/kernel.html) - Conservative, Scheme-like dialect of Lisp in which everything is a first-class object.

- [Kinx](https://github.com/Kray-G/kinx) - Looks like JavaScript, feels like Ruby, and it is the script language fitting in C programmers.

- [Kitten](http://kittenlang.org/) - Statically typed, stack-based functional programming language designed to be simple and fast. ([Code](https://github.com/evincarofautumn/kitten/))

- [Koto](https://github.com/koto-lang/koto) - Embeddable scripting language, written in Rust.

- [Kuljet](https://kuljet.com/) - Language for writing database-backed HTML applications. ([Code](https://github.com/KMahoney/kuljet))

- [L2](https://github.com/murisi/L2) - Minimalist type-inferred programming language with procedural macro support.

- [Lama](https://github.com/JetBrains-Research/Lama) - Programming language developed by JetBrains Research for educational purposes as an exemplary language to introduce the domain of programming languages, compilers and tools.

- [Lia](https://github.com/willcrichton/lia) - High-Level Language for Rust.

- [liblg](https://github.com/codr7/liblg) - Minimal stack-based VM. ([HN](https://news.ycombinator.com/item?id=24388687))

- [Lobster](http://strlen.com/lobster/) - General purpose stand-alone programming language that comes with a built-in library suitable for making games and other graphical things.

- [LoLa](https://github.com/MasterQ32/LoLa) - Small programming language meant to be embedded into games. ([Web](https://lola.random-projects.net/))

- [Lore](https://github.com/marcopennekamp/lore) - General-purpose programming language featuring multi-functions, structs and traits, structural typing enabling component-based programming, and intersection and semantic types.

- [Luau](https://roblox.github.io/luau/) - Fast, small, safe, gradually typed embeddable scripting language derived from Lua. ([FAQ](https://gist.github.com/zeux/bb646a63c02ff2828117092036d2d174)) ([HN](https://news.ycombinator.com/item?id=24059432))

- [Luf](https://github.com/Luukdegram/luf) - Statically typed, embeddable, scripting language written in Zig.

- [Luna](https://luna-lang.org/) - Data processing and visualization environment.

- [Lush](http://lush.sourceforge.net/) - Object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications.

- [Luster](https://github.com/kyren/luster) - Experimental Lua VM implemented in pure Rust.

- [Luxury](https://github.com/strawberryhacker/luxury) - Statically programming language which is targeting embedded programming.

- [Lys](https://github.com/lys-lang/lys) - Language that compiles to WebAssembly.

- [Makam](https://github.com/astampoulis/makam) - Tool for rapid language prototyping.

- [Makeshift](https://github.com/MasterQ32/makeshift) - Programming language that was designed to bootstrap the Ashet Home Computer.

- [Manticore](https://github.com/ManticoreProject/manticore) - High-level parallel programming language aimed at general-purpose applications running on multi-core processors. ([Web](http://manticore.cs.uchicago.edu/))

- [Mare](https://github.com/jemc/mare) - Reimagining of the Pony language in Crystal.

- [Mech](https://github.com/mech-lang/mech) - Language for developing data-driven, reactive systems like animations, games, and robots. ([Web](http://mech-lang.org/))

- [Metamine](https://github.com/ymte/metamine) - Completely declarative programming language.

- [micro-mitten](https://github.com/doctorn/micro-mitten) - Bare-bones Rust-like programming language, stripped down to simplify control-flow structures and the type system. ([HN](https://news.ycombinator.com/item?id=23113661))

- [min](https://github.com/h3rald/min) - Tiny concatenative programming language and shell.

- [MiniAgda](https://github.com/andreasabel/miniagda) - Prototypical dependently typed languages with sized types and variances.

- [Mint](https://www.mint-lang.com/) - Refreshing programming language for the front-end web. ([Code](https://github.com/mint-lang/mint)) ([Lobsters](https://lobste.rs/s/78fixr/mint_refreshing_programming_language))

- [Monkey in Go](https://github.com/bradford-hamilton/monkey-lang)

- [Monkey in Rust](https://github.com/bradford-hamilton/monkey_lang_rust)

- [Monkey in TypeScript](https://github.com/bradford-hamilton/monkey_lang_rust)

- [Mu](https://github.com/akkartik/mu) - Minimal-dependency hobbyist computing stack.

- [Mun](https://github.com/mun-lang/mun) - Programming language empowering creation through iteration.

- [Muon](https://github.com/nickmqb/muon) - Modern low-level programming language.

- [Myst](https://github.com/myst-lang/myst) - Structured, dynamic, general-purpose language.

- [Nelua](https://github.com/edubart/nelua-lang) - Minimal, efficient, statically-typed and meta-programmable systems programming language heavily inspired by Lua, which compiles to C and native code. ([Web](https://nelua.io/))

- [Neon](https://neon-lang.dev/) - High-level, statically typed, garbage collected, imperative programming language intended for teaching and learning the craft of programming. ([Code](https://github.com/ghewgill/neon-lang))

- [Neptune](https://github.com/Srinivasa314/neptune-lang) - Fast, concurrent and embeddable scripting language.

- [Nixt](https://github.com/Wafelack/nixt) - Interpreted lisp inspired programming language written in Rust.

- [nullc](https://github.com/WheretIB/nullc) - Fast C-like programming language with advanced features. ([HN](https://news.ycombinator.com/item?id=29342301))

- [Oak](https://github.com/adam-mcdaniel/oakc) - Portable programming language with an compact intermediate representation.

- [Oak](https://oaklang.org/) - Expressive, simple, dynamic programming language. ([Code](https://github.com/thesephist/oak))

- [Odin](https://github.com/odin-lang/Odin) - Fast, concise, readable, pragmatic and open sourced. It is designed with the intent of replacing C.

- [Ogol](https://github.com/fcanas/ogol) - Variant of the Logo computer language.

- [Oxide](https://github.com/tuqqu/oxide-lang) - Interpreted scripting language with a Rust influenced syntax.

- [Paka](https://github.com/FastVM/paka)

- [Passerine](https://github.com/vrtbl/passerine) - Small, concise, extensible functional scripting language, powered by a VM written in Rust. ([Web](https://www.passerine.io/)) ([HN](https://news.ycombinator.com/item?id=26212491))

- [Pen](https://pen-lang.org/) - Programming language for scalable development. ([Code](https://github.com/pen-lang/pen)) ([HN](https://news.ycombinator.com/item?id=28590209))

- [Peregrine](https://github.com/peregrine-lang/Peregrine) - Easy to use systems programming language with Python-like syntax.

- [Pocketlang](https://github.com/ThakeeNathees/pocketlang) - Small, fast and friendly language for scripting and embedding. ([Web](https://thakeenathees.github.io/pocketlang/)) ([HN](https://news.ycombinator.com/item?id=27588842))

- [Pointless](https://github.com/pointless-lang/pointless) - Scripting language for learning and fun. ([Web](https://ptls.dev/))

- [Pony](https://www.ponylang.io/) - Open-source, object-oriented, actor-model, capabilities-secure, high-performance programming language. ([Code](https://github.com/ponylang/ponyc))

- [Power-Fx](https://github.com/microsoft/Power-Fx) - Low-code general purpose programming language. ([HN](https://news.ycombinator.com/item?id=26324347))

- [PowerShell](https://github.com/PowerShell/PowerShell) - Cross-platform strongly dynamic typed object-based with functional features automation and configuration language.

- [Pyret](https://www.pyret.org/) - Python like scripting language. ([Code](https://github.com/brownplt/pyret-lang))

- [Pyxell](https://github.com/adamsol/Pyxell) - Multi-paradigm, statically typed programming language, compiled to machine code via C++. ([Docs](https://www.pyxell.org/docs/manual.html))

- [q](https://github.com/akyoto/q) - Programming language focusing on performance and efficiency.

- [Radiance](https://github.com/shortercode/Radiance) - Simple language that compiles to WASM.

- [RaptorJIT](https://github.com/raptorjit/raptorjit) - Dynamic language for system programming (LuaJIT fork).

- [Red](https://github.com/red/red) - Strongly inspired by Rebol, but with a broader field of usage thanks to its native-code compiler, from system programming to high-level scripting and cross-platform reactive GUI. ([Web](https://www.red-lang.org/p/about.html))

- [Rhai](https://github.com/jonathandturner/rhai) - Embedded scripting language for Rust.

- [Rune](https://github.com/rune-rs/rune/) - Embeddable dynamic programming language for Rust. ([Docs](https://rune-rs.github.io/rune/)) ([Lobsters](https://lobste.rs/s/9duro8/rune_programming_language))

- [Rust](https://www.rust-lang.org/) - Multi-paradigm, high-level, general-purpose programming language designed for performance and safety, especially safe concurrency.

- [Scale](https://github.com/StonkDragon/Scale) - Open Source stack-based concatenative programming language.

- [Self](https://selflanguage.org/) - Prototype-based dynamic object-oriented programming language, environment, and virtual machine. ([Code](https://github.com/russellallen/self))

- [Shattuck](https://github.com/whoiscc/shattuck) - Rust-based script programming language.

- [Shen/C](https://github.com/otabat/shen-c) - C port of the Shen programming language.

- [Shen/Go](https://github.com/tiancaiamao/shen-go) - Go port of the Shen language.

- [Shiika](https://github.com/yhara/shiika) - Statically-typed programming language. Looks like Ruby, but has explicit type annotations.

- [Silk](https://github.com/AjayMT/silk) - Small system programming language. Flexible and simple as C, but more pleasant to write. ([Web](https://ajaymt.github.io/silk/))

- [Skew](https://github.com/evanw/skew) - Web-first, cross-platform programming language with an optimizing compiler. ([Code](https://github.com/evanw/skew))

- [Skip](https://github.com/skiplang/skip) - Programming language to skip the things you have already computed.

- [SmallDragon](https://github.com/pointbazaar/smalldragon) - Simple, statically typed programming language that can be transpiled to C. ([Web](https://smalldragon.org/))

- [Smudge](https://github.com/smudgelang/smudge) - Domain-specific language for state machines.

- [SourcePawn](https://github.com/alliedmodders/sourcepawn) - Small and fast typed language for embedding in host applications.

- [Starlark in Rust](https://github.com/facebookexperimental/starlark-rust) - Deterministic language inspired by Python3, used for configuration in the build systems Bazel and Buck.

- [StarShip](https://github.com/larsaugustin/StarShip) - Interpreted, strongly typed, and functional programming language written in Swift.

- [Taichi](https://github.com/taichi-dev/taichi) - Productive programming language for portable, high-performance, sparse & differentiable computing. ([Web](https://www.taichi-lang.org/))

- [Tau](https://github.com/NicoNex/tau) - Open source interpreted programming language designed to be minimal, fast and efficient.

- [Tengo](https://github.com/d5/tengo) - Fast script language for Go.

- [ThinScript](https://github.com/evanw/thinscript) - Low-level programming language inspired by TypeScript.

- [tin](https://github.com/dflemstr/tin) - Statically structurally typed JIT-compiled programming language, mainly for embedding in other programs.

- [Titan](https://github.com/titan-lang/titan) - New programming language, designed to be a statically-typed, ahead-of-time compiled sister language to Lua.

- [Tokay](https://tokay.dev/) - Imperative, procedural programming language dedicated to parsing and other text-processing tasks. ([Code](https://github.com/tokay-lang/tokay))

- [TypeLang](https://github.com/ronami/typelang) - Tiny language interpreter implemented purely in TypeScript's type-system.

- [Umka](https://github.com/vtereshkov/umka-lang) - Statically typed embeddable scripting language.

- [Vale](https://vale.dev/) - Fast, safe, and easy programming language. It uses single ownership with constraint references for memory safety without garbage collection, and an emphasis on modern, readable syntax. ([Code](https://github.com/ValeLang/Vale)) ([HN](https://news.ycombinator.com/item?id=23865674)) ([HN 2](https://news.ycombinator.com/item?id=25160202))

- [Val](https://github.com/val-lang/val) - Open source, general-purpose programming language designed around on the concept of (mutable) value semantics.

- [Verona](https://github.com/microsoft/verona) - Research programming language to explore the concept of concurrent ownership.

- [V](https://vlang.io/) - Fast, safe, compiled language.

- [Virgil](https://github.com/titzer/virgil) - Fast and lightweight native programming language designed for fast, dependency-free programs. ([Lobsters](https://lobste.rs/s/lisdkp/virgil_fast_lightweight_native))

- [vizh](https://github.com/TartanLlama/vizh) - Esoteric visual language that takes image files as input based on a multi-tape turing machine, designed for compatibility with C.

- [Volt](https://github.com/VoltLang/Volta) - Systems level programming language written in D.

- [Wasp](https://github.com/wasp-lang/wasp) - Web Application Specification Language. Extensible DSL (domain-specific language) for building modern web apps with less code. ([Web](https://wasp-lang.dev/)) ([HN](https://news.ycombinator.com/item?id=26091956))

- [wax](https://github.com/LingDong-/wax) - Tiny language that transpiles to C, Java and TypeScript. ([Web](https://waxc.netlify.app/))

- [wenyan](https://wy-lang.org/) - Esoteric programming language that closely follows the grammar and tone of classical Chinese literature.

- [Whiley](http://whiley.org/) - Programming Language with Extended Static Checking. ([Code](https://github.com/Whiley/WhileyCompiler))

- [wlang](https://github.com/rsms/wlang)

- [Wren](https://github.com/wren-lang/wren) - Small, fast, class-based concurrent scripting language. ([Web](https://wren.io/)) ([Lobsters](https://lobste.rs/s/7tzgrc/wren_classy_little_scripting_language))

- [Wuffs](https://github.com/google/wuffs) - Memory-safe programming language (and a standard library written in that language) for wrangling untrusted file formats safely.

- [Wu](https://github.com/wu-lang/wu) - Practical game and data language. ([Docs](https://wu-lang.gitbook.io/guide/))

- [XL](https://github.com/c3d/xl) - Extensible programming language designed to accomodate a variety of programming needs with ease.

- [Yatta](https://github.com/yatta-lang/yatta) - Minimalistic, opiniated, (strongly) dynamically typed, strict, functional programming language, with ML-like syntax, for GraalVM.

- [Yuescript](http://yuescript.org/doc/) - Dynamic language that compiles to Lua. ([Code](https://github.com/pigpigyyy/Yuescript))

- [Zeta](https://github.com/zeta-lang/zeta) - Scripting language designed for efficiency, enabling dynamic extension and modification of high performance software.

- [Zig](https://github.com/zig-lang/zig) - Robust, optimal, and clear programming language.



## Related



- [List of programming languages that are actively developed on GitHub](https://github.com/collections/programming-languages)



[![CC4](https://img.shields.io/badge/license-CC4-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://creativecommons.org/licenses/by/4.0/)

[![Lists](https://img.shields.io/badge/-more%20lists-0a0a0a.svg?style=flat&colorA=0a0a0a)](https://github.com/learn-anything/curated-lists)

[![Contribute](https://img.shields.io/badge/-contribute-0a0a0a.svg?style=flat&colorA=0a0a0a)](contributing.md)

[![Twitter](http://bit.ly/latwitt)](https://twitter.com/learnanything_)