The list of 104 awesome programming languages that you might be interested in. If you like exploring programming languages or you are making your own programming language, than it's place for you. Here you can find interesting programming languages that are not well known. Also it's the place to look for a new ideas and inspiration. Feel free to make a contribution.

• Argon - Argon is an interpreted multi-paradigm dynamically typed programming language. Its syntax is mainly influenced by Python, Go and Rust.
• Arturo - Arturo is an independently-developed, modern programming language, vaguely related to various other ones - including but not limited to Logo, Rebol, Forth, Ruby, Haskell, D, SmallTalk, Tcl, and Lisp. The language has been designed following some very simple and straightforward principles: a) Code is just a list of words and symbols, b) Words and symbols within a block are interpreted - when needed - according to the context, c) No reserved words or keywords - look for them as hard as you can; there are absolutely none

• Beads - The Beads project is a daring attempt to generate a new language that will replace the current popular toolchain stack of HTML/CSS/JS/+Frameworks+Database, with a single language.
• Beef - Beef is a performance-oriented compiled programming language.
• Belch - Blech is a language for developing reactive, real-time critical embedded software.

• C2 - An evolution of C.
• C3 - C3 is a C-like language trying to be "an incremental improvement over C" rather than a whole new language.
• C∀ - C∀ (Cforall) is a language design extending ISO C. The purpose of the project is to engineer modern language features into C in an evolutionary rather than revolutionary way. Java is an example of the revolutionary approach of modernizing C/C++, resulting in a new language rather than an extension of its descendents. C++, Fortran 95 and Cobol 9X are examples of the evolutionary approach where modern language features are added and problems fixed within the framework of an existing language.
• Carp - A statically typed lisp, without a GC, for real-time applications. Carp is a small programming language designed to work well for interactive and performance sensitive use cases like games, sound synthesis and visualizations.
• Cicada - Cicada language is a dependently typed programming language and an interactive theorem prover. The aim of cicada project is to help people understand that developing software and developing mathematics are increasingly the same kind of activity, and people who practices these developments, can learn from each other, and help each other in very good ways.
• Cone - Cone is a fast, fit, friendly, and safe systems programming language. Ideal for complex, data-rich programs requiring responsive performance (e.g., 3D).
• Crystal - Crystal is a language with a Ruby like sintax, statically type-checked. It supports compile-time evaluation and code generation. It compiles to efficient native code.
• Cubiml - Cubiml is a simple ML-like programming language with subtyping and full type inference. You can try it out online in your browser here.

• D - General-purpose programming language with static typing, systems-level access, and C-like syntax.
• Dragon - The Dragon is an innovative and practical general-purpose language. The supported programming paradigms are imperative, object-oriented, declarative using nested structures, functional and natural programming. The language is portable (Windows, Linux, macOS, etc.) and can be used to create Console and GUI. The language is designed to be simple, small, flexible and fast..

• Ecstasy - Ecstasy is a new, general-purpose, programming language, designed for modern cloud architectures, and explicitly for the serverless cloud. Actually, to be completely honest, it's the most amazing programming language ever. No, really, it's that awesome.
• Effekt - A research language with effect handlers and lightweight effect polymorphism.
• Elm - Elm is a functional language that compiles to JavaScript. It helps you make websites and web apps. It has a strong emphasis on simplicity and quality tooling.
• EmojiCode - World’s only programming language that’s bursting with emojis. Emojicode is an open source, high-level, multi-paradigm programming language consisting of emojis. It features Object-Orientation, Optionals, Generics and Closures.
• Enact - Enact is a new compiled general-purpose programming language that's not designed to be unique or groundbreaking. Instead, Enact aims to be familiar, taking advantage of already established techniques and paradigms and making them nicer.

• F* - F* (pronounced F star) is a general-purpose functional programming language with effects aimed at program verification. It puts together the automation of an SMT-backed deductive verification tool with the expressive power of a proof assistant based on dependent types. After verification, F* programs can be extracted to efficient OCaml, F#, C, WASM, or ASM code. This enables verifying the functional correctness and security of realistic applications. The main ongoing use case of F* is building a verified, drop-in replacement for the whole HTTPS stack in Project Everest. This includes verified implementations of TLS 1.2 and 1.3 and of the underlying cryptographic primitives.

• Factor - Factor is a concatenative, stack-based programming language with high-level features including dynamic types, extensible syntax, macros, and garbage collection.

