Data

Tools

Indexes

Applications

Experiments

Awesome

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

programming-languages

Awesome Programming Languages
https://github.com/linsa-io/programming-languages

Last synced: about 10 hours ago
JSON representation

  • Functional

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

  • Lisp

    • PicoLisp - Simple and lightweight and encourages clean, concise code.
    • Carp - Statically typed lisp, without a GC, for real-time applications. ([Snippets](https://github.com/carpentry-org/snippets))
    • Clojure - Dynamic, general-purpose, combining the approachability and interactive development of a scripting language with an efficient and robust infrastructure for multithreaded programming.
    • Fennel - Lua Lisp Language.
    • Hime - A general programming language running on the JVM platform.
    • Janet - Functional and imperative programming language and bytecode interpreter.
    • Ketos - Lisp dialect scripting and extension language for Rust programs. ([HN](https://news.ycombinator.com/item?id=28616475))
    • Liz - Lisp-flavored general-purpose programming language (based on Zig).
    • llrl - Lisp-like programming language powered by Rust + LLVM.
    • Lux - Functional, statically-typed Lisp that will run on several platforms, such as the Java Virtual Machine and JavaScript interpreters.
    • PicoLisp - Simple and lightweight and encourages clean, concise code.
    • Ren - Cleaner, clearer JavaScript. Modern scripting language for the Web.
    • 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.
    • Emacs Lisp - 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.
    • Urn - Lisp implementation for Lua. ([Code](https://github.com/SquidDev/urn)) ([Lobsters](https://lobste.rs/s/qzubyo/urn_lisp_implementation_for_lua))

  • Multi paradigm

    • JavaScript - High-level, dynamic, weakly typed, prototype-based, multi-paradigm, and interpreted.
    • Objective C - General-purpose and object-oriented, adds Smalltalk-style messaging to the C programming language.
    • Chaos - Strongly typed, dynamic yet compilable, test-oriented procedural programming language that achieves zero cyclomatic complexity. ([HN](https://news.ycombinator.com/item?id=22940265))
    • 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.
    • Ring - Innovative and practical general-purpose multi-paradigm language.
    • Swift - General-purpose, multi-paradigm, compiled programming language.
    • TypeScript - Strict syntactical superset of JavaScript that adds optional static typing to the language.
    • Ada - General-purpose, strongly typed, performant, readable and safe language.
    • Ante - 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))
    • D - General-purpose programming language with static typing, systems-level access, and C-like syntax.

  • Other

    • Lobster - General purpose stand-alone programming language that comes with a built-in library suitable for making games and other graphical things.
    • Pony - Open-source, object-oriented, actor-model, capabilities-secure, high-performance programming language. ([Code](https://github.com/ponylang/ponyc))
    • Lush - Object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications.
    • Charity - Categorical programming language. ([Code](https://github.com/mietek/charity-lang))
    • Metamine - Completely declarative programming language.
    • Mint - 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))
    • Whiley - Programming Language with Extended Static Checking. ([Code](https://github.com/Whiley/WhileyCompiler))
    • Kitten - Statically typed, stack-based functional programming language designed to be simple and fast. ([Code](https://github.com/evincarofautumn/kitten/))
    • Yuescript - Dynamic language that compiles to Lua. ([Code](https://github.com/pigpigyyy/Yuescript))
    • 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))
    • ABS - Programming language that works best when you're scripting on your terminal.
    • Acton - Compiled language, offering the speed of C but with a considerably simpler programming model.
    • Alan - Programming language that does concurrency for you and can thus separate how the software is written from how it runs.
    • Antimony - Language that gets out of your way. ([Docs](https://antimony-lang.github.io/antimony/))
    • Arturo - Simple, modern and powerful interpreted programming language for efficient scripting. ([Web](http://arturo-lang.io/))
    • Astro - Fun safe language for rapid prototyping and high performance applications.
    • Austral - Systems language with linear types.
    • Bagel - Statically typed, reactive language with pure and impure functions. ([Article](https://www.brandons.me/blog/the-bagel-language))
    • Ballerina - Open-source programming language for the cloud that makes it easier to use, combine, and create network services. ([Web](https://ballerina.io/))
    • Basil - Fast and flexible language exploring partial evaluation, context-sensitive parsing, and metaprogramming. Compiles JIT or AOT to native code.
    • Beef - Open source performance-oriented compiled programming language which has been built hand-in-hand with its IDE environment.
    • BIPLAN - Byte coded Interpreted Programming language.
    • BlazeX - AOT compiled object oriented programming language.
    • Bog - Small, strongly typed, embeddable language. Written in Zig.
    • Bolt - Research language with finer-grained concurrency than Rust. ([HN](https://news.ycombinator.com/item?id=23122973))
    • Boson - Hybrid programming language written in Rust.
    • Bosque - Experiment in regularized design for a machine assisted rapid and reliable software development lifecycle. ([HN](https://news.ycombinator.com/item?id=23175280))
    • Butter - Aims to be a concise and friendly language for building efficient software.
    • buzz - Small/lightweight typed scripting language written in Zig.
    • Cairo - Programming language for writing provable programs. ([Web](https://www.cairo-lang.org/))
    • Caledon - Dependently typed, polymorphic, higher order logic programming language.
    • Cane - A small vector language designed for making beats with realtime MIDI.
    • Cant - Programming language descended mainly from E and Scheme.
    • Charity - Categorical programming language. ([Code](https://github.com/mietek/charity-lang))
    • Ć - 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 - Programming language that builds up from a logic-based simple kernel, and is designed to be extensible and modular.
    • Clay - Programming language designed for Generic Programming.
    • Compose - Experimental programming language. It aims to be teachable, scalable, modern, powerful & precise.
    • Cone - Fast, fit, friendly, and safe systems programming language. ([Web](https://cone.jondgoodwin.com/))
    • Cotowali - Statically typed scripting language that transpile into POSIX sh.
    • Crunch - Strongly & statically typed systems level language focused on ease of use, portability and speed.
    • CUP - Simple, C-like programming language.
    • DaCE - Data-Centric Parallel Programming.
    • daScript - High-performance statically strong typed scripting language. ([HN](https://news.ycombinator.com/item?id=24166505))
    • Dictu - High-level dynamically typed, multi-paradigm, interpreted programming language. ([Docs](https://dictu-lang.com/))
    • Disco - Functional teaching language for use in a discrete mathematics course.
    • Ditto - Super Kawaii Dependently Typed Programming Language.
    • Dora - JIT-compiler for the programming language Dora implemented in Rust.
    • Ein - Functional programming language for scalable development.
    • Elsa - Minimal, fast and secure QuickJS wrapper written in Go. ([HN](https://news.ycombinator.com/item?id=24626655))
    • Enso - Visual and textual functional programming language.
    • EO - Experimental Object-Oriented Programming Language Based on 𝜑-Calculus. ([HN](https://news.ycombinator.com/item?id=28423328))
    • FaCT - Flexible and Constant Time Programming Language.
    • fe - Tiny, embeddable language implemented in ANSI C. ([HN](https://news.ycombinator.com/item?id=22785137))
    • Felix - Advanced, statically typed, high performance scripting language with native C++ embedding.
    • F-- - Uncurried minimal functional programming language.
    • Flax - Level, general-purpose language with high level syntax and expressibility.
    • Foolang - Smalltalk-inspired language. ([Web](https://foolang.org/#/))
    • Ghost - Small, class-based scripting language. ([Web](https://ghostlang.org/))
    • GLICOL - Graph-oriented live coding language written in Rust. Make music with code. ([Web](https://glicol.org/))
    • Gravity - Embeddable programming language. ([Code](https://github.com/marcobambini/gravity)) ([HN](https://news.ycombinator.com/item?id=23467289))
    • Gwion - Strongly-timed language aimed at music creation. Heavily inspired by ChucK.
    • Hedy - Gradual programming language, which increases in syntactic elements level by level. ([Web](https://www.hedycode.com/))
    • Hook - Cross-platform scripting language with a C-like syntax, dynamic typing, mutable value semantics approach, and memory management through reference counting.
    • Horse64 - Simple & versatile high-level programming language. ([Web](https://horse64.org/))
    • Hugorm - Mission-critical scripting language.
    • Husky - Programming language designed for many difficult tasks which haven't yet been seen as programmable at all.
    • \_hyperscript - Small scripting language for the web.
    • Inko - Statically-typed, safe, object-oriented programming language for writing concurrent programs.
    • 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 - Programming language. Inspired by Self, Smalltalk and LISP. ([Web](https://iolanguage.org/))
    • jakt - Memory-safe systems programming language. Currently transpiles to C++.
    • Kara - Statically typed, LLVM-based programming language. It's designed to be fast and easy to use.
    • Kempe - Compiled stack-based language.
    • Kinx - Looks like JavaScript, feels like Ruby, and it is the script language fitting in C programmers.
    • Kitten - Statically typed, stack-based functional programming language designed to be simple and fast. ([Code](https://github.com/evincarofautumn/kitten/))
    • Koto - Embeddable scripting language, written in Rust.
    • L2 - Minimalist type-inferred programming language with procedural macro support.
    • 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 - High-Level Language for Rust.
    • liblg - Minimal stack-based VM. ([HN](https://news.ycombinator.com/item?id=24388687))
    • Lobster - General purpose stand-alone programming language that comes with a built-in library suitable for making games and other graphical things.
    • LoLa - Small programming language meant to be embedded into games. ([Web](https://lola.random-projects.net/))
    • Lore - General-purpose programming language featuring multi-functions, structs and traits, structural typing enabling component-based programming, and intersection and semantic types.
    • 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 - Statically typed, embeddable, scripting language written in Zig.
    • Luna - Data processing and visualization environment.
    • Lush - Object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications.
    • Luster - Experimental Lua VM implemented in pure Rust.
    • Lys - Language that compiles to WebAssembly.
    • Makam - Tool for rapid language prototyping.
    • Makeshift - Programming language that was designed to bootstrap the Ashet Home Computer.
    • Manticore - High-level parallel programming language aimed at general-purpose applications running on multi-core processors. ([Web](http://manticore.cs.uchicago.edu/))
    • Mare - Reimagining of the Pony language in Crystal.
    • Mech - Language for developing data-driven, reactive systems like animations, games, and robots. ([Web](http://mech-lang.org/))
    • 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 - Tiny concatenative programming language and shell.
    • MiniAgda - Prototypical dependently typed languages with sized types and variances.
    • Monkey in Go
    • Monkey in Rust
    • Mu - Minimal-dependency hobbyist computing stack.
    • Mun - Programming language empowering creation through iteration.
    • Muon - Modern low-level programming language.
    • Myst - Structured, dynamic, general-purpose language.
    • Nelua - 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/))
    • Neptune - Fast, concurrent and embeddable scripting language.
    • Nixt - Interpreted lisp inspired programming language written in Rust.
    • nullc - Fast C-like programming language with advanced features. ([HN](https://news.ycombinator.com/item?id=29342301))
    • Oak - Portable programming language with an compact intermediate representation.
    • Odin - Fast, concise, readable, pragmatic and open sourced. It is designed with the intent of replacing C.
    • Ogol - Variant of the Logo computer language.
    • Oxide - Interpreted scripting language with a Rust influenced syntax.
    • Paka
    • 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))
    • Peregrine - Easy to use systems programming language with Python-like syntax.
    • 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 - Scripting language for learning and fun. ([Web](https://ptls.dev/))
    • Power-Fx - Low-code general purpose programming language. ([HN](https://news.ycombinator.com/item?id=26324347))
    • PowerShell - Cross-platform strongly dynamic typed object-based with functional features automation and configuration language.
    • Pyxell - Multi-paradigm, statically typed programming language, compiled to machine code via C++. ([Docs](https://www.pyxell.org/docs/manual.html))
    • q - Programming language focusing on performance and efficiency.
    • Radiance - Simple language that compiles to WASM.
    • RaptorJIT - Dynamic language for system programming (LuaJIT fork).
    • 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))
    • Scale - Open Source stack-based concatenative programming language.
    • Shattuck - Rust-based script programming language.
    • Shen/C - C port of the Shen programming language.
    • Shen/Go - Go port of the Shen language.
    • Shiika - Statically-typed programming language. Looks like Ruby, but has explicit type annotations.
    • Silk - Small system programming language. Flexible and simple as C, but more pleasant to write. ([Web](https://ajaymt.github.io/silk/))
    • Skew - Web-first, cross-platform programming language with an optimizing compiler. ([Code](https://github.com/evanw/skew))
    • Skip - Programming language to skip the things you have already computed.
    • SmallDragon - Simple, statically typed programming language that can be transpiled to C. ([Web](https://smalldragon.org/))
    • Smudge - Domain-specific language for state machines.
    • SourcePawn - Small and fast typed language for embedding in host applications.
    • Starlark in Rust - Deterministic language inspired by Python3, used for configuration in the build systems Bazel and Buck.
    • StarShip - Interpreted, strongly typed, and functional programming language written in Swift.
    • Taichi - Productive programming language for portable, high-performance, sparse & differentiable computing. ([Web](https://www.taichi-lang.org/))
    • Tau - Open source interpreted programming language designed to be minimal, fast and efficient.
    • Tengo - Fast script language for Go.
    • ThinScript - Low-level programming language inspired by TypeScript.
    • tin - Statically structurally typed JIT-compiled programming language, mainly for embedding in other programs.
    • Titan - New programming language, designed to be a statically-typed, ahead-of-time compiled sister language to Lua.
    • TypeLang - Tiny language interpreter implemented purely in TypeScript's type-system.
    • Umka - Statically typed embeddable scripting language.
    • Verona - Research programming language to explore the concept of concurrent ownership.
    • Virgil - Fast and lightweight native programming language designed for fast, dependency-free programs. ([Lobsters](https://lobste.rs/s/lisdkp/virgil_fast_lightweight_native))
    • vizh - Esoteric visual language that takes image files as input based on a multi-tape turing machine, designed for compatibility with C.
    • Volt - Systems level programming language written in D.
    • 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 - Tiny language that transpiles to C, Java and TypeScript. ([Web](https://waxc.netlify.app/))
    • Whiley - Programming Language with Extended Static Checking. ([Code](https://github.com/Whiley/WhileyCompiler))
    • wlang
    • Wren - Small, fast, class-based concurrent scripting language. ([Web](https://wren.io/)) ([Lobsters](https://lobste.rs/s/7tzgrc/wren_classy_little_scripting_language))
    • Wuffs - Memory-safe programming language (and a standard library written in that language) for wrangling untrusted file formats safely.
    • Wu - Practical game and data language. ([Docs](https://wu-lang.gitbook.io/guide/))
    • XL - Extensible programming language designed to accomodate a variety of programming needs with ease.
    • Yatta - Minimalistic, opiniated, (strongly) dynamically typed, strict, functional programming language, with ML-like syntax, for GraalVM.
    • Yuescript - Dynamic language that compiles to Lua. ([Code](https://github.com/pigpigyyy/Yuescript))
    • CLU - Programming language created at MIT.
    • Concurnas - 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))
    • Copper - Experimental programming language that can be used as a replacement to C and C++.
    • 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](https://github.com/raghavnautiyal/Dip))
    • Egison - Programming language that features extensible efficient non-linear pattern matching with backtracking for non-free data types. ([Code](https://github.com/egison/egison))
    • Ella - Computer programming language interpreter written in Rust.
    • Emojicode - Open-source, full-blown programming language consisting of emojis. ([Code](https://github.com/emojicode/emojicode))
    • Factor - Practical stack language. ([Lobsters](https://lobste.rs/s/sv9jw7/factor_programming_language))
    • 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))
    • Gosu - Pragmatic language for the JVM. ([Code](https://github.com/gosu-lang/gosu-lang))
    • Hamler - 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 - Systems programming language designed to be simple, stable, and robust. ([Code](https://sr.ht/~sircmpwn/hare/))
    • Hexagony - Two-dimensional stack-based programming language. ([Hexagony IDE](https://hexagony.net/))
    • Icon - Programming language with a focus on string manipulation. ([Lobsters](https://lobste.rs/s/qendox/icon_programming_language))
    • Jai - High-level programming language developed by Jonathan Blow.
    • Kara - Experimental programming language inspired by Swift and Idris.
    • Kernel - Conservative, Scheme-like dialect of Lisp in which everything is a first-class object.
    • Kuljet - Language for writing database-backed HTML applications. ([Code](https://github.com/KMahoney/kuljet))
    • Luxury - Statically programming language which is targeting embedded programming.
    • Neon - 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))
    • Oak - Expressive, simple, dynamic programming language. ([Code](https://github.com/thesephist/oak))
    • Pen - Programming language for scalable development. ([Code](https://github.com/pen-lang/pen)) ([HN](https://news.ycombinator.com/item?id=28590209))
    • Rust - Multi-paradigm, high-level, general-purpose programming language designed for performance and safety, especially safe concurrency.
    • Self - Prototype-based dynamic object-oriented programming language, environment, and virtual machine. ([Code](https://github.com/russellallen/self))
    • Tokay - Imperative, procedural programming language dedicated to parsing and other text-processing tasks. ([Code](https://github.com/tokay-lang/tokay))
    • 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](https://github.com/ValeLang/Vale)) ([HN](https://news.ycombinator.com/item?id=23865674)) ([HN 2](https://news.ycombinator.com/item?id=25160202))
    • V - Fast, safe, compiled language.
    • wenyan - Esoteric programming language that closely follows the grammar and tone of classical Chinese literature.
    • Zeta - Scripting language designed for efficiency, enabling dynamic extension and modification of high performance software.

  • Object-Oriented

    • Inko - Statically-typed, safe, object-oriented programming languages for writing concurrent programs.
    • 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".

  • Explicit logical parallelism

    • Ceu - Reactive language that aims to offer a higher-level and safer alternative to C. ([Web](http://www.ceu-lang.org/))
    • FuncSug - Language for GUI programming that allows program codes to follow the same order as the scenario.
    • Pendulum - Synchronous reactive language (OCaml extension) to program reactive systems on the Web.
    • Reactive ML - Synchronous reactive language that combines the temporal expressiveness of synchronous languages with the power of functional programming.([Web](https://reactiveml.org/))
    • SugarCubes - Synchronous (à la Boussinot) reactive language that allows to write reactive parallel/concurrent programs on top of sequential JavaScript.
    • Estérel - 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))

  • Funny

    • ArnoldC - Programming language based on the one-liners of Arnold Schwarzenegger.
    • C-plus-Equality - Feminist programming language.
    • dogescript - Wow so syntax very doge much future.
Programming Languages
Rust 26 C 20 Haskell 19 C++ 11 TypeScript 9 Go 8 OCaml 6 Scala 5 JavaScript 4 Python 4
Categories
Other 188 Functional 67 Multi paradigm 16 Lisp 15 Explicit logical parallelism 6 Object-Oriented 3 Funny 3 Related 2
Sub Categories
Keywords
programming-language 62 compiler 52 language 50 functional-programming 18 interpreter 14 rust 14 scripting-language 13 functional 10 javascript 10 haskell 10 c 8 lisp 8 bytecode 6 macros 6 lua 6 webassembly 5 virtual-machine 5 typescript 5 embeddable 5 go 5 golang 5 repl 4 transpiler 4 dependent-types 4 vm 4 ocaml 4 cross-platform 4 type-system 4 llvm 4 algebraic-effects 3 cuda 3 functional-languages 3 metaprogramming 3 ide 3 scripting 3 music 3 functional-language 3 wasm 3 stack-based 3 procedural 3 object-oriented 3 linux 3 gpu 3 concurrency 3 zig 2 embeddable-scripting-language 2 recursion 2 compiler-design 2 x86-64 2 type-theory 2