Skip to content

linsa-io/programming-languages

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

325 Commits
 
 
 
 

Repository files navigation

Programming languages Lists

Please read contribution guidelines before contributing.

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 - ML-like functional programming language.
  • 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 - 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.
  • Braid - Functional language with Reason-like syntax that compiles to Go.
  • 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)
  • 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.
  • Eff - Functional language with handlers of not only exceptions, but also of other computational effects such as state or I/O.
  • Effekt - Research language with effect handlers and lightweight effect polymorphism. (Web)
  • 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)
  • F* - General-purpose functional programming language with effects aimed at program verification.
  • 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)
  • 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.
  • Haskell - Advanced, purely functional programming 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.
  • Ink - Minimal programming language inspired by modern JavaScript and Go, with functional style. (Ink By Example)
  • Keli (Motivations) (HN)
  • 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.
  • Lasca - LLVM-based statically or dynamically typed strict functional programming language. Simplified OCaml if you will.
  • Lawvere - Categorical programming language with effects.
  • Leo - Functional, statically-typed programming language built for writing private applications.
  • 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.
  • Neut - Dependently-typed programming language based on the Calculus of Constructions. (HN)
  • Never - Statically typed, embedded functional programming language.
  • OCaml - Industrial strength language supporting functional, imperative and object-oriented styles.
  • Pikelet - Small, functional, dependently typed programming language.
  • Salt - Compilation target that functional programmers always wanted.
  • Silt - An in-progress fast, dependently typed, functional programming language implemented in Swift.
  • 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)
  • 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)
  • Zilch - Statically-typed, low-level, functional programming language with some focus on runtime performance.

Lisp

  • Carp - Statically typed lisp, without a GC, for real-time applications. (Snippets)
  • Clojure - Dynamic, general-purpose, combining the approachability and interactive development of a scripting language with an efficient and robust infrastructure for multithreaded programming.
  • 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.
  • femtolisp - Lightweight, robust, scheme-like lisp implementation.
  • 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)
  • 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.
  • Urn - Lisp implementation for Lua. (Code) (Lobsters)

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)
  • Estérel - Synchronous reactive language that allows simple expression of parallelism and preemption and is based on logical instants and zero time hypothesis. (Web)
  • 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)
  • SugarCubes - Synchronous (à la Boussinot) reactive language that allows to write reactive parallel/concurrent programs on top of sequential JavaScript.

Multi paradigm

  • 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) (HN) (Lobsters)
  • 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.
  • 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.

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.