• Felix - An advanced, statically typed, high performance scripting language with native C++ embedding.

• Flix - Next-generation reliable, safe, concise, and functional-first programming language. Flix is a principled functional, imperative, and logic programming language developed at Aarhus University, at the University of Waterloo, and by a community of open source contributors.

  Flix is inspired by OCaml and Haskell with ideas from Rust and Scala. Flix looks like Scala, but its type system is based on Hindley-Milner. Two unique features of Flix are its polymorphic effect system and its support for first-class Datalog constraints.

  Flix compiles JVM bytecode, runs on the Java Virtual Machine, and supports full tail call elimination. A VSCode plugin for Flix is available.

• Formality - Formality is an efficient proof language. An lightweight proof-gramming language. It aims to be:

  • Fast: no garbage-collection, optimal beta-reduction, massively parallel compilers.
  • Secure: a powerful type system capable of proving mathematical theorems.
  • Portable: the entire language desugars to a 500 lines core type-theory.

• Forscape - Scientific computing language. Forscape solves engineering problems with an unprecedented level of abstraction so you get reliable results quickly. This high-level approach starts with intuitive syntax. Program with the same notation you use to write equations thanks to our innovative math rendering with semantic formatting. Matrices, fractions, symbols– write code using the same notation you use to think through problems on the whiteboard.

• FreeBASIC - FreeBASIC is a completely free, open-source, multi-platform BASIC compiler, with syntax similar to MS-QuickBASIC, that adds new features such as pointers, object orientation, unsigned data types, inline assembly, and many others.

• Futhark - High-performance purely functional data-parallel array programming on the GPU. Futhark is a small programming language designed to be compiled to efficient parallel code. It is a statically typed, data-parallel, and purely functional array language in the ML family, and comes with a heavily optimising ahead-of-time compiler that presently generates GPU code via CUDA and OpenCL, although the language itself is hardware-agnostic and can also run on multicore CPUs.

• Giml - A functional programming language with emphasis on structural typing.
• Gravity - Gravity is a powerful, dynamically typed, lightweight, embeddable programming language written in C without any external dependencies (except for stdlib). It is a class-based concurrent scripting language with modern Swift-like syntax.
• Gleam - Gleam is a type safe functional programming language for building scalable concurrent systems. It compiles to Erlang and has straightforward interop with other BEAM languages such as Erlang, Elixir and LFE.
• Gluon - Gluon is a static, type inferred and embeddabble language written in Rust.
• Groovy - Groovy is a powerful, optionally typed and dynamic language, with static-typing and static compilation capabilities, for the Java platform aimed at improving developer productivity thanks to a concise, familiar and easy to learn syntax. It integrates smoothly with any Java program, and immediately delivers to your application powerful features, including scripting capabilities, Domain-Specific Language authoring, runtime and compile-time meta-programming and functional programming.
• GSL - GSL is a code construction tool. It will generate code in all languages and for all purposes. If this sounds too good to be true, welcome to 1996, when we invented these techniques. Magic is simply technology that is twenty years ahead of its time. In addition to code construction, GSL has been used to generate database schema definitions, user interfaces, reports, system administration tools and much more.

• Hack - Hack is built specifically for HHVM, a high performance runtime for your Hack applications, and reconciles the fast development cycle of a dynamically typed language with the discipline provided by static typing, while adding many features commonly found in other modern programming languages.
• Hamler - Haskell-style functional programming language running on Erlang VM.
• Hascal - Hascal is a general purpose and open source programming language designed to build optimal, maintainable, reliable and efficient software.
• Haxe - High-level and strictly-typed programming language, cross-compiles to many different targets.
• Hugorm - Hugorm is a dynamically typed programming language. Hugorm strives to be better version of the other snake language, with a heightened focus on . The syntax is designed to be easy to read and easy to write, and runs on a constantly improving bytecode virtual machine.

• Inko - Inko is a statically-typed, safe, object-oriented programming language for writing concurrent programs.

• Jai - Jai is a high-level programming language developed by Jonathan Blow, creator of indie games Braid and, most recently, The Witness. It is an imperative static/strongly typed C-style language, but with a variety of modern language features that C lacks. Blow began work on Jai in late September 2014. It is still in development and as of yet is unavailable to the general public. Blow developed it with an eye towards video games, but in fact it’s a general purpose programming language that could be used for any task.
• JS++ JS++ is a programming language designed for high-quality web and mobile development.
• Juvix - A more elegant language for a more civilized age. Juvix synthesizes a high-level frontend syntax, dependent-linearly-typed core language, whole-program optimisation system, and backend-swappable execution model into a single unified stack for writing formally verifiable, efficiently executable smart contracts which can be deployed to a variety of distributed ledgers.

