Programming languages

Please read contribution guidelines before contributing.

• Functional
• Lisp
• Object-Oriented
• Multi paradigm
• Funny
• Other
• Related

Functional

• Accelerate - Embedded language for high-performance array computations.
• Agda - Dependently typed functional language.
• Alice ML - Functional programming language based on Standard ML, extended with support for concurrent, distributed, and constraint programming.
• 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.
• Eff - Functional language with handlers of not only exceptions, but also of other computational effects such as state or I/O.
• Eta - Dialect of Haskell on the JVM.
• Eve - Programming language based on years of research into building a human-first programming platform.
• F* - General-purpose functional programming language with effects aimed at program verification.
• Flix - Statically typed functional- and logic programming language inspired by Scala, OCaml, F#, Haskell, and Datalog. (Web)
• Futhark - Purely functional data-parallel programming language. Its optimising compiler is able to compile it to typically very performant GPU code.
• Haskell - Advanced, purely functional programming language.
• OCaml - Industrial strength language supporting functional, imperative and object-oriented styles.
• Sixten - Experimental functional language where all data is unboxed by default. Functional programming with fewer indirections.
• TiML - Functional Language for Practical Complexity Analysis with Invariants.
• Unison - Modern, statically-typed purely functional language, similar to Haskell, but with a unique ability to describe entire distributed systems with a single program.
• Expresso - Simple expressions language with polymorphic extensible row types. (HN)
• Bosatsu - Python-ish pure and total functional programming language.
• Silt - An in-progress fast, dependently typed, functional programming language implemented in Swift.
• Granule - Statically typed functional language with graded modal types for fine-grained program reasoning via types.
• LinearML - Functional language for parallel programming.
• Koka - Function-oriented language with effect inference.
• Beluga - Functional programming language designed for reasoning about formal systems.
• Gluon - Static, type inferred and embeddable language written in Rust.
• Ur/Web - Implementation of a domain-specific functional programming language for web applications.
• Lasca - LLVM-based statically or dynamically typed strict functional programming language. Simplified OCaml if you will.
• Ko - Generic type-safe language for concurrent, stateful, deadlock-free systems and protocol manipulations.
• Braid - Functional language with Reason-like syntax that compiles to Go.
• cur - Powerful meta-programming for powerful types.
• Ink - Minimal programming language inspired by modern JavaScript and Go, with functional style. (Ink By Example)
• Verve - Functional language for the working hacker.
• Enki - Intended to be a logic language for teaching programming to people with no programming experience.
• Bright ML - Statically-typed programming language based on "F-ing modules".
• TopShell - Purely functional, reactive scripting language.
• Amulet - ML-like functional programming language.
• Never - Statically typed, embedded functional programming language.
• Functa - Flexible, fully functional dynamic programming language.
• Pikelet - Small, functional, dependently typed programming language.
• Spiral - Functional language with intensional polymorphism and first-class staging.
• Neut - Dependently-typed programming language based on the Calculus of Constructions. (HN)
• Salt - Compilation target that functional programmers always wanted.
• Discus - Experimental dialect of Haskell which investigates static typing and program transformation in the presence of computational effects.
• Keli (Motivations) (HN)
• F# - Open-source, cross-platform functional programming language for .NET.
• Tyrade - Pure functional language for type-level programming in Rust.
• Unlambda - Minimal, "nearly pure" functional programming language invented by David Madore. Based on combinatory logic. (Wiki)
• Fika - Statically typed functional programming language for the web.
• Yeti - ML-like functional language for the JVM. (Web)
• Nazo ML - Experimental implementation of temporal-logic-based Hindley-Milner type system.
• Dynasty - Interpreted, dynamically-typed, lazily evaluated, purely functional programming language.
• Atto - Insanely simple self-hosted functional programming language.
• Lawvere - Categorical programming language with effects.
• Leo - Functional, statically-typed programming language built for writing private applications.
• Effekt - Research language with effect handlers and lightweight effect polymorphism. (Web)
• Facet - Call-by-value functional language with algebraic effects, quantitative type theory, and staging.
• Mlatu - Statically typed, stack-based purely functional programming language designed for simplicity, speed, and safety.
• Grace - Ready-to-fork interpreted, typed, and functional language.
• TAMGU - FIL programming language: Functional, Imperative, Logical all in one for annotation and data augmentation.
• Clio - Functional, parallel, distributed programming language. (Web)
• morloc - Typed, polyglot, functional language.
• 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.
• Tao - Statically-typed functional programming language.
• Derw - Elm-inspired language that transpiles to TypeScript.
• Labrys - Toy language based on LLVM that implements the System Fω type-system.
• lviv - Stack-based RPN functional programming language. Written in Scheme.
• lambda-ski - Small functional language with a combinator based graph-reduction machine.
• Ditto - Functional, statically typed, and pure.
• Zilch - Statically-typed, low-level, functional programming language with some focus on runtime performance.
• Calypso - Mostly imperative language with some functional influences that is focused on flexibility and simplicity.