Other

  • 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)
  • Arturo - Simple, modern and powerful interpreted programming language for efficient scripting. (Web)
  • 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)
  • Ballerina - Open-source programming language for the cloud that makes it easier to use, combine, and create network services. (Web)
  • 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)
  • Boson - Hybrid programming language written in Rust.
  • Bosque - Experiment in regularized design for a machine assisted rapid and reliable software development lifecycle. (HN)
  • 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)
  • 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)
  • Ć - Language which can be translated automatically to C, C++, C#, Java, JavaScript, Python, Swift, TypeScript and OpenCL C. (HN)
  • 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.
  • CLU - Programming language created at MIT.
  • Cognate - Quasi-concatenative stack language that uses embedded comments to read like English prose.
  • Compose - Experimental programming language. It aims to be teachable, scalable, modern, powerful & precise.
  • Concurnas - Open source JVM programming language designed for building reliable, scalable, high performance concurrent, distributed and parallel systems. (HN)
  • Cone - Fast, fit, friendly, and safe systems programming language. (Web)
  • Copper - Experimental programming language that can be used as a replacement to C and C++.
  • 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)
  • Dictu - High-level dynamically typed, multi-paradigm, interpreted programming language. (Docs)
  • 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)
  • 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.
  • Egison - Programming language that features extensible efficient non-linear pattern matching with backtracking for non-free data types. (Code)
  • Ein - Functional programming language for scalable development.
  • Ella - Computer programming language interpreter written in Rust.
  • Elsa - Minimal, fast and secure QuickJS wrapper written in Go. (HN)
  • Emojicode - Open-source, full-blown programming language consisting of emojis. (Code)
  • Enso - Visual and textual functional programming language.
  • EO - Experimental Object-Oriented Programming Language Based on 𝜑-Calculus. (HN)
  • FaCT - Flexible and Constant Time Programming Language.
  • Factor - Practical stack language. (Lobsters)
  • fe - Tiny, embeddable language implemented in ANSI C. (HN)
  • 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)
  • Fractran - Turing-complete esoteric programming language invented by the mathematician John Conway. (Notes) (Fractran Interpreter)
  • Ghost - Small, class-based scripting language. (Web)
  • GLICOL - Graph-oriented live coding language written in Rust. Make music with code. (Web)
  • Gosu - Pragmatic language for the JVM. (Code)
  • Gravity - Embeddable programming language. (Code) (HN)
  • Gwion - Strongly-timed language aimed at music creation. Heavily inspired by ChucK.
  • Hamler - Haskell-style functional programming language running on Erlang VM. (Code) (Article)
  • Hare - Systems programming language designed to be simple, stable, and robust. (Code)
  • Hascal - General purpose and open source programming language designed to build optimal, maintainable, reliable and efficient software.
  • Hazure - ML-Inspired programming language that transpiles to Typescript.
  • Hedy - Gradual programming language, which increases in syntactic elements level by level. (Web)
  • Hexagony - Two-dimensional stack-based programming language. (Hexagony IDE)
  • 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)
  • 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.
  • Icon - Programming language with a focus on string manipulation. (Lobsters)
  • 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)
  • Jai - High-level programming language developed by Jonathan Blow.
  • 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.
  • Kara - Experimental programming language inspired by Swift and Idris.
  • Kempe - Compiled stack-based language.
  • Kernel - Conservative, Scheme-like dialect of Lisp in which everything is a first-class object.
  • 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)
  • Koto - Embeddable scripting language, written in Rust.
  • Kuljet - Language for writing database-backed HTML applications. (Code)
  • 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)
  • 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)
  • 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) (HN)
  • 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.
  • Luxury - Statically programming language which is targeting embedded programming.
  • 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)
  • Mare - Reimagining of the Pony language in Crystal.
  • Mech - Language for developing data-driven, reactive systems like animations, games, and robots. (Web)
  • Metamine - Completely declarative programming language.
  • micro-mitten - Bare-bones Rust-like programming language, stripped down to simplify control-flow structures and the type system. (HN)
  • min - Tiny concatenative programming language and shell.
  • MiniAgda - Prototypical dependently typed languages with sized types and variances.
  • Mint - Refreshing programming language for the front-end web. (Code) (Lobsters)
  • Monkey in Go
  • Monkey in Rust
  • Monkey in TypeScript
  • 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)
  • Neon - High-level, statically typed, garbage collected, imperative programming language intended for teaching and learning the craft of programming. (Code)
  • 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)
  • Oak - Portable programming language with an compact intermediate representation.
  • Oak - Expressive, simple, dynamic programming language. (Code)
  • 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) (HN)
  • Pen - Programming language for scalable development. (Code) (HN)
  • Peregrine - Easy to use systems programming language with Python-like syntax.
  • Pocketlang - Small, fast and friendly language for scripting and embedding. (Web) (HN)
  • Pointless - Scripting language for learning and fun. (Web)
  • Pony - Open-source, object-oriented, actor-model, capabilities-secure, high-performance programming language. (Code)
  • Power-Fx - Low-code general purpose programming language. (HN)
  • PowerShell - Cross-platform strongly dynamic typed object-based with functional features automation and configuration language.
  • Pyret - Python like scripting language. (Code)
  • Pyxell - Multi-paradigm, statically typed programming language, compiled to machine code via C++. (Docs)
  • 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)
  • Rhai - Embedded scripting language for Rust.
  • Rune - Embeddable dynamic programming language for Rust. (Docs) (Lobsters)
  • Rust - Multi-paradigm, high-level, general-purpose programming language designed for performance and safety, especially safe concurrency.
  • Scale - Open Source stack-based concatenative programming language.
  • Self - Prototype-based dynamic object-oriented programming language, environment, and virtual machine. (Code)
  • 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)
  • Skew - Web-first, cross-platform programming language with an optimizing compiler. (Code)
  • Skip - Programming language to skip the things you have already computed.
  • SmallDragon - Simple, statically typed programming language that can be transpiled to C. (Web)
  • 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)
  • 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.
  • Tokay - Imperative, procedural programming language dedicated to parsing and other text-processing tasks. (Code)
  • TypeLang - Tiny language interpreter implemented purely in TypeScript's type-system.
  • Umka - Statically typed embeddable scripting language.
  • 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)
  • Val - Open source, general-purpose programming language designed around on the concept of (mutable) value semantics.
  • Verona - Research programming language to explore the concept of concurrent ownership.
  • V - Fast, safe, compiled language.
  • Virgil - Fast and lightweight native programming language designed for fast, dependency-free programs. (Lobsters)
  • 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) (HN)
  • wax - Tiny language that transpiles to C, Java and TypeScript. (Web)
  • wenyan - Esoteric programming language that closely follows the grammar and tone of classical Chinese literature.
  • Whiley - Programming Language with Extended Static Checking. (Code)
  • wlang
  • Wren - Small, fast, class-based concurrent scripting language. (Web) (Lobsters)
  • 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)
  • 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)
  • Zeta - Scripting language designed for efficiency, enabling dynamic extension and modification of high performance software.
  • Zig - Robust, optimal, and clear programming language.

Related

CC4 Lists Contribute Twitter

About

Awesome Programming Languages

Topics

Resources

Contributing

Stars

328 stars

Watchers

13 watching

Forks

Releases

No releases published

Sponsor this project

Packages

 
 
 

Contributors