• Kalaam - Kalaam is the first-ever programming language in Hindi and has all the basic functionalities of a modern programming language. From for loops to while loops and from functions to conditional statements.
• Kalyn - Self-hosting compiler from a Haskell-like Lisp directly to x86-64, developed fully from scratch.
• Keli - Keli is a general purpose programming language where its semantics are mostly based on the pure functional programming model (as of Haskell's) which includes user-defined algebraic datatypes, case matching and higher-order functions, while its syntactic structure is strongly influenced by Smalltalk's message sending syntax, such as the unary, binary and keywords messages.
• Kit - Kit is a programming language designed for creating concise, high performance cross-platform applications. Kit compiles to C, so it's highly portable; it can be used in addition to or as an alternative to C, and was designed with game development in mind.
• Koka - Koka: a functional language with effects. Koka is a strongly typed functional-style language with effect types and handlers.
• Konna - A fast functional language based on two level type theory. An experimental language for exploring the practical applications of two level type theory.

• Leafscript - Leafscript is a lightweight programming language created as a proof of concept by someone with no idea how to write a language. It's written entirely in Golang, and was inspired by the speed and simplicity of Lua.
• Lean - Lean is an open source theorem prover and programming language being developed at Microsoft Research. Lean aims to bridge the gap between interactive and automated theorem proving, by situating automated tools and methods in a framework that supports user interaction and the construction of fully specified axiomatic proofs.
• Lever - Lever programming language is dynamically typed language designed & programmed by Henri Tuhola. It has capabilities to absorb features from other languages. Otherwise it is very generic purpose programming system with a hint of inclination towards interactive graphics and audio programming.
• Luau - A fast, small, safe, gradually typed embeddable scripting language derived from Lua.

• Macro Lambda Calculus - lambda calculus using interaction nets, providing CLI and API. Its browserified version is available as an online demo.
• Magmide - A dependently-typed language intended to make provably correct code possible for working software engineers.
• MANOOL - MANOOL is a programming language designed with an idea to maximize the expressive power / implementation complexity ratio.
• Mash - Untyped, lightweight, crossplatform OOP language.
• Melody - Melody is a language that compiles to regular expressions and aims to be more easily readable and maintainable.
• MetaLang 99 - A functional language for C99 preprocessor metaprogramming.
• MiniLisp - A readable lisp in less than 1k lines of C.
• Minsk - Minsk, a handwritten compiler in C#. It illustrates basic concepts of compiler construction and how one can tool the language inside of an IDE by exposing APIs for parsing and type checking.
• Mun - A programming language empowering creation through iteration.

• Neut - A dependently-typed programming language with compile-time malloc/free determination.
• Never - Never is a simple functional programming language. Technically it may be classified as syntactically scoped, strongly typed, call by value, functional programming language.
• NewLang - NewLang is a high-level programming language that combines standard algorithmic constructs with declarative programming and tensor computing for machine learning problems. The main feature of the language is an easy, logical and non-contradictory syntax, which is not based on the use of reserved keywords, but on a strict system of grammatical rules using punctuation marks (which also includes language operators).
• Nim - Nim is a compiled, garbage-collected systems programming language with a design that focuses on efficiency, expressiveness, and elegance (in that order of priority).
• Nit - Nit is an expressive language with a script-like syntax, a friendly type-system and aims at elegance, simplicity and intuitiveness.

• Oak - A portable programming language with an incredibly compact backend.
• Odin - The Odin programming language is designed with the intent of creating an alternative to C.
• Oil - Oil is a new Unix shell. It's our upgrade path from bash to a better language and runtime.
• Orion - Orion is a high level, purely functional Lisp dialect.

• PAIN - PAIN is a programming language made with the intention of being awful. This is a bad idea and your contributions directly support the starvation of children.
• Passerine - A small extensible programming language designed for concise expression with little code. Passerine is a small, concise, extensible functional scripting language, powered by a VM¹ written in Rust.
• Pharo - Pharo is a pure object-oriented programming language and a powerful environment, focused on simplicity and immediate feedback (think IDE and OS rolled into one).
• Pinafore - Pinafore is a language that allows you to structure information and create user interfaces for it. Currently it's at the "proof of concept" stage. You can build it from source and run it.
• Pure - Pure is a modern-style functional programming language based on term rewriting. It offers equational definitions with pattern matching, full symbolic rewriting capabilities, dynamic typing, eager and lazy evaluation, lexical closures, built-in list and matrix support and an easy-to-use C interface.
• Pure - A pure type system implemented in OCaml.
• Pycopy - Pycopy - a minimalist and memory-efficient Python dialect. Good for desktop, cloud, constrained systems, microcontrollers, and just everything.

• Red - Red is a next-generation programming language 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, while providing modern support for concurrency, all in a zero-install, zero-config, single 1MB file!
• ReScript - ReScript compiler and syntax provide the best experience to write JS and React applications. Unifying the tools in one coherent platform and core team allows us to build features that wouldn't be possible in the original BuckleScript + Reason setup.
• Ribbon - Ribbon is a dynamic interpreted programming language. It's inspired by the likes of Python, Javascript and a little bit of Lua.
• Rio - A script-feeling, safe, naturally compatible replacement for C, with no runtime nor std lib of its own.
• Rhovas - Rhovas is a programming language for API design and enforcement. Using Rhovas, developers can better express the contracts and intention of their code to help create correct, maintainable software.
• Roy - Roy is a small functional language that compiles to JavaScript. It has a few main features:
  • Damas-Hindley-Milner type inference
  • Whitespace significant syntax
  • Simple tagged unions
  • Pattern matching
  • Structural typing
  • Monad syntax
  • Not-horrible JS output
• RustScript - RustScript is a functional scripting language with as much relation to Rust as Javascript has to Java.

• Seed7 - Seed7 is a higher level language compared to Ada, C++ and Java.
• Slate - Slate is a prototype-based, multi-dispatch object-oriented language that runs from a highly-customizable live environment. The implementation is highly portable and relatively lightweight.
• Spiral - Functional language with intensional polymorphism and first-class staging.
• Spry - Spry borrows homoiconicity from Rebol and Lisp, free form syntax from Forth and Rebol, words of different types from Rebol, good data structure literal support from JavaScript and the general coding experience and style from Smalltalk. It also has a few ideas of its own, like an interesting argument passing mechanism and a relatively novel take on OO. Spry is dynamically typed and while trying to recreate the "feeling" of Smalltalk this is an experiment in trying out "interesting" approaches.
• Stark - Stark is a new language and OS with the help of the .NET ecosystem and seL4 micro-kernel.
• Stroscot - Stroscot is an imperative programming language designed for modern processors.

• TableM - A relational language.
• Tlön - Tlön is a programming language transpiled into Modern C++. These are the key goals:
  • Add features which C++ is missing.
  • Throw out all the legacy crap that's been dragged into C++ over the years.
  • Also, just simplify things.
  • Provide a sensible API over Standard Library/STL.
  • Other lofty goals :)