Lisp

• Common Lisp - Modern, multi-paradigm, high-performance, compiled, ANSI-standardized, most prominent (along with Scheme) descendant of the long-running family of Lisp programming languages.
• Clojure - Dynamic, general-purpose, combining the approachability and interactive development of a scripting language with an efficient and robust infrastructure for multithreaded programming.
• femtolisp - Lightweight, robust, scheme-like lisp implementation.
• Fennel - Lua Lisp Language.
• PicoLisp - Simple and lightweight and encourages clean, concise code.
• Janet - Functional and imperative programming language and bytecode interpreter.
• Carp - Statically typed lisp, without a GC, for real-time applications. (Snippets)
• Urn - Lisp implementation for Lua. (Code) (Lobsters)
• llrl - Lisp-like programming language powered by Rust + LLVM.
• Ketos - Lisp dialect scripting and extension language for Rust programs. (HN)
• Lux - Functional, statically-typed Lisp that will run on several platforms, such as the Java Virtual Machine and JavaScript interpreters.
• Liz - Lisp-flavored general-purpose programming language (based on Zig).
• Ren - Cleaner, clearer JavaScript. Modern scripting language for the Web.
• Hime - A general programming language running on the JVM platform.

Object-Oriented

• Pharo - A pure object-oriented programming language and a powerful environment derived from Squeak Smalltalk.
• Smalltalk-72 - A pure message-oriented programming language and its environment implemented in '72 to test Alan Kay's idea of "programming by messaging".
• Inko - Statically-typed, safe, object-oriented programming languages for writing concurrent programs.

Multi paradigm

• C - General-purpose, imperative, supporting structured programming, lexical variable scope and recursion, while a static type system prevents many unintended operations.
• Chaos - Strongly typed, dynamic yet compilable, test-oriented procedural programming language that achieves zero cyclomatic complexity. (HN)
• D - General-purpose programming language with static typing, systems-level access, and C-like syntax.
• 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 - High-level and strictly-typed, cross-compiles to many different targets.
• JavaScript - High-level, dynamic, weakly typed, prototype-based, multi-paradigm, and interpreted.
• Julia - High-level, high-performance dynamic language for technical computing.
• Nim - Both high-level and systems-level language, with productivity of Python, performance of C and meta-programming of Lisp.
• Objective C - General-purpose and object-oriented, adds Smalltalk-style messaging to the C programming language.
• Python - Interpreted high-level language for general-purpose programming.
• Swift - General-purpose, multi-paradigm, compiled programming language.
• TypeScript - Strict syntactical superset of JavaScript that adds optional static typing to the language.
• Ring - Innovative and practical general-purpose multi-paradigm language.
• Ante - Low-level functional language for exploring refinement types, lifetime inference, and other fun features. (Code) (HN) (Lobsters)

Funny

• dogescript - Wow so syntax very doge much future.
• C-plus-Equality - Feminist programming language.
• ArnoldC - Programming language based on the one-liners of Arnold Schwarzenegger.

Other