• Ü - Experimental programming language that is compilable, statically-typed C++-like language.
• Umka - Umka is a statically typed embeddable scripting language. It combines the simplicity and flexibility needed for scripting with a compile-time protection against type errors. Its aim is to follow the Python Zen principle Explicit is better than implicit more consistently than dynamically typed languages generally do.
• Unison - Unison is a modern, statically-typed purely functional language, similar to Haskell, but with the ability to describe entire distributed systems with a single program.
• Ur - Ur is a programming language in the tradition of ML and Haskell, but featuring a significantly richer type system. Ur is functional, pure, statically typed, and strict. Ur supports a powerful kind of metaprogramming based on row types.

• V - Simple, fast, safe, compiled language for developing maintainable software. Compiles itself in <1s with zero library dependencies.
• Vale - Vale is the 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.
• Virgil - A Fast and Lightweight Programming Language. Its design blends functional and object-oriented programming paradigms for expressiveness without a lot of overhead, either syntactically or at runtime. Its implementation is focused primarily on static compilation to produce native executables that are standalone. It is well-suited to writing small and fast programs. That makes it ideal for building certain kinds of programs like compilers and virtual machines. It is currently being used for virtual machine and programming language research.

• Wu - An expression oriented, gradually typed and mission-critical programming language.
• Wren - Wren is a small, fast, class-based concurrent scripting language.

• Zenon - Zenon is a statically typed language that compiles to C++. It offers safe and easy application development thanks to high-level features and fast compile times, while keeping C++'s performance and familiar syntax.
• Zig - General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.