• Cognate - Quasi-concatenative stack language that uses embedded comments to read like English prose.
• RaptorJIT - Dynamic language for system programming (LuaJIT fork).
• Zig - Robust, optimal, and clear programming language.
• Tengo - Fast script language for Go.
• Ciao - Programming language that builds up from a logic-based simple kernel, and is designed to be extensible and modular.
• V - Fast, safe, compiled language.
• Lobster - General purpose stand-alone programming language that comes with a built-in library suitable for making games and other graphical things.
• Bosque - Experiment in regularized design for a machine assisted rapid and reliable software development lifecycle. (HN)
• PowerShell - Cross-platform strongly dynamic typed object-based with functional features automation and configuration language.
• 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)
• Pony - Open-source, object-oriented, actor-model, capabilities-secure, high-performance programming language. (Code)
• Mare - Reimagining of the Pony language in Crystal.
• Clay - Programming language designed for Generic Programming.
• Smudge - Domain-specific language for state machines.
• Felix - Advanced, statically typed, high performance scripting language with native C++ embedding.
• StarShip - Interpreted, strongly typed, and functional programming language written in Swift.
• DaCE - Data-Centric Parallel Programming.
• Beef - Open source performance-oriented compiled programming language which has been built hand-in-hand with its IDE environment.
• Verona - Research programming language to explore the concept of concurrent ownership.
• Factor - Practical stack language. (Lobsters)
• wenyan - Esoteric programming language that closely follows the grammar and tone of classical Chinese literature.
• Titan - New programming language, designed to be a statically-typed, ahead-of-time compiled sister language to Lua.
• Odin - Fast, concise, readable, pragmatic and open sourced. It is designed with the intent of replacing C.
• Taichi - Productive programming language for portable, high-performance, sparse & differentiable computing. (Web)
• XL - Extensible programming language designed to accomodate a variety of programming needs with ease.
• ABS - Programming language that works best when you're scripting on your terminal.
• ThinScript - Low-level programming language inspired by TypeScript.
• Makam - Tool for rapid language prototyping.
• fe - Tiny, embeddable language implemented in ANSI C. (HN)
• Ceu - Reactive language that aims to offer a higher-level and safer alternative to C. (Web)
• Monkey in Go
• Monkey in Rust
• Monkey in TypeScript
• Pointless - Scripting language for learning and fun. (Web)
• Jai - High-level programming language developed by Jonathan Blow.
• Cone - Fast, fit, friendly, and safe systems programming language. (Web)
• micro-mitten - Bare-bones Rust-like programming language, stripped down to simplify control-flow structures and the type system. (HN)
• Bolt - Research language with finer-grained concurrency than Rust. (HN)
• Skip - Programming language to skip the things you have already computed.
• wlang
• MiniAgda - Prototypical dependently typed languages with sized types and variances.
• Muon - Modern low-level programming language.
• Yatta - Minimalistic, opiniated, (strongly) dynamically typed, strict, functional programming language, with ML-like syntax, for GraalVM.
• Concurnas - Open source JVM programming language designed for building reliable, scalable, high performance concurrent, distributed and parallel systems. (HN)
• Compose - Experimental programming language. It aims to be teachable, scalable, modern, powerful & precise.
• Mu - Minimal-dependency hobbyist computing stack.
• Mun - Programming language empowering creation through iteration.
• Hugorm - Mission-critical scripting language.
• Lys - Language that compiles to WebAssembly.
• Radiance - Simple language that compiles to WASM.
• FaCT - Flexible and Constant Time Programming Language.
• min - Tiny concatenative programming language and shell.
• Gravity - Embeddable programming language. (Code) (HN)
• Disco - Functional teaching language for use in a discrete mathematics course.
• Wren - Small, fast, class-based concurrent scripting language. (Web) (Lobsters)
• Inko - Statically-typed, safe, object-oriented programming language for writing concurrent programs.
• Hamler - Haskell-style functional programming language running on Erlang VM. (Code) (Article)
• Luster - Experimental Lua VM implemented in pure Rust.
• Wuffs - Memory-safe programming language (and a standard library written in that language) for wrangling untrusted file formats safely.
• Caledon - Dependently typed, polymorphic, higher order logic programming language.
• Ditto - Super Kawaii Dependently Typed Programming Language.
• Rhai - Embedded scripting language for Rust.
• Pyret - Python like scripting language. (Code)
• Gosu - Pragmatic language for the JVM. (Code)
• Self - Prototype-based dynamic object-oriented programming language, environment, and virtual machine. (Code)
• Vale - 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) (HN) (HN 2)
• Oak - Portable programming language with an compact intermediate representation.
• Luau - Fast, small, safe, gradually typed embeddable scripting language derived from Lua. (FAQ) (HN)
• daScript - High-performance statically strong typed scripting language. (HN)
• Lush - Object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications.
• Luna - Data processing and visualization environment.
• Enso - Visual and textual functional programming language.
• liblg - Minimal stack-based VM. (HN)
• Rune - Embeddable dynamic programming language for Rust. (Docs) (Lobsters)
• 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.
• Charity - Categorical programming language. (Code)
• Elsa - Minimal, fast and secure QuickJS wrapper written in Go. (HN)
• Shiika - Statically-typed programming language. Looks like Ruby, but has explicit type annotations.
• Metamine - Completely declarative programming language.
• _hyperscript - Small scripting language for the web.
• Neon - High-level, statically typed, garbage collected, imperative programming language intended for teaching and learning the craft of programming. (Code)
• Myst - Structured, dynamic, general-purpose language.
• Wasp - Web Application Specification Language. Extensible DSL (domain-specific language) for building modern web apps with less code. (Web) (HN)
• Arturo - Simple, modern and powerful interpreted programming language for efficient scripting. (Web)
• Horse64 - Simple & versatile high-level programming language. (Web)
• wax - Tiny language that transpiles to C, Java and TypeScript. (Web)
• TypeLang - Tiny language interpreter implemented purely in TypeScript's type-system.
• Pyxell - Multi-paradigm, statically typed programming language, compiled to machine code via C++. (Docs)
• Crunch - Strongly & statically typed systems level language focused on ease of use, portability and speed.
• Koto - Embeddable scripting language, written in Rust.
• Cant - Programming language descended mainly from E and Scheme.
• Kempe - Compiled stack-based language.
• Dora - JIT-compiler for the programming language Dora implemented in Rust.
• Butter - Aims to be a concise and friendly language for building efficient software.
• Kinx - Looks like JavaScript, feels like Ruby, and it is the script language fitting in C programmers.
• Icon - Programming language with a focus on string manipulation. (Lobsters)
• Nelua - Minimal, efficient, statically-typed and meta-programmable systems programming language heavily inspired by Lua, which compiles to C and native code. (Web)
• Fractran - Turing-complete esoteric programming language invented by the mathematician John Conway. (Notes) (Fractran Interpreter)
• Zeta - Scripting language designed for efficiency, enabling dynamic extension and modification of high performance software.
• Kuljet - Language for writing database-backed HTML applications. (Code)
• Skew - Web-first, cross-platform programming language with an optimizing compiler. (Code)
• Copper - Experimental programming language that can be used as a replacement to C and C++.
• CLU - Programming language created at MIT.
• q - Programming language focusing on performance and efficiency.
• Lama - Programming language developed by JetBrains Research for educational purposes as an exemplary language to introduce the domain of programming languages, compilers and tools.
• Ghost - Small, class-based scripting language. (Web)
• Ein - Functional programming language for scalable development.
• Alan - Programming language that does concurrency for you and can thus separate how the software is written from how it runs.
• Ella - Computer programming language interpreter written in Rust.
• Nixt - Interpreted lisp inspired programming language written in Rust.
• Manticore - High-level parallel programming language aimed at general-purpose applications running on multi-core processors. (Web)
• BIPLAN - Byte coded Interpreted Programming language.
• Ogol - Variant of the Logo computer language.
• Bog - Small, strongly typed, embeddable language. Written in Zig.
• Shen/Go - Go port of the Shen language.
• Shen/C - C port of the Shen programming language.
• Cairo - Programming language for writing provable programs. (Web)
• Starlark in Rust - Deterministic language inspired by Python3, used for configuration in the build systems Bazel and Buck.
• Dip - 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)
• Mint - Refreshing programming language for the front-end web. (Code) (Lobsters)
• Whiley - Programming Language with Extended Static Checking. (Code)
• Passerine - Small, concise, extensible functional scripting language, powered by a VM written in Rust. (Web) (HN)
• io - Programming language. Inspired by Self, Smalltalk and LISP. (Web)
• Power-Fx - Low-code general purpose programming language. (HN)
• SmallDragon - Simple, statically typed programming language that can be transpiled to C. (Web)
• Egison - Programming language that features extensible efficient non-linear pattern matching with backtracking for non-free data types. (Code)
• Kitten - Statically typed, stack-based functional programming language designed to be simple and fast. (Code)
• Luxury - Statically programming language which is targeting embedded programming.
• Oxide - Interpreted scripting language with a Rust influenced syntax.
• Umka - Statically typed embeddable scripting language.
• Hexagony - Two-dimensional stack-based programming language. (Hexagony IDE)
• Kernel - Conservative, Scheme-like dialect of Lisp in which everything is a first-class object.
• F-- - Uncurried minimal functional programming language.
• vizh - Esoteric visual language that takes image files as input based on a multi-tape turing machine, designed for compatibility with C.
• tin - Statically structurally typed JIT-compiled programming language, mainly for embedding in other programs.
• Flax - Level, general-purpose language with high level syntax and expressibility.
• Pocketlang - Small, fast and friendly language for scripting and embedding. (Web) (HN)
• Ballerina - Open-source programming language for the cloud that makes it easier to use, combine, and create network services. (Web)
• LoLa - Small programming language meant to be embedded into games. (Web)
• Antimony - Language that gets out of your way. (Docs)
• Astro - Fun safe language for rapid prototyping and high performance applications.
• Foolang - Smalltalk-inspired language. (Web)
• Rust - Multi-paradigm, high-level, general-purpose programming language designed for performance and safety, especially safe concurrency.
• Emojicode - Open-source, full-blown programming language consisting of emojis. (Code)
• EO - Experimental Object-Oriented Programming Language Based on 𝜑-Calculus. (HN)
• Oak - Expressive, simple, dynamic programming language. (Code)
• Bagel - Statically typed, reactive language with pure and impure functions. (Article)
• Pen - Programming language for scalable development. (Code) (HN)
• Hedy - Gradual programming language, which increases in syntactic elements level by level. (Web)
• buzz - Small/lightweight typed scripting language written in Zig.
• Lore - General-purpose programming language featuring multi-functions, structs and traits, structural typing enabling component-based programming, and intersection and semantic types.
• L2 - Minimalist type-inferred programming language with procedural macro support.
• GLICOL - Graph-oriented live coding language written in Rust. Make music with code. (Web)
• Virgil - Fast and lightweight native programming language designed for fast, dependency-free programs. (Lobsters)
• Silk - Small system programming language. Flexible and simple as C, but more pleasant to write. (Web)
• Lia - High-Level Language for Rust.
• Kara - Experimental programming language inspired by Swift and Idris.
• Acton - Compiled language, offering the speed of C but with a considerably simpler programming model.
• Peregrine - Easy to use systems programming language with Python-like syntax.
• Ć - Language which can be translated automatically to C, C++, C#, Java, JavaScript, Python, Swift, TypeScript and OpenCL C. (HN)
• SourcePawn - Small and fast typed language for embedding in host applications.
• Austral - Systems language with linear types.
• Kara - Statically typed, LLVM-based programming language. It's designed to be fast and easy to use.
• BlazeX - AOT compiled object oriented programming language.
• nullc - Fast C-like programming language with advanced features. (HN)
• Val - Open source, general-purpose programming language designed around on the concept of (mutable) value semantics.
• Cotowali - Statically typed scripting language that transpile into POSIX sh.
• Hascal - General purpose and open source programming language designed to build optimal, maintainable, reliable and efficient software.
• Dictu - High-level dynamically typed, multi-paradigm, interpreted programming language. (Docs)
• Shattuck - Rust-based script programming language.
• Volt - Systems level programming language written in D.
• Paka
• Yuescript - Dynamic language that compiles to Lua. (Code)
• Luf - Statically typed, embeddable, scripting language written in Zig.
• Basil - Fast and flexible language exploring partial evaluation, context-sensitive parsing, and metaprogramming. Compiles JIT or AOT to native code.
• Makeshift - Programming language that was designed to bootstrap the Ashet Home Computer.
• CUP - Simple, C-like programming language.
• Hare - Systems programming language designed to be simple, stable, and robust. (Code)
• Hazure - ML-Inspired programming language that transpiles to Typescript.
• Neptune - Fast, concurrent and embeddable scripting language.
• Gwion - Strongly-timed language aimed at music creation. Heavily inspired by ChucK.
• Cane - A small vector language designed for making beats with realtime MIDI.
• Mech - Language for developing data-driven, reactive systems like animations, games, and robots. (Web)
• Tokay - Imperative, procedural programming language dedicated to parsing and other text-processing tasks. (Code)
• jakt - Memory-safe systems programming language. Currently transpiles to C++.
• Wu - Practical game and data language. (Docs)
• Boson - Hybrid programming language written in Rust.
• Tau - Open source interpreted programming language designed to be minimal, fast and efficient.
• Husky - Programming language designed for many difficult tasks which haven't yet been seen as programmable at all.

Related

• List of programming languages that are actively developed on GitHub