GitHub - wyasher/programming-language-navigator: A repository for navigating through various programming languages, providing links to their official websites and repository addresses.

Introduction

A repository for navigating through various programming languages, providing links to their official websites and repository addresses.

Programming Languages

3body

Three Body Language written in Rust.

ACT

This is the implementation of the ACT hardware description language, and some of the core tools. (ACT = asynchronous circuit/compiler tools).

Acton

Acton is a general purpose programming language, designed to be useful for a wide range of applications, from desktop applications to embedded and distributed systems. In a first approximation Acton can be described as a seamless addition of a powerful new construct to an existing language: Acton adds actors to Python.

Acton is a compiled language, offering the speed of C but with a considerably simpler programming model. There is no explicit memory management, instead relying on garbage collection.

Acton is statically typed with an expressive type language and type inference. Type inferrence means you don't have to explicitly declare types of every variable but that the compiler will infer the type and performs its checks accordingly. We can have the benefits of type safety without the extra overhead involved in declaring types.

The Acton Run Time System (RTS) offers a distributed mode of operation allowing multiple computers to participate in running one logical Acton system. Actors can migrate between compute nodes for load sharing purposes and similar. The RTS offers exactly once delivery guarantees. Through checkpointing of actor states to a distributed database, the failure of individual compute nodes can be recovered by restoring actor state. Your system can run forever!

Ada

Ada is a structured, statically typed, imperative, and object-oriented high-level programming language, inspired by Pascal and other languages. It has built-in language support for design by contract (DbC), extremely strong typing, explicit concurrency, tasks, synchronous message passing, protected objects, and non-determinism.

Official Website: https://ada-lang.io

Adama

A programming language for board games powered by the JVM. It is a data-centric programming language which enables building tiny persistent game servers which radically reduce engineering and operational costs for board games.

Adept

A blazing fast language for general purpose programming.

Repository: https://github.com/AdeptLanguage/Adept

Agda

Agda is a dependently typed functional programming language. It has inductive families, i.e., data types which depend on values, such as the type of vectors of a given length. It also has parametrised modules, mixfix operators, Unicode characters, and an interactive Emacs interface which can assist the programmer in writing the program.

Agda is a proof assistant. It is an interactive system for writing and checking proofs. Agda is based on intuitionistic type theory, a foundational system for constructive mathematics developed by the Swedish logician Per Martin-Löf. It has many similarities with other proof assistants based on dependent types, such as Coq, Epigram, Matita and NuPRL.

Agda is open-source and enjoys contributions from many authors. The center of the Agda development is the Programming Logic group at Chalmers and Gothenburg University. The main developers are Ulf Norell, Nils Anders Danielsson, Jesper Cockx, and Andreas Abel.

AiScript

🔋 A lightweight scripting language runing on JavaScript.

Alan

👩‍🚀 Alan is a programming language that makes the power of the GPU more accessible, with a syntax similar to a dynamic language (it's typed, but 100% inferred), and restrictions on recursion and iteration to make automatic generation of multi-threaded CPU and GPGPU versions of your code for you.

Alda

Alda is a text-based programming language for music composition. It allows you to write and play back music using only a text editor and the command line.

Alumina

Alumina is an imperative, general-purpose, statically typed, compiled system programming language. It is heavily inspired by Rust, but it keeps C-style manual memory management and memory unsafety.

Amun

A Statically typed, compiled general purpose low level programming language built using C++ and LLVM Infrastructure framework, the design was inspired from many programming languages with the goal to be simple and productive.

AnalLang

AnalLang is a language that takes a Node.js program to translate to AnalLang by splitting each character, translating each character to its ASCII code, and repeating the "🍑🍆" emoji sequence by the ASCII code, then adding a space and taking the next letter from the string and translating to the "🍑🍆" emoji sequence, which is repeated until all letters are translated.

AnalLang interprets by splitting each "🍑🍆" emoji sequence, then splitting all the spaces into an array, then looping through each entry and counting appearances of "🍑🍆", which is then turned into an ASCII code and then into its original character, then looping until all characters have been translated to their original form, then joining the characters and evaluating the final result.

Official Website: https://esolangs.org/wiki/AnalLang

AnalScript

AnalScript is a joke esoteric programming language, that takes inspiration from the fallen AnalLang and serves, the purpose to be a modern approach for writing anally fast stuff.

Ante

Ante is a low-level functional language for exploring refinement types, lifetime inference, and other fun features.

Apex

Apex is a strongly typed, object-oriented programming language that allows developers to execute flow and transaction control statements on the Salesforce Platform server, in conjunction with calls to the API. This guide introduces you to the Apex development process and provides valuable information on learning, writing, deploying and testing Apex.

Official Website: https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_dev_guide.htm

AQ

AQ is an interpreted programming language. It is fast, small, simple and safe. At the same time, programs written in AQ can also be compiled. Maybe a great piece of work.

Aqua

Aqua is an open-source language for distributed workflow coordination in p2p networks. Aqua programs are executed on many peers, sequentially or in parallel, forming a single-use coordination network. Applications are turned into hostless workflows over distributed function calls, which enables various levels of decentralization: from handling by a limited set of servers to complete peer-to-peer architecture by connecting user devices directly. Aqua is the core of the Fluence protocol and a framework for internet or private cloud applications.

Argon

The Argon language is a work-in-progress interpreted multi-paradigm programming language. Its syntax is influenced by many modern languages and aims to be elegant, clean and simple to use.

ArkScript

ArkScript is a small, fast, functional and scripting language for C++ projects.

small (less than 10'000 lines of idiomatic C++17)
a scripting language
portable, compile once, run your bytecode anywhere
functional, every argument is passed by copy
homoiconic, you can manipulate code with macros
extensible, through C++ plugins
async/await on any function
no hidden references
tail call and unused variable optimization
a REPL with autocompletion and coloration
a standard library in ArkScript and C++
only need to learn 10 keywords
docker images: stable, nightly

ArkTS

ArkTS is the application development language for Harmony Ecology. On the basis of maintaining the basic syntax style of TypeScript (TS), it imposes stricter constraints on the dynamic typing characteristics of TS and introduces static typing. At the same time, it provides corresponding capabilities such as declarative UI and state management, allowing developers to develop high-performance applications in a more concise and natural way.

Artichoke

Artichoke is a Ruby implementation written in Rust and Ruby. Artichoke intends to be MRI-compatible and targets recent MRI Ruby. Artichoke provides a Ruby runtime implemented in Rust and Ruby. Official Website: https://www.artichokeruby.org

Repository: https://github.com/artichoke/artichoke

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:

Code is just a list of words, symbols and literal values
Words and symbols within a block are interpreted - when needed - according to the context
No reserved words or keywords - look for them as hard as you can; there are absolutely none

AsmX

AsmX is a modern programming language, has great flexibility for refactoring code. Has Turing completeness. Low-level.

AssemblyScript

A TypeScript-like language for WebAssembly.

AssemblyScript targets WebAssembly's feature set specifically, giving developers low-level control over their code.
Its similarity with TypeScript makes it easy to compile to WebAssembly without learning a new language.
Integrates with the existing Web ecosystem - no heavy toolchains to set up. Simply npm install it!

Aviator

Aviator is a lightweight, high performance scripting language hosted on the JVM. It compiles script to java byte code and evaluate it on the fly.

Awk

The awk utility interprets a special-purpose programming language that makes it possible to handle simple data-reformatting jobs with just a few lines of code.

Asteria

Asteria is untyped. Variables do not have types. Only values (which can be stored in in variables) do. In this sense functions are considered opaque data.

Repository: https://github.com/lhmouse/asteria

Azoth

something about a general-purpose language; flexible, extensible, correct, and robust; for Professional Programmers; Robust programming at scale; enabling powerful libraries.

Ballerina

Flexible, Powerful, Beautiful Integrations as Code with Ballerina

Open source, cloud-native programming language optimized for integration
Batteries included: Rich ecosystem of network protocols, data formats, and connectors
Edit/view source code textually or graphically as sequence diagrams and flowcharts
Built-in, easy and efficient concurrency with sequence diagrams and safety primitives
Developed by WSO2 since 2016 and first released in February 2021

BAML

BAML (Basically a Made-up Language) is a Domain Specific Language (DSL) for building AI applications and interacting with LLMs and other AI models.

Key Features of BAML:

Define LLM prompts as functions: Inputs and output types are clearly defined, allowing you to break down complex LLM prompts into smaller, more manageable tasks, and allowing you to query your data in more powerful ways.
Generate Python and TypeScript code: Run a BAML function in Python or typescript using our built-in code generator.
Invocation tracing and data querying/viewing: Enables monitoring and analysis of function calls.

Barn

Barn is a simple programming language written in GoLang and compiled to C. Syntax is very simple, and Barn can call C/C++ functions natively so creating new bindings should be easy. Barn was written with the goal of being as fast and easy to use as possible. Barn is just a little project with which I can chill and just code.

Bass

Bass is a scripting language for running commands and caching the shit out of them.

Bass's goal is to make shipping software predictable, repeatable, and fun. The plan is to support sophisticated CI/CD flows while sticking to familiar ideas. CI/CD boils down to running commands. Bass leverages that instead of trying to replace it.

Beef

Beef is an open source performance-oriented compiled programming language which has been built hand-in-hand with its IDE environment. The syntax and many semantics are most directly derived from C#, while attempting to retain the C ideals of bare-metal explicitness and lack of runtime surprises, with some "modern" niceties inspired by languages such as Rust, Swift, and Go.

Beef's primary design goal is to provide a fluid and pleasurable development experience for high-performance real-time applications such as video games, with low-level features that make it suitable for engine development, combined with high-level ergonomics suitable for game code development.

Beef allows for safely mixing different optimization levels on a per-type or per-method level, allowing for performance-critical code to be executed at maximum speed without affecting debuggability of the rest of the application.

Memory management in Beef is manual, and includes first-class support for custom allocators. Care has been taken to reduce the burden of manual memory management with language ergonomics and runtime safeties – Beef can detect memory leaks in real-time, and offers guaranteed protection against use-after-free and double-deletion errors. As with most safety features in Beef, these memory safeties can be turned off in release builds for maximum performance.

The Beef IDE supports productivity features such as autocomplete, fixits, reformatting, refactoring tools, type inspection, runtime code compilation (hot code swapping), and a built-in profiler. The IDE's general-purpose debugger is capable of debugging native applications written in any language, and is intended to be a fully-featured standalone debugger even for pure C/C++ developers who want an alternative to Visual Studio debugging.

Blade

Blade is a modern general-purpose programming language focused on enterprise Web, IoT, and secure application development. Blade offers a comprehensive set of tools and libraries out of the box leading to reduced reliance on third-party packages.

Blade comes equipped with an integrated package management system, simplifying the management of both internal and external dependencies and a self-hostable repository server making it ideal for private organizational and personal use. Its intuitive syntax and gentle learning curve ensure an accessible experience for developers of all skill levels. Leveraging the best features from JavaScript, Python, Ruby, and Dart, Blade provides a familiar and robust ecosystem that enables developers to harness the strengths of these languages effortlessly.

Bosatsu

Bosatsu (菩薩) is the transliteration in Japanese of the sanskrit bodhisattva. A bodhisattva is someone who can reach enlightenment but decides not to, to help others achieve that goal.

Borgo

Borgo is a new programming language that compiles to Go.

bpftrace

bpftrace is a high-level tracing language for Linux enhanced Berkeley Packet Filter (eBPF) available in recent Linux kernels (4.x). bpftrace uses LLVM as a backend to compile scripts to BPF-bytecode and makes use of BCC for interacting with the Linux BPF system, as well as existing Linux tracing capabilities: kernel dynamic tracing (kprobes), user-level dynamic tracing (uprobes), and tracepoints. The bpftrace language is inspired by awk and C, and predecessor tracers such as DTrace and SystemTap. bpftrace was created by Alastair Robertson.

Repository: https://github.com/iovisor/bpftrace

BQN

BQN: finally, an APL for your flying saucer.

A simple, consistent, and stable array programming language
A low-dependency C implementation using bytecode compilation: installation
System functions for math, files, and I/O (including a C FFI)
Documentation with examples, visuals, explanations, and rationale for features
Libraries with interfaces for common file formats like JSON and CSV

bruijn

Functional programming language based on pure de Bruijn indexed lambda calculus.

Brainease

Brainease is a scripting language that has many similar concepts with brainf*ck, sharing some principal concepts, like memory and instructions. It was created to be a simple and faster language to create, but also to be a language that is easy to read and understand.

One instruction per line, long files but shorter width.
Syntax highlighting for every IDE that supports highlighting for the R language.
Memory management done with a simple, fast and linear memory allocation system.
Python-like indentation system - Just two spaces.

Buzz

A small/lightweight statically typed scripting language written in Zig.

Find out bugs in your IDE rather than in production
Uses MIR, a fast and lightweight JIT compiler
No implicit behavior or unexpected type coercion
Does not take much space on your drive or in your mind
Single threaded cooperative multitasking

C

C is a general-purpose computer programming language. It was created in the 1970s by Dennis Ritchie, and remains very widely used and influential. By design, C's features cleanly reflect the capabilities of the targeted CPUs. It has found lasting use in operating systems, device drivers, protocol stacks, though decreasingly for application software. C is commonly used on computer architectures that range from the largest supercomputers to the smallest microcontrollers and embedded systems.

Official Website: https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html

C

C is a perfect programming language.

Repository: https://github.com/TodePond/C

C3

C3 is a programming language that builds on the syntax and semantics of the C language, with the goal of evolving it while still retaining familiarity for C programmers.

It's an evolution, not a revolution: the C-like for programmers who like C.

Repository: https://github.com/c3lang/c3c

Cadence

Cadence is a resource-oriented programming language that introduces new features to smart contract programming that help developers ensure that their code is safe, secure, clear, and approachable.

Type safety and a strong static type system
Resource-oriented programming, a new paradigm that pairs linear types with object capabilities to create a secure and declarative model for digital ownership by ensuring that resources (and their associated assets) can only exist in one location at a time, cannot be copied, and cannot be accidentally lost or deleted
Built-in pre-conditions and post-conditions for functions and transactions
The utilization of capability-based security, which enforces access control by requiring that access to objects is restricted to only the owner and those who have a valid reference to the object

CakeML

CakeML is a functional programming language and an ecosystem of proofs and tools built around the language. The ecosystem includes a proven-correct compiler that can bootstrap itself.

Calcpad

Calcpad is free software for mathematical and engineering calculations. It represents a flexible and modern programmable calculator with Html report generator. It is simple and easy to use, but it also includes many advanced features:

real and complex numbers;
units of measurement (SI, Imperial and USCS);
custom variables and units;
built-in library with common math functions;
custom functions of multiple parameters f(x; y; z; ...);
powerful numerical methods for root and extremum finding, numerical integration and differentiation;
finite sum, product and iteration procedures;
modules, macros and string variables;
program flow control with conditions and loops;
"titles" and 'text' comments in quotes;
support for Html and CSS in comments for rich formatting;
function plotting, images, tables, parametric SVG drawings, etc.;
automatic generation of Html forms for data input;
professional looking Html reports for viewing and printing;
export to Word documents (*.docx) and PDF;
variable substitution and smart rounding of numbers;
output visibility control and content folding;
support for plain text (*.txt, .cpd) and binary (.cpdz) file formats.

Cmajor

Cmajor is a programming language for writing fast, portable audio software.

You've heard of C, C++, C#, objective-C... well, Cmajor is a C-family language designed specifically for writing DSP signal processing code.

Candy

A sweet, functional programming language that is robust, minimalistic, and expressive.

Repository: https://github.com/candy-lang/candy

Capy

A statically typed, compiled programming language, largely inspired by Jai, Odin, and Zig. It even has arbitrary compile-time evaluation!

Repository: https://github.com/capy-language/capy

Carbon

Carbon is fundamentally a successor language approach, rather than an attempt to incrementally evolve C++. It is designed around interoperability with C++ as well as large-scale adoption and migration for existing C++ codebases and developers.

Repository: https://github.com/carbon-language/carbon-lang

Carp

Carp is a programming language designed to work well for interactive and performance sensitive use cases like games, sound synthesis and visualizations.

The key features of Carp are the following:

Automatic and deterministic memory management (no garbage collector or VM)
Inferred static types for great speed and reliability
Ownership tracking enables a functional programming style while still using mutation of cache-friendly data structures under the hood
No hidden performance penalties – allocation and copying are explicit
Straightforward integration with existing C code
Lisp macros, compile time scripting and a helpful REPL

Repository: https://github.com/carp-lang/Carp

Catala

Catala is a programming language adapted for socio-fiscal legislative literate programming. By annotating each line of the legislative text with its meaning in terms of code, one can derive an implementation of complex socio-fiscal mechanisms that enjoys a high level of assurance regarding the code-law faithfulness.

Catspeak

A cross-platform, expression oriented programming language for implementing modding support into your GameMaker Studio 2.3 games.

Celerity

Celerity is a programming language aiming for a good balance of productivity and scalability while being easily embeddable in host applications.

Celerity is expression-oriented, multi-paradigm, and features optional type checking. Some notable features are pattern matching, first-class functions with closures, opt-in mutability, explicit yet terse error propagation, concurrency based on lightweight agents, and non-suspending garbage collection.

ChaiScript

ChaiScript is one of the only embedded scripting language designed from the ground up to directly target C++ and take advantage of modern C++ development techniques, working with the developer how they would expect it to work. Being a native C++ application, it has some advantages over existing embedded scripting languages:

It uses a header-only approach, which makes it easy to integrate with existing projects.
It maintains type safety between your C++ application and the user scripts.
It supports a variety of C++ techniques including callbacks, overloaded functions, class methods, and stl containers.

Chapel

Chapel is a programming language designed for productive parallel computing at scale.

Why Chapel? Because it simplifies parallel programming through elegant support for:

distributed arrays that can leverage thousands of nodes' memories and cores
a global namespace supporting direct access to local or remote variables
data parallelism to trivially use the cores of a laptop, cluster, or supercomputer
task parallelism to create concurrency within a node or across the system

Chapel Characteristics

productive: code tends to be similarly readable/writable as Python
scalable: runs on laptops, clusters, the cloud, and HPC systems
fast: performance competes with or beats C/C++ & MPI & OpenMP
portable: compiles and runs in virtually any *nix environment
open-source: hosted on GitHub, permissively licensed

Cherri

Cherri (pronounced cherry) is a iOS Siri Shortcuts programming language, that compiles directly to a valid runnable Shortcut.

Chisel

The Constructing Hardware in a Scala Embedded Language (Chisel) is an open-source hardware description language (HDL) used to describe digital electronics and circuits at the register-transfer level that facilitates advanced circuit generation and design reuse for both ASIC and FPGA digital logic designs.

Chisel adds hardware construction primitives to the Scala programming language, providing designers with the power of a modern programming language to write complex, parameterizable circuit generators that produce synthesizable Verilog. This generator methodology enables the creation of re-usable components and libraries, such as the FIFO queue and arbiters in the Chisel Standard Library, raising the level of abstraction in design while retaining fine-grained control.

ChucK

ChucK is a programming language for real-time sound synthesis and music creation. It is open-source and freely available on macOS, Windows, and Linux. ChucK presents a unique time-based, concurrent programming model that is precise and expressive (we call this strongly-timed), with dynamic control rates and the ability to add and modify code on-the-fly. In addition, ChucK supports MIDI, OpenSoundControl, HID devices, and multi-channel audio. It's fun and easy to learn, and offers composers, researchers, and performers a powerful programming tool for building and experimenting with complex audio synthesis/analysis programs, and real-time interactive music.

Cicada

Cicada language is a dependently typed programming language and an interactive theorem prover.

Citrine

With Citrine you can easily create apps and games using your native language. You can export your creations to any PC, mobile phone, game console or website (soon).

Clojure

Clojure is a robust, practical, and fast programming language with a set of useful features that together form a simple, coherent, and powerful tool.

Clojure is a dynamic, general-purpose programming language, combining the approachability and interactive development of a scripting language with an efficient and robust infrastructure for multithreaded programming. Clojure is a compiled language, yet remains completely dynamic – every feature supported by Clojure is supported at runtime. Clojure provides easy access to the Java frameworks, with optional type hints and type inference, to ensure that calls to Java can avoid reflection.

Clojure is a dialect of Lisp, and shares with Lisp the code-as-data philosophy and a powerful macro system. Clojure is predominantly a functional programming language, and features a rich set of immutable, persistent data structures. When mutable state is needed, Clojure offers a software transactional memory system and reactive Agent system that ensure clean, correct, multithreaded designs.

Clio

Clio is a functional, distributed programming language that compiles to JavaScript. It runs in the browser and on the server and is made to be a suitable language for scientific programming. Clio takes advantage of multiple CPUs and multiple CPU cores (parallelism) by default, is able to use network resources, is easy to run on clusters and on the cloud.

Coalton

Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.

CodePortal

CodePortal is an open-source full-stack, AI-first, web-based programming platform with the primary goal of improving the way in which we build software. With CodePortal you can create, edit and publish web-apps, widgets, and APIs in a simple and intuitive editor. All without installing or configuring anything.

Cloe

Cloe is the timeless functional programming language which provides implicit parallelism, concurrency, and reactiveness. It aims to be simple and practical.

Clue

Clue is a programming language that compiles blazingly fast into Lua code with a syntax similar to languages like C or Rust.

Clue tries to be almost as simple as Lua (with only a slightly more advanced syntax) but adds many optional features that can make code look better or make some things (like metatables) easier to code.

Clue does not compile to a specfic version of Lua: flags can be toggled to alter the output to allow most if not all versions or modifications of Lua to be compiled to with Clue.

Cobalt

Cobalt is a high-level, compiled language with similar uses to C++. It aims to be more modern than C++, but offer more freedom than Rust.

COBOL

COBOL is an important language on the modern mainframe that enterprises and developers continue to rely on.

Official Website: https://developer.ibm.com/languages/cobol

Coconut

Coconut is a functional programming language that compiles to Python. Since all valid Python is valid Coconut, using Coconut will only extend and enhance what you're already capable of in Python.

Coconut aims to enhance the repertoire of Python programmers to include the tools of modern functional programming in as Pythonic a way as possible. Additionally, Coconut code runs the same on any Python version, meaning that even if you just use Coconut to write pure Python, you no longer have to worry about any core Python version differences: Coconut can backport almost all modern Python features as far back as Python 2.6.

CoffeeScript

CoffeeScript is a little language that compiles into JavaScript. Underneath that awkward Java-esque patina, JavaScript has always had a gorgeous heart. CoffeeScript is an attempt to expose the good parts of JavaScript in a simple way.

Core

a modern, minimal programming language.

Common Lisp

Common Lisp (CL) is a dialect of the Lisp programming language, published in American National Standards Institute (ANSI) standard document ANSI INCITS 226-1994 (S20018) (formerly X3.226-1994 (R1999)). The Common Lisp HyperSpec, a hyperlinked HTML version, has been derived from the ANSI Common Lisp standard.

Compis

Compis is a contemporary systems programming language in the spirit of C.

The compiler supports writing programs in mixed Compis and C; you can mix .c and .co source files. It accomplishes this by bundling some LLVM tools, like clang and lld into one executable. The LLVM dependency might go away someday.

Repository: https://github.com/rsms/compis

Comune

comune is a general-purpose programming language, designed as a gradual successor to C++. it boasts many modern and powerful features, including static memory safety, an expression-based C-style syntax, type-checked generics, first-class support for sum types, a flexible pattern-matching system, and a highly parallelized compiler, while providing seamless C++ interop.

Repository: https://github.com/comune-lang/comune

Cotowali

A statically typed scripting language that is transpiled into shell script.

Outputs shell script that is fully compliant with POSIX standards.
Simple syntax.
Simple static type system.
Syntax for shell specific feature like pipe and redirection.

CovScript

Covariant Script is a dynamic general-purpose programming language designed for modern applications to deliver consistent experience across different platforms.

Crystal

Crystal is a programming language with the following goals:

Have a syntax similar to Ruby (but compatibility with it is not a goal)
Statically type-checked but without having to specify the type of variables or method arguments.
Be able to call C code by writing bindings to it in Crystal.
Have compile-time evaluation and generation of code, to avoid boilerplate code.
Compile to efficient native code.

Crumb

Crumb is a high level, functional, interpreted, dynamically typed, general-purpose programming language, with a terse syntax, and a verbose standard library.

Strictly no side effects* to help you write functional code
The ability to localize the effects of imported Crumb files.
Dynamic typing and garbage collection.
0 keywords, everything is a function.

Repository: https://github.com/liam-ilan/crumb

CSML

CSML helps chatbot development teams build truly intelligent, maintainable and scalable chatbots, integrated with your favorite apps, on any channel, with full control over your source code.

CSpydr

CSpydr is a low-level, static typed, free and open-source, compiled programming language inspired by Rust and C. This repository contains cspc (the CSpydr Programming Language Compiler), as well as CSpydr's Standard Library, a code-linting utility, some code examples and unit tests.

Repository: https://github.com/CSML-by-Clevy/csml-engine

Csq

Csq is a high level programming language which is inspired by the speed of C++ and productivity of Python.

CSS

Cascading Style Sheets (CSS) is a stylesheet language used to describe the presentation of a document written in HTML or XML (including XML dialects such as SVG, MathML or XHTML). CSS describes how elements should be rendered on screen, on paper, in speech, or on other media.

Official Website: https://developer.mozilla.org/en-US/docs/Web/CSS

CUE

Configure, Unify, Execute

CUE is an open source data constraint language which aims to simplify tasks involving defining and using data.

It is a superset of JSON, allowing users familiar with JSON to get started quickly.

Curry

Curry is a declarative multi-paradigm programming language which combines in a seamless way features from functional programming (nested expressions, higher-order functions, strong typing, lazy evaluation) and logic programming (non-determinism, built-in search, free variables, partial data structures). Compared to the single programming paradigms, Curry provides additional features, like optimal evaluation for logic-oriented computations and flexible, non-deterministic pattern matching with user-defined functions.

Curv

Curv is a programming language for creating art using mathematics. It's a 2D and 3D geometric modelling tool that supports full colour, animation and 3D printing. Features:

Curv is a simple, powerful, dynamically typed, pure functional programming language.
Curv is easy to use for beginners. It has a standard library of predefined geometric shapes, plus operators for transforming and combining shapes. These can be plugged together like Lego to make 2D and 3D models.
Coloured shapes are represented using Function Representation (F-Rep). They can be infinitely detailed, infinitely large, and any shape or colour pattern that can be described using mathematics can be represented exactly.
Curv exposes the full power of F-Rep programming to experts. The standard geometry library is written entirely in Curv. Many of the demos seen on shadertoy.com can be reproduced in Curv, using shorter, simpler programs. Experts can package techniques used on shadertoy as high level operations for use by beginners.
Rendering is GPU accelerated. Curv programs are compiled into fragment shaders which are executed on the GPU.
Curv can export meshes to STL, OBJ and X3D files for 3D printing. The X3D format supports full colour 3D printing (on Shapeways.com, at least). These meshes are defect free: watertight, manifold, with no self intersections, degenerate triangles, or flipped triangles.

Repository: https://github.com/curv3d/curv

CVXPY

CVXPY is a Python-embedded modeling language for convex optimization problems. It allows you to express your problem in a natural way that follows the math, rather than in the restrictive standard form required by solvers.

Cyber

Cyber is a fast, efficient, and concurrent scripting language. You can embed it into your applications, games, or engines on desktop or web. Cyber also comes with a CLI so you can do scripting on your computer.

Cypher

openCypher is an open source implementation of Cypher® - the most widely adopted, fully-specified, and open query language for property graph databases. Cypher was developed by Neo4j®.

Cypher provides an intuitive way to work with property graphs today and is the best on-ramp to the graph query language (GQL) standard being developed by ISO.

C++

C++ is a high-level, general-purpose programming language created by Danish computer scientist Bjarne Stroustrup. First released in 1985 as an extension of the C programming language, it has since expanded significantly over time; modern C++ currently has object-oriented, generic, and functional features, in addition to facilities for low-level memory manipulation. It is almost always implemented as a compiled language, and many vendors provide C++ compilers, including the Free Software Foundation, LLVM, Microsoft, Intel, Embarcadero, Oracle, and IBM.

Official Website: https://cplusplus.com

C#

C# is a modern, innovative, open-source, cross-platform object-oriented programming language and one of the top 5 programming languages on GitHub.

D

D is a general-purpose programming language with static typing, systems-level access, and C-like syntax. With the D Programming Language, write fast, read fast, and run fast.

Fast code, fast.

D2

D2 is a modern diagram scripting language that turns text to diagrams.

DaCe

Decoupling domain science from performance optimization.

DaCe is a fast parallel programming framework that takes code in Python/NumPy and other programming languages, and maps it to high-performance CPU, GPU, and FPGA programs, which can be optimized to achieve state-of-the-art. Internally, DaCe uses the Stateful DataFlow multiGraph (SDFG) data-centric intermediate representation: A transformable, interactive representation of code based on data movement. Since the input code and the SDFG are separate, it is possible to optimize a program without changing its source, so that it stays readable. On the other hand, transformations are customizable and user-extensible, so they can be written once and reused in many applications. With data-centric parallel programming, we enable direct knowledge transfer of performance optimization, regardless of the application or the target processor.

DaCe generates high-performance programs for:

Multi-core CPUs (tested on Intel, IBM POWER9, and ARM with SVE)
NVIDIA GPUs and AMD GPUs (with HIP)
Xilinx and Intel FPGAs

Dark

a combined language, editor, and infrastructure to make it easy to build backends.

Dart

Dart is a client-optimized language for fast apps on any platform.

Develop with a programming language specialized around the needs of user interface creation
Make changes iteratively: use hot reload to see the result instantly in your running app
Compile to ARM & x64 machine code for mobile, desktop, and backend. Or compile to JavaScript for the web

Dafny

Dafny is a verification-aware programming language that has native support for recording specifications and is equipped with a static program verifier. By blending sophisticated automated reasoning with familiar programming idioms and tools, Dafny empowers developers to write provably correct code (w.r.t. specifications). It also compiles Dafny code to familiar development environments such as C#, Java, JavaScript, Go and Python (with more to come) so Dafny can integrate with your existing workflow. Dafny makes rigorous verification an integral part of development, thus reducing costly late-stage bugs that may be missed by testing.

daScript

daScript is a high-level programming language that features strong static typing. It is designed to provide high performance and serves as an embeddable 'scripting' language for C++ applications that require fast and reliable performance, such as games or back end/servers. Additionally, it functions effectively as a standalone programming language.

daScript is:

Extremely fast programming language that can rival compiled or JIT languages even in interpreter mode. It consistently outperforms dynamically interpreted scripting languages such as Lua. When used in AOT mode, daScript is often faster than naively written C++ due to its SSE-friendly POD-types, and it even surpasses some of the best JIT VMs like V8 or LuaJIT. As a result, there's no need to rewrite your daScript code in C++ to optimize your application.
Safe and versatile programming language that provides all the benefits of static typing. Many errors that would break an application in runtime in languages like Lua or JavaScript won't even compile in daScript. Additionally, due to its support for generics, type inference, and macros, daScript is easy and fluid to use. Safety is a fundamental pillar of daScript's design, making it safer in many cases than languages like C++ or Java.
Real embedded programming language that requires no external dependencies other than a C++17 compiler. Its interop capabilities are both super easy to use and safe, as is expected from any embedded scripting language that's meant to call native code.

DDP

Die Deutsche Programmiersprache (DDP) ist eine (Witz-)Programmiersprache von NotLe0n und bafto, die so entworfen wurde, dass in ihr geschriebene Programme so gelesen werden können wie (annähernd) korrektes Deutsch.

Dictu

Dictu is a high-level dynamically typed, multi-paradigm, interpreted programming language. Dictu has a very familiar C-style syntax along with taking inspiration from the family of languages surrounding it, such as Python and JavaScript.

Dictu means simplistic in Latin. This is the aim of the language: to be as simplistic, organized, and logical as humanly possible.

Delphi

Delphi is a general-purpose programming language and a software product that uses the Delphi dialect of the Object Pascal programming language and provides an integrated development environment (IDE) for rapid application development of desktop, mobile, web, and console software,[3] currently developed and maintained by Embarcadero Technologies.

Official Website: https://www.embarcadero.com/products/delphi

Dinfio

Dinfio is a high-level, general-purpose, interpreted, minimalist, simple, and open source programming language. Dinfio supports multiple paradigms, including imperative, procedural, object-oriented, and event-driven programming.

Disco

Disco is a programming language intended to teach basic functional programming principles in the context of a discrete mathematics course.

Repository: https://github.com/disco-lang/disco

Dora

dora programming language.

Repository: https://github.com/dinfuehr/dora

Dylan

Dylan is an object-functional language originally created by Apple for the Newton. Dylan is a direct descendant of Scheme and CLOS (without the Lisp syntax) with a programming model designed to support efficient machine code generation, including fine-grained control over dynamic and static behaviors.

Eberban

Eberban is a logical constructed language aimed to satisfy the following goals :

being simple: the Eberban grammar allows manipulating predicates with particles in a way that is close to the higher-order logic it translates into, while abstracting away the verbosity of explicitly providing variables as arguments of predicates.
being regular: valid sentences are syntactically unambiguous. Most grammar rules rely on particles which are organised into families, each starting with a unique prefix. Many additional patterns are shared between particles and predicate words to help with learning groups of related words.
being expressive: the grammar and core vocabulary focus on providing a simple framework, on top of which can be built abstractions, complex concepts and tools. Since those are built into Eberban itself, users can create their own tools and abstractions to express entirely new concepts. Eberban takes inspiration from Lojban and other logical languages, but tries novel approaches to satisfy the above goals.
Official Website: https://eberban.github.io/eberban
Repository: https://github.com/eberban/eberban

eC

An Expressive and Intuitive, C Style Object-Oriented Programming Language.

Effekt

A research language with effect handlers and lightweight effect polymorphism.

Eiger

Eiger (name from Mt. Eiger, Switzerland) is a simple interpreted dynamic-typed programming language.

ELENA

ELENA is a general-purpose language with late binding. It is multi-paradigm, combining features of functional and object-oriented programming. It supports both strong and weak types, run-time conversions, boxing and unboxing primitive types, direct usage of external libraries. A rich set of tools is provided to deal with message dispatching : multi-methods, message qualifying, generic message handlers. Multiple-inheritance can be simulated using mixins and type interfaces. The built-in script engine allows incorporating custom-defined scripts into your applications. Both stand-alone applications and Virtual machine clients are supported.

Elixir

Elixir is a dynamic, functional language for building scalable and maintainable applications.

Elixir runs on the Erlang VM, known for creating low-latency, distributed, and fault-tolerant systems. These capabilities and Elixir tooling allow developers to be productive in several domains, such as web development, embedded software, machine learning, data pipelines, and multimedia processing, across a wide range of industries.

Ellie

Ellie is a type-safe programing language that runs on embedded and sandboxed environments.

Elm

A delightful language for reliable web applications.

Elvish

Elvish is an expressive programming language and a versatile interactive shell, combined into one seamless package. It runs on Linux, BSDs, macOS and Windows.

Emacs Lisp

At its core is an interpreter for Emacs Lisp, a dialect of the Lisp programming language with extensions to support text editing.

Emojicode

Emojicode is an open source, high-level, multi-paradigm programming language consisting of emojis. It features Object-Orientation, Optionals, Generics and Closures.

EndBASIC

EndBASIC is an interpreter for a BASIC-like language and is inspired by Amstrad's Locomotive BASIC 1.1 and Microsoft's QuickBASIC 4.5. Like the former, EndBASIC intends to provide an interactive environment that seamlessly merges coding with immediate visual feedback. Like the latter, EndBASIC offers higher-level programming constructs and strong typing.

EndBASIC offers a simplified and restricted environment to learn the foundations of programming and focuses on features that can quickly reward the programmer. These features include things like a built-in text editor, commands to render graphics, and commands to interact with the hardware of a Raspberry Pi. Implementing this kind of features has priority over others such as performance or a much richer language.

EndBASIC is written in Rust and runs both on the web and locally on a variety of operating systems and platforms, including macOS, Windows, and Linux.

Enso

Enso is an award-winning interactive programming language with dual visual and textual representations. It is a tool that spans the entire stack, going from high-level visualization and communication to the nitty-gritty of backend services, all in a single language. Watch the following introduction video to learn what Enso is, and how it helps companies build data workflows in minutes instead of weeks.

Enterprise

Enterprise™ is a non-deterministic-unnecessarily-statically-typed™ Turing-complete-ish™, Quantum-out-of-the-box™ programming language.

Enterprise™ is designed to create computer programs that disrupt markets.

Repository: https://github.com/joaomilho/Enterprise

EO

EO (stands for Elegant Objects or ISO 639-1 code of Esperanto) is an object-oriented programming language based on 𝜑-calculus. We're aware of popular semi-OOP languages and we don't think they are good enough, including: Java, Ruby, C++, Smalltalk, Python, PHP, C#.

Erg

Erg has a strong type system and comfortable compiler support. For example, it has dependent types and refinement types. These types strongly encode pre-conditions, invariant conditions, etc. into the code.

Erlang

Erlang is a programming language used to build massively scalable soft real-time systems with requirements on high availability. Some of its uses are in telecoms, banking, e-commerce, computer telephony and instant messaging. Erlang's runtime system has built-in support for concurrency, distribution and fault tolerance.

Eve

Eve is a programming language based on years of research into building a human-first programming platform.

Eyg

Create programs that run everywhere and never crash.

Eyg programs can be run everywhere, on client and server as well as build scripts and embedded. The Eyg language makes no assumptions about the runtime or platform a program will be run on. All requirements a program has to the outside world are explicit and tracked using effect types.

Factor

The Factor programming language is a concatenative, stack-based programming language with high-level features including dynamic types, extensible syntax, macros, and garbage collection. On a practical side, Factor has a full-featured library, supports many different platforms, and has been extensively documented.

The implementation is fully compiled for performance, while still supporting interactive development. Factor applications are portable between all common platforms. Factor can deploy stand-alone applications on all platforms. Full source code for the Factor project is available under a BSD license.

Fennel

Fennel is a lisp that compiles to Lua. It aims to be easy to use, expressive, and has almost zero overhead compared to writing Lua directly.

Full Lua compatibility- You can use any function or library from Lua.
Zero overhead - Compiled code should be just as efficient as hand-written Lua.
Compile-time macros - Ship compiled code with no runtime dependency on Fennel.
Embeddable - Fennel is a one-file library as well as an executable. Embed it in other programs to support runtime extensibility and interactive development.
Official Website: https://fennel-lang.org
Repository: https://github.com/bakpakin/Fennel

Fetlang

Fetlang is a statically typed, procedural, esoteric programming language and reference implementation. It is designed such that source code looks like poorly written fetish erotica.

Repository: https://github.com/fetlang/fetlang

Flitter

Flitter is a functional programming language and declarative system for describing 2D and 3D visuals. The language is designed to encourage an iterative, explorative, play-based approach to constructing visuals.

The engine is able to live reload all code and assets (including shaders, images, videos, models, etc.) while retaining the current system state - thus supporting live-coding. It also has support for interacting with running programs via MIDI surfaces.

Flitter is designed for expressivity and ease of engine development over raw performance, but is fast enough to be able to do interesting things.

Finkel

Finkel is a statically typed, purely functional, and non-strict-by-default LISP flavored programming language.

Or in other words, Haskell in S-expression.

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 to JVM bytecode, runs on the Java Virtual Machine, and supports full tail call elimination. A VSCode plugin for Flix is available.

Fortran

High-performance parallel programming language.

Fortran is mostly used in domains that adopted computation early–science and engineering. These include numerical weather and ocean prediction, computational fluid dynamics, applied math, statistics, and finance. Fortran is the dominant language of High Performance Computing and is used to benchmark the fastest supercomputers in the world.

FunctionalScript

FunctionalScript is a purely functional programming language and a strict subset of ECMAScript/JavaScript. It's inspired by

JSON and JSON5 as subsets of JavaScript. JSON is also a subset of FunctionalScript.
asm.JS/WebAssembly, as a subset of JavaScript.
TypeScript, as a superset of JavaScript.
Repository: https://github.com/functionalscript/functionalscript

Fusion

Fusion is a programming language which can be translated automatically to C, C++, C#, D, Java, JavaScript, Python, Swift, TypeScript and OpenCL C.

Repository: https://github.com/fusionlanguage/fut

Futhark

Futhark is a purely functional data-parallel programming language in the ML family. It can be compiled to typically very efficient parallel code, running on either a CPU or GPU. The language is developed at DIKU at the University of Copenhagen, originally as part of the HIPERFIT centre. It is quite stable and suitable for practical programming.

F#

An open-source language that makes it easy to write succinct, robust, and performant code.

F*

F* (pronounced F star) is a general-purpose proof-oriented programming language, supporting both purely functional and effectful programming. It combines the expressive power of dependent types with proof automation based on SMT solving and tactic-based interactive theorem proving.

F* programs compile, by default, to OCaml. Various fragments of F* can also be extracted to F#, to C or Wasm by a tool called KaRaMeL, or to assembly using the Vale toolchain. F* is implemented in F* and bootstrapped using OCaml.

GDL

GDL is a domain-specific programming language and a data analysis environment. As a language, it is dynamically-typed, array-oriented, vectorised and has object-oriented programming capabilities. GDL library routines handle numerical calculations, data visualisation, signal/image processing, interaction with host OS and data input/output. GDL supports several data formats such as netCDF, HDF4, HDF5, GRIB, PNG, TIFF, DICOM, etc. Graphical output is handled by X11, PostScript, SVG or z-buffer terminals, the last one allowing output graphics (plots) to be saved in a variety of raster graphics formats. GDL features integrated debugging facilities. The built-in widget functionality enables development of GUI-based software. GDL has also a Python bridge (Python code can be called from GDL; GDL can be compiled as a Python module). Development and maintenance of GDL is carried out targeting Linux, BSD, OSX and Windows (MinGW, Cygwin).

Repository: https://github.com/gnudatalanguage/gdl

GDScript

GDScript is a high-level, object-oriented, imperative, and gradually typed programming language built for Godot. It uses an indentation-based syntax similar to languages like Python. Its goal is to be optimized for and tightly integrated with Godot Engine, allowing great flexibility for content creation and integration.

GDScript is entirely independent from Python and is not based on it.

Gera

A procedural, statically typed, garbage collected programming language without type annotations.

Gitql

A git query language.

Repository: https://github.com/filhodanuvem/gitql

Gleam

Gleam is a friendly language for building type-safe systems that scale!

It compiles to Erlang (or JavaScript) and has straightforward interop with other BEAM languages such as Erlang, Elixir, and LFE.

The power of a type system, the expressiveness of functional programming, and the reliability of the highly concurrent, fault tolerant Erlang runtime, with a familiar and modern syntax.

Gluon

Gluon is a static, type inferred and embeddabble language written in Rust.

Go

Build simple, secure, scalable systems with Go.

An open-source programming language supported by Google
Easy to learn and great for teams
Built-in concurrency and a robust standard library
Large ecosystem of partners, communities, and tools

Gosu

Gosu is a pragmatic programming language for the JVM. It has been designed with Java developers in mind by providing a set of features that allow them to be more productive without sacrificing the benefits of Java's simple syntax and type-safety. Gosu is an object oriented language with a sprinkle of functional programming features.

Go+

For engineering, STEM education, and data science.

A static typed language.
The simplest engineering language that can be mastered by children (script-like style).
Performance: as fast as Go (Go+'s main backend compiles to human-readable Go).
Fully compatible with Go and can mix Go/Go+ code in the same package (see Go/Go+ hybrid programming).
No DSL (Domain Specific Language) support, but it's Specific Domain Friendly (see DSL vs. SDF).
Support Go code generation (main backend) and bytecode backend (REPL: see iGo+).
Simplest way to interaction with C (cgo is supported but not recommended).
Powerful built-in data processing capabilities.

Grain

Grain is a new language that puts academic language features to work.

Grain is a new programming language that compiles to WebAssembly via Binaryen.

GraphQXL

GraphQXL is a new language built on top of the GraphQL syntax that extends the original language with some additional features useful for creating scalable and big server side schemas. This repository contains the source code for the GraphQXL compiler.

Grapycal

Grapycal is a graphical and interactive programming language. It allows users to manipulate and assemble programs by dragging and clicking blocks or graphs representing various built-in and custom Python functions.

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.

Gravity supports procedural programming, object-oriented programming, functional programming, and data-driven programming. Thanks to special built-in methods, it can also be used as a prototype-based programming language.

Gravity has been developed from scratch for the Creo project in order to offer an easy way to write portable code for the iOS and Android platforms. It is written in portable C code that can be compiled on any platform using a C99 compiler. The VM code is about 4K lines long, the multipass compiler code is about 7K lines and the shared code is about 3K lines long. The compiler and virtual machine combined add less than 200KB to the executable on a 64-bit system.

Gren

Gren is a functional programming language with carefully managed side-effects and a strong static type system. The language consists of a few concepts with human readable names that compose well together, so you can do more with less.

Programs written in Gren are simple, have few or no runtime exceptions and are fun to work with.

Grimoire

Grimoire is a simple and fast concurrent programming language that can easily be embedded into another D programs. You can very easily interface your program with Grimoire's scripts.

Groovy

Apache 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.

Guidance

Guidance enables you to control modern language models more effectively and efficiently than traditional prompting or chaining. Guidance programs allow you to interleave generation, prompting, and logical control into a single continuous flow matching how the language model actually processes the text. Simple output structures like Chain of Thought and its many variants (e.g., ART, Auto-CoT, etc.) have been shown to improve LLM performance. The advent of more powerful LLMs like GPT-4 allows for even richer structure, and guidance makes that structure easier and cheaper.

Simple, intuitive syntax, based on Handlebars templating.
Rich output structure with multiple generations, selections, conditionals, tool use, etc.
Playground-like streaming in Jupyter/VSCode Notebooks.
Smart seed-based generation caching.
Support for role-based chat models (e.g., ChatGPT).
Easy integration with Hugging Face models, including guidance acceleration for speedups over standard prompting, token healing to optimize prompt boundaries, and regex pattern guides to enforce formats.
Repository: https://github.com/guidance-ai/guidance

Gwion

gwion is a strongly timed programming language for making music.

It is strongly influenced by ChucK, but adds a bunch of high-level features: templating, first-class functions and more.

It aims to be simple, small, fast, extendable and embeddable.

Hack

Hack is an object-oriented programming language for building reliable websites at epic scale.

Halide

Halide is a programming language designed to make it easier to write high-performance image and array processing code on modern machines. Halide currently targets:

CPU architectures: X86, ARM, Hexagon, PowerPC, RISC-V
Operating systems: Linux, Windows, macOS, Android, iOS, Qualcomm QuRT
GPU Compute APIs: CUDA, OpenCL, OpenGL Compute Shaders, Apple Metal, Microsoft Direct X 12, Vulkan
Official Website: https://halide-lang.org
Repository: https://github.com/halide/Halide

Hamler

Hamler is a strongly-typed language with compile-time typechecking and built-in support for concurrency and distribution.

Hamler empowers industries to build the next generation of scalable, reliable, realtime applications, especially for 5G, IoT and edge computing.

Harbour

Harbour is the free software implementation of a multi-platform, multi-threading, object-oriented, scriptable programming language, backward compatible with Clipper/xBase. Harbour consists of a compiler and runtime libraries with multiple UI and database backends, its own make system and a large collection of libraries and interfaces to many popular APIs.

Harmony

A Python-like programming language for testing and experimenting with concurrent programs. Instead of "running" code, Harmony programs are model-checked so that all corner cases are explored.

Hare

Hare is a systems programming language designed to be simple, stable, and robust. Hare uses a static type system, manual memory management, and a minimal runtime. It is well-suited to writing operating systems, system tools, compilers, networking software, and other low-level, high performance tasks.

Hash

Firstly, Hash is an interpreted, garbage collected, strongly and statically typed language.

Haskell

An advanced, purely functional programming language.

Haxe

Haxe is an open source high-level strictly-typed programming language with a fast optimizing cross-compiler.

Haxe can build cross-platform applications targeting JavaScript, C++, C#, Java, JVM, Python, Lua, PHP, Flash, and allows access to each platform's native capabilities. Haxe has its own VMs (HashLink and NekoVM) but can also run in interpreted mode.

Code written in Haxe can be compiled to any target Haxe supports.

Hedy

Hedy is a gradual programming language aimed at teaching programming and teaching Python. It teaches using different levels. The first level just offers printing text and asking for input. This level is meant to introduce learners to the idea of a programming language, and the environment. From there, Hedy builds up to include more complex syntax and additional concepts.

Helix

Helix is an experimental language designed for seamless interoperability with Python, C, C++, and Rust. The project aims to provide developers with a fast, efficient, and easy-to-use language that can leverage the power of existing code and libraries in these languages. With its clean syntax and robust features, Helix aims to simplify the process of writing and maintaining code while maximizing performance.

Horse64

Horse64 is a high-level language that combines readability, clean dynamic typing, and readiness for large projects

HTML

HTML (HyperText Markup Language) is the most basic building block of the Web. It defines the meaning and structure of web content. Other technologies besides HTML are generally used to describe a web page's appearance/presentation (CSS) or functionality/behavior (JavaScript).

Official Website: https://developer.mozilla.org/en-US/docs/Web/HTML

Huff

Huff is a low-level programming language designed for developing highly optimized smart contracts that run on the Ethereum Virtual Machine (EVM). Huff does not hide the inner workings of the EVM. Instead, Huff exposes its programming stack to the developer for manual manipulation.

Rather than having functions, Huff has macros - individual blocks of bytecode that can be rigorously tested and evaluated using the Huff runtime testing suite.

Huff was originally developed by the Aztec Protocol team to write Weierstrudel. Weierstrudel is an on-chain elliptical curve arithmetic library that requires incredibly optimized code that neither Solidity nor Yul could provide.

HVML

HVML is a descriptive programming language proposed and designed by Vincent Wei, who is the author of MiniGUI, one of the earliest open-source software projects in China.

PurC is the acronym of the Prime HVML inteRpreter for C/C++ language. It is also the abbreviation of Purring Cat, while Purring Cat is the nickname and the mascot of HVML.

Hylo

Hylo (formely Val) is a programming language that leverages mutable value semantics and generic programming for high-level systems programming.

Fast by definition: Hylo is compiled ahead-of-time to machine code and relies on its type system to support in-place mutation and avoid unnecessary memory allocations. Hylo avoids hidden costs such as implicit copies and therefore avoids heavy dependence on an optimizer for basic performance.
Safe by default: Hylo’s foundation of mutable value semantics ensures that ordinary code is memory safe, typesafe, and data-race-free. By explicit, auditable opt-in, programmers can use unsafe constructs for performance where necessary, and can build safe constructs using unsafe ones.
Simple: Hylo borrows heavily from Swift which has demonstrated a user-friendly approach to generic programming and deep support for value semantics. Hylo’s programming model strengthens and extends this support, while de-emphasizing reference semantics and avoiding the complexities that result from trying to make it statically safe (e.g., memory regions, lifetime annotations, etc.).

I

The I programming language is a high level programming language written in rust.

Idris

Idris is a programming language designed to encourage Type-Driven Development.

In Idris, types are first-class constructs in the langauge. This means types can be passed as arguments to functions, and returned from functions just like any other value, such as numbers, strings, or lists. This is a small but powerful idea, enabling:

relationships to be expressed between values; for example, that two lists have the same length.
assumptions to be made explicit and checked by the compiler. For example, if you assume that a list is non-empty, Idris can ensure this assumption always holds before the program is run.
if desired, properties of program behaviour to be formally stated and proven.

Imba

Imba is a Web programming language that's fast in two ways: Imba's time-saving syntax with built-in tags and styles results in less typing and switching files so you can build things fast. Imba's groundbreaking memoized DOM is an order of magnitude faster than virtual DOM libraries, so you can build fast things.

Ink

Ink is inkle's scripting language for writing interactive narrative, both for text-centric games as well as more graphical games that contain highly branching stories. It's designed to be easy to learn, but with powerful enough features to allow an advanced level of structuring.

Inko

Inko makes it easy to build concurrent software, without having to worry about unpredictable performance, unexpected runtime errors, data races, and type errors.

Inko features deterministic automatic memory management, move semantics, static typing, type-safe concurrency, efficient error handling, and more.

Inox

🛡️ Inox is a secure programming language for Web Application Development and scripting. It features a powerful shell with colorization & completions.

Repository: https://github.com/inoxlang/inox

Insitux

An extensible scripting language primarily integrated in the First Person Shooter game Deadline. It is compatible with roblox-ts enabling Roblox game integration, featuring a simple prefix syntax, exception-free parsing and execution, budgeting for expensive computations, and more.

Iridis

A Fast, Modern, Low-Level General-Purpose Programming Language

Iridis is an innovative programming language designed to cater to the needs of various domains, such as computational physics, kernel development, and game development, while remaining versatile enough to be applicable in many other areas. This language is built from the ground up to offer blazing fast performance, a modern development experience, and low-level control, empowering programmers to tackle complex problems efficiently and effectively.

Repository: https://github.com/Hachem-H/Iridis

Jactl

Jactl is a powerful scripting language for Java-based applications whose syntax borrows from Java and Groovy, with a dash of Perl thrown in for good measure. See Jactl Language Features for a quick overview of some of the language features or Jactl Language Guide for a full description of the language.

Jakt

Jakt is a memory-safe systems programming language.

It currently transpiles to C++.

Repository: https://github.com/SerenityOS/jakt

Janet

Janet is a functional and imperative programming language. It runs on Windows, Linux, macOS, BSDs, and should run on other systems with some porting. The entire language (core library, interpreter, compiler, assembler, PEG) is less than 1MB. You can also add Janet scripting to an application by embedding a single C source file and a single header.

Jasmin

Jasmin is a workbench for high-assurance and high-speed cryptography. Jasmin implementations aim at being efficient, safe, correct, and secure.

The Jasmin programming language smoothly combines high-level and low-level constructs, so as to support “assembly in the head” programming. Programmers can control many low-level details that are performance-critical: instruction selection and scheduling, what registers to spill and when, etc. They can also rely on high-level abstractions (variables, functions, arrays, loops, etc.) to structure their code and make it more amenable to formal verification.

The semantics is formally defined to allow rigorous reasoning about program behaviors. The Coq definitions can be found in the proofs/lang/sem.v file. This semantics is executable, thus Jasmin programs can be directly interpreted.

Jasmin programs can be automatically checked for safety and termination (using a trusted static analyzer).

The Jasmin compiler produces predictable assembly and ensures that the use of high-level abstractions incurs no run-time penalty. It is formally verified for correctness (the precise Coq statement and the corresponding machine-checked proofs can be found in the proofs/compiler/compiler_proof.v file). This justifies that many properties can be proved on a source program and still apply to the corresponding assembly program: safety, termination, functional correctness…

The Jasmin workbench leverages the EasyCrypt toolset for formal verification. Jasmin programs can be extracted to corresponding EasyCrypt programs to prove functional correctness, cryptographic security, or security against side-channel attacks (constant-time).

Repository: https://github.com/jasmin-lang/jasmin

Java

Java is a programming language and computing platform first released by Sun Microsystems in 1995. It has evolved from humble beginnings to power a large share of today’s digital world, by providing the reliable platform upon which many services and applications are built. New, innovative products and digital services designed for the future continue to rely on Java, as well.

JavaScript

JavaScript (JS) is a lightweight interpreted (or just-in-time compiled) programming language with first-class functions. While it is most well-known as the scripting language for Web pages, many non-browser environments also use it, such as Node.js, Apache CouchDB and Adobe Acrobat. JavaScript is a prototype-based, multi-paradigm, single-threaded, dynamic language, supporting object-oriented, imperative, and declarative (e.g. functional programming) styles.

Jinko

jinko is a small and safe interpreted language written in Rust, with integrated unit tests, mocking and FFI.

Repository: https://github.com/jinko-core/jinko

Jolie

Jolie is a service-oriented programming language, designed to offer native abstractions for the development of microservices.

Jsonnet

A configuration language for app and tool developers

Generate config data
Side-effect free
Organize, simplify, unify
Manage sprawling config

Jule

Jule is the simple, efficient, statically typed and compiled system programming language.

Jule is an open source and free programming language
Easy to learn and get started with
Extremely fast and efficient
High interoperability with C/C++
Well-written and explained manual

Julia

Julia is a high-level, high-performance dynamic language for technical computing. The main homepage for Julia can be found at julialang.org.

Julia was designed from the beginning for high performance. Julia programs compile to efficient native code for multiple platforms via LLVM.
Julia is dynamically typed, feels like a scripting language, and has good support for interactive use.
Reproducible environments make it possible to recreate the same Julia environment every time, across platforms, with pre-built binaries.
Julia uses multiple dispatch as a paradigm, making it easy to express many object-oriented and functional programming patterns. The talk on the Unreasonable Effectiveness of Multiple Dispatch explains why it works so well.
Julia provides asynchronous I/O, metaprogramming, debugging, logging, profiling, a package manager, and more. One can build entire Applications and Microservices in Julia.
Julia is an open source project with over 1,000 contributors. It is made available under the MIT license. The source code is available on GitHub.

Juvix

Juvix is an open-source, constantly evolving functional programming language designed for writing privacy-preserving decentralized applications. Using Juvix, developers can write high-level programs which can be compiled to WASM directly, or through VampIR to circuits for private execution with Taiga on Anoma or Ethereum.

kaoscript

kaoscript is programming language combining features from ES7, CoffeeScript, TypeScript, Rust, Swift, C# and more.

Kast

A first-class programming language.

Functions, types, templates, bindings, AST, IR, the compiler itself — everything is treat as value in Kast, bringing absolute power

KCL

KCL is an open-source, constraint-based record and functional language that enhances the writing of complex configurations, including those for cloud-native scenarios. With its advanced programming language technology and practices, KCL is dedicated to promoting better modularity, scalability, and stability for configurations. It enables simpler logic writing and offers ease of automation APIs and integration with homegrown systems.

KDL

KDL is a document language with xml-like semantics that looks like you're invoking a bunch of CLI commands! It's meant to be used both as a serialization format and a configuration language, much like JSON, YAML, or XML.

Kestrel

Kestrel is a threat hunting language aiming to make cyber threat hunting fast by providing a layer of abstraction to build reusable, composable, and shareable hunt-flow.

Repository: https://github.com/opencybersecurityalliance/kestrel-lang

Ki

ki is a type safe compiled language designed to be fast and easy to use. It does not have any garbage collection and instead uses ownership combined with minimal ref counting to manage memory. Alternatively you can manage your own memory using 'struct' instead of 'class'. We also allow you to compile from any platform to any platform out-of-the-box. We have generics. We have 'null' but runtime null errors do not exist. We have an awesome way to return/handle errors. Our compile times are much faster than other language (and we havent optimized it yet). We use LLVM as a back-end, so all your release code will be super optimized. We are also working on a fast/simple/versioned package manager.

Kipper

Kipper is a JavaScript-like strongly and strictly typed language with Python flavour. It aims to provide straightforward, simple, secure and type-safe coding with better efficiency and developer satisfaction!

It compiles to both JavaScript and TypeScript, and can be set up in your terminal, Node.js or ES6+ browser. 🦊💻

Kobra

Kobra is a visual programming language for machine learning, built by data scientists and engineers to make ML easy to learn and experiment with.

Koka

a strongly typed functional-style language with effect types and handlers.

Kotlin

Kotlin is a modern but already mature programming language designed to make developers happier. It's concise, safe, interoperable with Java and other languages, and provides many ways to reuse code between multiple platforms for productive programming.

Koto

Koto is an embeddable scripting language, written in Rust. It has been designed for ease of use and built for speed, with the goal of it being an ideal choice for adding scripting to Rust applications.

Koto is versatile enough to be useful in a variety of applications, although there has been a focus during development on interactive systems, such as rapid iteration during game development, or experimentation in creative coding.

Repository: https://github.com/koto-lang/koto

Lamdu

Lamdu is a programming language designed to be useful and delightful.

Text-like user interface: A predictable user interface with rich code completions, without the possiblity of syntax errors.
Responsive layout: Continuous, automatic code formatting without the user needing to deal with formatting.
Steady Typing: Harnessing the full power of rich static types, while making them friendly by employing type inference with a novel user interface for type errors.
Live reloading: Safe continuous execution of code by differentianting pure computations from effectful processes.
Internationalization (NEW!): Making the natural language of the code just a display preference.

LDPL

LDPL is a powerful and robust general-purpose compiled programming language designed from the ground up to be excessively expressive, readable, fast, and easy to learn. It mimics plain English, in the likeness of the good parts of older programming languages like COBOL. It even supports UTF-8 out of the box.

Lean

Lean is a functional programming language that makes it easy to write correct and maintainable code. You can also use Lean as an interactive theorem prover. Lean programming primarily involves defining types and functions. This allows your focus to remain on the problem domain and manipulating its data, rather than the details of programming.

Leo

🦁 The Leo Programming Language. A Programming Language for Formally Verified, Zero-Knowledge Applications.

Less

Less. The dynamic stylesheet language.

LFE

LFE is not a casual Lisp. It's a Lisp for those who want to build distributed applications -- like the Erlang software that powers 40% of the world's telecommunications.

LinguaFranca

Lingua Franca (LF) is a polyglot coordination language for concurrent and possibly time-sensitive applications ranging from low-level embedded code to distributed cloud and edge applications. An LF program specifies the interactions between components called reactors. The emphasis of the framework is on ensuring deterministic interaction with explicit management of timing. The logic of each reactor is written in one of a suite of target languages (currently C, C++, Python, and TypeScript) and can integrate legacy code in those languages. A code generator synthesizes one or more programs in the target language, which are then compiled using standard toolchains. If the application has exploitable parallelism, then it executes transparently on multiple cores without compromising determinacy. A distributed application translates into multiple programs and scripts to launch those programs on distributed machines. The communication fabric connecting components is synthesized as part of the programs.

Liquid

Liquid is an open-source template language created by Shopify and written in Ruby. It is the backbone of Shopify themes and is used to load dynamic content on storefronts.

Liquid has been in production use at Shopify since 2006 and is now used by many other hosted web applications.

LMQL

LMQL is a programming language for language model interaction.

Locutus

Locutus is a project that seeks to assimilate other languages’ standard libraries to JavaScript. Why, you ask? Well, firstly because we can of course! Apart from that, it can also serve as a nice pastime for a rainy Sunday afternoon. Not only can porting a function be quite rewarding, but it also deepens your understanding of different languages. In that sense, it is not unlike doing a crossword puzzle. Lastly it will hopefully allow us to profit from interoperable functions (for instance when apps involve more than one programming language) as well as from higher level functions such as: number_format, sprintf, and strtotime, which do not exist in JavaScript’s standard library.

Logica

Logica is an open source declarative logic programming language for data manipulation.

Logica extends syntax of logic programming for intuitive and efficient data manipulation. It compiles to SQL thus providing you access to the power of SQL engines with the convenience of logic programming syntax.

Logo

The Logo Programming Language, a dialect of Lisp, was designed as a tool for learning. Its features - interactivity, modularity, extensibility, flexibility of data types - follow from this goal.

Official Website: https://el.media.mit.edu/logo-foundation/what_is_logo/logo_programming.html

Lojban

Lojban is a carefully constructed spoken language. It has been built for over 50 years by dozens of workers and hundreds of supporters.

Lojban's grammar is based on simple rules, and its linguistic features are inspired by predicate logic. Lojban allows the expression of nuances in emotion using words called attitudinals, which are like spoken emoticons. ue marks that you're surprised; ba'u marks that you're exaggerating. You can be as vague or detailed as you like when speaking lojban. For example, specifying tense (past, present or future) or number (singular or plural) is optional when they're clear from context. Lojban is machine parsable, so the syntactic structure and validity of a sentence is unambiguous, and can be analyzed using computer tools. There is a live community of speakers expanding the lojban vocabulary day by day.

Official Website: https://mw.lojban.org/papri/Lojban

Lua

Lua is a powerful, efficient, lightweight, embeddable scripting language. It supports procedural programming, object-oriented programming, functional programming, data-driven programming, and data description.

Lua combines simple procedural syntax with powerful data description constructs based on associative arrays and extensible semantics. Lua is dynamically typed, runs by interpreting bytecode with a register-based virtual machine, and has automatic memory management with incremental garbage collection, making it ideal for configuration, scripting, and rapid prototyping.

Luau

Luau (lowercase u, /ˈlu.aʊ/) is a fast, small, safe, gradually typed embeddable scripting language derived from Lua.

Lurk

Lurk is a statically scoped dialect of Lisp, influenced by Scheme and Common Lisp.

Lurk program execution can be proved in zero-knowledge.

Lurk proofs support multiple backend SNARK proving systems.

Lux

Lux is a new programming language in the making.

It's meant to be a functional, statically-typed Lisp that will run on several platforms, such as the Java Virtual Machine and JavaScript, Python, Lua, or Ruby interpreters.

Repository: https://github.com/LuxLang/lux

m

A general purpose static-typed programming language with type inference and can be compiled as a WebAssembly module. Its syntax is like Python for ease of usability.

Madlib

Madlib is a pragmatic functional programming language which compiles to both native binary executables and JavaScript. It is similar in syntax to JavaScript (with a little bit of Haskell). Madlib embraces function composition, automatic currying, and monadic control structures.

Marko

Marko is HTML re-imagined as a language for building dynamic and reactive user interfaces. Just about any valid HTML is valid Marko, but Marko extends the HTML language to allow building modern applications in a declarative way.

MasterCSS

A markup-driven CSS language with enhanced syntax.

Master CSS provides various compilation modes, allowing you to choose according to the characteristics and needs of different projects.

Progressive Rendering - Scan the requested HTML on the server side, generate CSS rules, and enable runtime-rendering compilation on the browser side
Runtime Rendering - Observe the DOM tree, manipulate CSS rules according to the changed class name, and synchronize to the running style sheet at runtime
Static Extraction - Scan source files for class names at build time, extract class names, and generate CSS files/virtual modules, then import them in the entry file

MATLAB

Millions of engineers and scientists worldwide use MATLAB® to analyze and design the systems and products transforming our world. The matrix-based MATLAB language is the world’s most natural way to express computational mathematics. Built-in graphics make it easy to visualize and gain insights from data. The desktop environment invites experimentation, exploration, and discovery. These MATLAB tools and capabilities are all rigorously tested and designed to work together.

MATLAB helps you take your ideas beyond the desktop. You can run your analyses on larger data sets, and scale up to clusters and clouds. MATLAB code can be integrated with other languages, enabling you to deploy algorithms and applications within web, enterprise, and production systems.

Official Website: https://www.mathworks.com/help/matlab

Mech

Mech is a language for developing data-driven, reactive systems like animations, games, and robots. It makes composing, transforming, and distributing data easy, allowing you to focus on the essential complexity of your project.

Melang

Melang is a script Language of preemptive scheduling coroutine in single thread or multi-thread. It is only support on UNIX/Linux.

Melody

Melody is a language that compiles to regular expressions and aims to be more easily readable and maintainable.

Mercury

A minimal and human-readable language for the live coding of algorithmic electronic audiovisual performances.

Milone

The Milone language is an F#-subset programming language.

Repository: https://github.com/vain0x/milone-lang

MiniScript

MiniScript is modern, elegant, easy to learn, and easy to embed in your own C# or C++ projects.

Mint

The programming language for writing single page applications.

Mint has all the tools you need to write error free, easily readable and maintainable applications in record time.

Mojo

Mojo 🔥 — a new programming language for all AI developers.

Mojo combines the usability of Python with the performance of C, unlocking unparalleled programmability of AI hardware and extensibility of AI models.

morloc

morloc is a functional programming language where functions are imported from foreign languages and unified under a common type system. The compiler generates the code needed to compose functions across languages and also to direct automation of mundane tasks such as data validation, type/format conversions, data caching, distributed computing, and file reading/writing. The endgame is to develop morloc into a query language that returns optimized programs from an infinite library of functions and compositions of functions.

Repository: https://github.com/morloc-project/morloc

Moshell

Moshell is a modern shell scripting language with a static type system. This repository hosts the source code from the parser to the interpreter and its standard library.

Repository: https://github.com/moshell-lang/moshell

Motion

Motion is a dynamically typed general purpose programming language designed to help developers write fast, clean, and efficient code for a modern world.

Motion is created in pure ANSI C, with no dependancies.

Motion is a variation of the Lox language found at www.craftinginterpreters.com and is licensed under GNU GPL v3.0.

Official Website: https://github.com/MotionLang/motion

Motoko

A safe, simple, actor-based programming language for authoring Internet Computer (IC) canister smart contracts.

Moonbit

Moonbit language designed specifically for WebAssembly. Provide multiple backends including JavaScript and Native.

Support multiple programming paradigm including functional and object oriented.

Simple yet practical type system, data oriented language design. Developer with any background can start immediately.

Official Website: https://www.moonbitlang.com

MoonScript

MoonScript is a dynamic scripting language that compiles into Lua. It gives you the power of one of the fastest scripting languages combined with a rich set of features.

Move

Move is a programming language for writing safe smart contracts originally developed at Facebook to power the Diem blockchain. Move is designed to be a platform-agnostic language to enable common libraries, tooling, and developer communities across diverse blockchains with vastly different data and execution models. Move's ambition is to become the "JavaScript of web3" in terms of ubiquity--when developers want to quickly write safe code involving assets, it should be written in Move.

Repository: https://github.com/move-language/move

Mun

Mun is a programming language empowering creation through iteration.

Ahead of time compilation - Mun is compiled ahead of time (AOT), as opposed to being interpreted or compiled just in time (JIT). By detecting errors in the code during AOT compilation, an entire class of runtime errors is eliminated. This allows developers to stay within the comfort of their IDE instead of having to switch between the IDE and target application to debug runtime errors.
Statically typed - Mun resolves types at compilation time instead of at runtime, resulting in immediate feedback when writing code and opening the door for powerful refactoring tools.
First class hot-reloading - Every aspect of Mun is designed with hot reloading in mind. Hot reloading is the process of changing code and resources of a live application, removing the need to start, stop and recompile an application whenever a function or value is changed.
Performance - AOT compilation combined with static typing ensure that Mun is compiled to machine code that can be natively executed on any target platform. LLVM is used for compilation and optimization, guaranteeing the best possible performance. Hot reloading does introduce a slight runtime overhead, but it can be disabled for production builds to ensure the best possible runtime performance.
Cross compilation - The Mun compiler is able to compile to all supported target platforms from any supported compiler platform.
Powerful IDE integration - The Mun language and compiler framework are designed to support source code queries, allowing for powerful IDE integrations such as code completion and refactoring tools.

Natalie

Natalie is a work-in-progress Ruby implementation, compiled to C++.

Never

Never is a simple functional programming language. Technically it may be classified as syntactically scoped, strongly typed, call by value, functional programming language.

In practise Never offers basic data types, assignment, control flow, arrays, first order functions and some mathematical functions to make it useful to calculate expressions. Also it demonstrates how functions can be compiled, invoked and passed as parameters or results between other functions.

Nelua

Nelua (stands for Native Extensible Lua) is a minimal, efficient, statically-typed and meta-programmable systems programming language heavily inspired by Lua, which compiles to C and native code.

NeoHaskell

NeoHaskell is a dialect of Haskell that is focused on newcomer-friendliness and productivity.

It is designed to be easy to learn and use, while also being powerful enough to release your app with minimum effort and maximum confidence.

Neut

Neut is a dependently-typed programming language with static memory management.

NeXTCode

NeXTCode is a software development technology specifically designed for engineering high-reliability applications. It consists of a programming language, a verification toolset and a design method which, taken together, ensure that ultra-low defect software can be deployed in application domains where high-reliability must be assured and where safety and security are key requirements.

Nim

Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula.

Nix

The Nix language is designed for conveniently creating and composing derivations – precise descriptions of how contents of existing files are used to derive new files.

Nois

Statically typed programming language for the web.

Novika

Novika is a moldable, concise, and expressive programming language in the spirit of Forth, Self, Red/Rebol, and Lisp.

NPL

NPL or Neural Parallel Language is an open source, high-performance, scripting language. Its syntax is 100%-compatible with lua. NPL runtime provides essential functionality for building 3D/2D/Server applications that runs on windows/linux/android/iOS.

Numbat

Numbat is a statically typed programming language for scientific computations with first class support for physical dimensions and units.

Oak

Oak is a modern, compiled, low-level, statically-typed programming language. It uses Rust-like typing, without Rust's lifetimes system. It is analogous to C++ with stronger macro support, modern typing, compile-time syntax modification and integrated package management. It's like if C let you shape the language to your liking. It is named Oak because nature imagery is desperately needed in the mind of a programmer.

Oak is, as of now, a translated language; Oak code is translated via the acorn command (see later) into C++. acorn can also compile Oak into object code, or link it to create executables.

Oak has modifiable syntax (see the section on preprocessor rules), making it highly customizable and flexible in a way that no other mainstream languages are. It supports the creation of "dialects", which are Oak variants which use preprocessor rules to support independent syntactical structures. In this way, Oak provides a strong central core to many branches.

Repository: https://github.com/jorbDehmel/oak

Objeck

Objeck is a modern object-oriented programming language with functional features. It emphasizes, expression, simplicity, portability, and scalability. The programming environment consists of a compiler, virtual machine, REPL shell, and command line debugger with IDE plugins.

Objective-C

Objective-C is the primary programming language you use when writing software for OS X and iOS. It’s a superset of the C programming language and provides object-oriented capabilities and a dynamic runtime. Objective-C inherits the syntax, primitive types, and flow control statements of C and adds syntax for defining classes and methods. It also adds language-level support for object graph management and object literals while providing dynamic typing and binding, deferring many responsibilities until runtime.

Official Website: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html

Objective-J

Objective-J is a new programming language based on Objective-C. It is a superset of JavaScript, which means that any valid JavaScript code is also valid Objective-J code. Anyone familiar with JavaScript and object-oriented programming concepts, classical inheritance in particular, should have no difficulty learning Objective-J. Familiarity with Objective-C will be helpful, but it is not required.

OCaml

An industrial-strength functional programming language with an emphasis on expressiveness and safety.

OCL

The Object Constraint Language (OCL) is a language for describing rules that apply to MOF conform modelling languages like UML. The OCL is a text based language that provides constraint and object query expressions that cannot be expressed by a meta modelling language.

Repository: https://github.com/SteKoe/ocl.js

Odin

Odin is a general-purpose programming language with distinct typing built for high performance, modern systems and data-oriented programming.

Odin is the C alternative for the Joy of Programming.

Ohm

Ohm is a parsing toolkit consisting of a library and a domain-specific language. You can use it to parse custom file formats or quickly build parsers, interpreters, and compilers for programming languages.

The Ohm language is based on parsing expression grammars (PEGs), which are a formal way of describing syntax, similar to regular expressions and context-free grammars. The Ohm library provides a JavaScript interface for creating parsers, interpreters, and more from the grammars you write.

Full support for left-recursive rules means that you can define left-associative operators in a natural way.
Object-oriented grammar extension makes it easy to extend an existing language with new syntax.
Modular semantic actions. Unlike many similar tools, Ohm completely separates grammars from semantic actions. This separation improves modularity and extensibility, and makes both grammars and semantic actions easier to read and understand.
Online editor and visualizer. The Ohm Editor provides instant feedback and an interactive visualization that makes the entire execution of the parser visible and tangible. It'll make you feel like you have superpowers. 💪

Repository: https://github.com/ohmjs/ohm

Ol

Otus Lisp is a purely* functional dialect of small, embeddable and crossplatform Lisp.

One

It is an open source, self-hosted, bootstrapping system programming language which makes it easy to build reliable and efficient software.

Online-IDE

Online-IDE is a java-like programming language with IDE for computer-science-education that runs inside any browser.

Onyx

A simple, yet powerful language for WebAssembly.

OpenTofu

The main purpose of the OpenTofu language is declaring resources, which represent infrastructure objects. All other language features exist only to make the definition of resources more flexible and convenient.

OpShin

A simple pythonic programming language for Smart Contracts on Cardano.

PikaPython

PikaPython is an ultra-lightweight Python interpreter that runs with only 4KB of RAM, zero dependencies. It is ready to use out of the box without any configuration required and easy to extend with C.

Pivot

A Rust-like language with immix gc and other cool stuffs.

PLang

The P programming language.

Prog8

high level programming language and compiler targeting 6502 machines such as the C-64 and CommanderX16.

Structured Programming Language for 8-bit 6502/65c02 microprocessors.

Prolog

SWI-Prolog offers a comprehensive free Prolog environment. Since its start in 1987, SWI-Prolog development has been driven by the needs of real world applications. SWI-Prolog is widely used in research and education as well as commercial applications. Join over a million users who have downloaded SWI-Prolog.

PRQL

Pipelined Relational Query Language, pronounced "Prequel".

PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement. Like SQL, it's readable, explicit and declarative. Unlike SQL, it forms a logical pipeline of transformations, and supports abstractions such as variables and functions. It can be used with any database that uses SQL, since it compiles to SQL.

Orca

Orca is an esoteric programming language designed to quickly create procedural sequencers, in which every letter of the alphabet is an operation, where lowercase letters operate on bang, uppercase letters operate each frame.

Orchid

An experimental lazy, pure functional programming language designed to be embeddable in a Rust application for scripting.

P

P is a state machine based programming language for formally modeling and specifying complex distributed systems. P allows programmers to model their system design as a collection of communicating state machines. P supports several backend analysis engines (based on automated reasoning techniques like model checking and symbolic execution) to check that the distributed system modeled in P satisfy the desired correctness specifications.

Peregrine

Peregrine is a Compiled, Systems Programming Language, currently under development.

Repository: https://github.com/peregrine-lang/Peregrine

Perl

Perl is a highly capable, feature-rich programming language with over 30 years of development.

Pen

Pen is the parallel, concurrent, and functional programming language for scalable software development, focused on software maintainability and portability.

Penrose

Penrose is a platform that enables people to create beautiful diagrams just by typing notation in plain text. The goal is to make it easy for non-experts to create and explore high-quality diagrams and provide deeper insight into challenging technical concepts. We aim to democratize the process of creating visual intuition.

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).

Phel

Phel is a functional programming language that compiles to PHP.

It is a dialect of Lisp inspired by Clojure and Janet.

Php

A popular general-purpose scripting language that is especially suited to web development.

Fast, flexible and pragmatic, PHP powers everything from your blog to the most popular websites in the world.

Plato

Plato is an efficient and fun programming language inspired by JavaScript, C#, and Haskell. Plato is designed to be easy to teach and learn while being efficient and robust enough for commercial coding, particularly in the realm of 3D graphics.

Repository: https://github.com/cdiggins/plato

Pluto

Pluto is a unique dialect of Lua, which aims to specialize for general-purpose programming.

Pocketlang

Pocketlang is a lightweight (~3000 semicolons) and fast object oriented, embeddable scripting language written in C. It has a ruby flavoured python syntax, that can be learned within 15 minutes. Including the compiler, bytecode VM and runtime, it's a standalone executable with zero external dependencies just as it's self descriptive name. The pocketlang VM can be embedded in another hosting program very easily.

Wren Language and their wonderful book Crafting Interpreters were used as a reference to write this language.

Pony

Pony is an open-source, object-oriented, actor-model, capabilities-secure, high-performance programming language.

POWER-KI

POWER-KI (PWK) is a programming language that implements the Software Plastic Architecture (SPA) for the realization of Intelligent Applications (AI), that is applications that use all the available information, also deducing them autonomously (AI), to optimize their operation and simplify interactions with users. PWK's application areas range from IoT (Internet of Things), to supervision and control systems, to applications for the management of production and decision-making processes, to the Web and eCommerce.

Power Query M

Microsoft Power Query provides a powerful data import experience that encompasses many features. Power Query works with Analysis Services, Excel, and Power BI workbooks. A core capability of Power Query is to filter and combine, that is, to mash-up data from one or more of a rich collection of supported data sources. Any such data mashup is expressed using the Power Query M formula language. It's a functional, case sensitive language similar to F#.

Repository: https://learn.microsoft.com/en-us/powerquery-m

Prajna

a program language for AI infrastructure.

Repository: https://github.com/prajna-lang/prajna

PureScript

A small strongly typed programming language with expressive types that compiles to JavaScript, written in and inspired by Haskell.

Pyret

Pyret is a programming language designed to serve as an outstanding choice for programming education while exploring the confluence of scripting and functional programming. It's under active design and development, and free to use or modify.

Python

Python is a programming language that lets you work quickly and integrate systems more effectively.

Qore

Qore is an interpreted scripting language designed for enterprise use with:

multithreading and thread-safe programming
optional strong typing and exception handling
code embedding and sandboxing controls
automatic memory management and c++-style destructors

R

R is a free software environment for statistical computing and graphics. It compiles and runs on a wide variety of UNIX platforms, Windows and MacOS.

Racket

Racket is a general-purpose programming language and an ecosystem for language-oriented programming.

Raj

A simple, easy to use compiled programming language that can be compiled to multiple languages from a single syntax.

Raku

Raku is a language specification similar to C and C++. To actually run programs written in Raku one needs a Raku implementation. There are several implementations varying in their level of maturity and development activity.

Rascal

The one-stop shop for metaprogramming

Reason

Reason lets you write simple, fast and quality type safe code while leveraging both the JavaScript & OCaml ecosystems.

Red

Red is a next-gen programming language, strongly inspired by REBOL. Main features are:

Human-friendly syntax
Homoiconic (Red is its own meta-language and own data-format)
Functional, imperative, reactive and symbolic programming
Prototype-based object support
Multi-typing
Powerful pattern-matching Macros system
Rich set of built-in datatypes (50+)
Both statically and JIT-compiled(*) to native code
Cross-compilation done right
Produces executables of less than 1MB, with no dependencies
Concurrency and parallelism strong support (actors, parallel collections)(*)
Low-level system programming abilities through the built-in Red/System DSL
Powerful PEG parser DSL built-in
Fast, compacting Garbage Collector
Cross-platform native GUI system, with a UI layout DSL and drawing DSL
Bridging to the JVM
High-level scripting and REPL GUI and CLI consoles included
Visual Studio Code plugin, with many helpful features
Highly embeddable
Low memory footprint
Single-file (~1MB) contains whole toolchain, full standard library and REPL (**)
No install, no setup
Fun guaranteed!

Redscript

Redscript is an open-source programming language and toolset designed to work natively with Cyberpunk 2077's scripting runtime. Redscript allows modders to write scripts that extend many features such as user-interface, combat balance, and NPC behavior.

REBOL

Rebol provides an easy-to-write, easy-to-read format and a wide variety of data-types for expressing data and code.

ReScript

ReScript is a robustly typed language that compiles to efficient and human-readable JavaScript. It comes with a lightning fast compiler toolchain that scales to any codebase size.

Rhovas

Rhovas is a programming language intended for API design and enforcement. Using Rhovas, developers can better express the contracts and intention of their code to help create maintainable, correct, and performant software.

Rickroll

Rick Roll Programming Language, a language that is rickroll-based!

Ring

Simple and flexible programming language for applications development.

The Ring is a practical general-purpose multi-paradigm language. The supported programming paradigms are imperative, procedural, object-oriented, declarative using nested structures, functional, meta programming and natural programming. The language is portable (MS-DOS, Windows, Linux, macOS, Android, WebAssembly, etc.) and can be used to create Console, GUI, Web, Games and Mobile applications. The language is designed to be simple, small and flexible.

Ring is distributed as a Free-Open Source project under the MIT License.

Rivet

Rivet's goal is to be a very powerful programming language and at the same time easy to use, with a syntax that is the result of mixing Go + Zig + C# and other languages such as Python, Lua, TypeScript, D, etc.

Easy-to-learn syntax: A syntax without overload of unnecessary elements.
Named and optional arguments: Very useful, my_func(arg0: 5).
Not NULL values by default: This is only possible with option types (?T) and none.
Easy error handling: With result types, func my_func() !T { ... } and catch.
A basic preprocessor: if, else_if, else and endif for optional code using flags (-D my_flag).
Immutable values: Variables and fields are immutable by default.
Polymorphism: Traits and Embedded Structs are supported.
Generics: Specialize and reuse the same code for different types (coming soon).

Roc

Roc's goal is to be a fast, friendly, functional language. It's very much a work in progress; below, you can see the current progress towards this goal. This website is intentionally unstyled as a way to emphasize the language's current level of incompleteness. The website will become more polished after the language itself becomes more polished!

Roc compiles to machine code or to WebAssembly. Eventually you'll be able to use Roc to build high-quality servers, command-line applications, graphical native desktop user interfaces, among other classes of applications. Today, only command-line interfaces have support beyond the proof-of-concept stage; the other use cases will mature over time.

Like Lua, Roc's automatic memory management doesn't require a virtual machine, and it's possible to call Roc functions directly from any language that can call C functions. This makes Roc additionally useful as a language for implementing plugins, and gives you a way to incrementally transition a legacy code base from another language to Roc.

Rockstar

Rockstar is a dynamically typed computer programming language, designed for creating programs that are also song lyrics. Rockstar is heavily influenced by the lyrical conventions of 1980s hard rock and power ballads.

Rogue

Rogue programming language. Ergonomic, object-oriented, high-level, multi-platform, compiles to C.

Repository: https://github.com/brombres/Rogue

RowScript

RowScript is a robustly-typed functional language that compiles to efficient and reliable JavaScript.

This repository contains many components of RowScript, visit our website for more information.

Ruby

A dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write.

Rune

Rune is a dynamic programming language that is easily embeddable and has support for an exciting set of language features.

Rust

A language empowering everyone to build reliable and efficient software.

Rust is blazingly fast and memory-efficient: with no runtime or garbage collector, it can power performance-critical services, run on embedded devices, and easily integrate with other languages.

Rust’s rich type system and ownership model guarantee memory-safety and thread-safety — enabling you to eliminate many classes of bugs at compile-time.

Rust has great documentation, a friendly compiler with useful error messages, and top-notch tooling — an integrated package manager and build tool, smart multi-editor support with auto-completion and type inspections, an auto-formatter, and more.

RustPython

RustPython is a Python interpreter written in Rust. RustPython can be embedded into Rust programs to use Python as a scripting language for your application, or it can be compiled to WebAssembly in order to run Python in the browser. RustPython is free and open-source under the MIT license.

Rye

Rye is a human centric, high level, dynamic programming language based on ideas from Rebol, flavored by Factor, Linux shells and Golang. It's still an experiment in language design, but it should slowly become more and more useful in real world.

It features a Golang based interpreter and console and could also be seen as (modest) Golang's scripting companion as Go's libraries are quite easy to integrate.

R#

R# is a language and environment for GCModeller scripting and data science chart plot graphics. It is an Open source project which is similar to the R language and environment which was developed at R&D laboratory from BioNovogene corporation by Xie.Guigang. The R# language its language syntax is derived from the R language, and R# can be considered as a part of implementation of R on Microsoft .NET Framework environment. Although there are too many important differences between R# and R, but much code written for R could runs unaltered under R#.

Unlike the R Project, R# language is not focus on the statistical computing, R# try to combine the numeric computing with the .NET library programming which is comes from the GCModeller on the contrary. So in this way, R# provides a wide variety of bioinformatics analysis toolkit from GCModeller and graphical techniques, and is highly extensible.

SAS

SAS Programming enables you to write SAS programs to access, explore, prepare, and analyze data. It is the entry point to learning SAS programming for data science, machine learning, and artificial intelligence and a prerequisite to many other SAS courses.

SAS Programming is used globally across a wide range of industries. Here at SAS, we believe everybody should have the chance to learn these skills which is why we are making this in depth course available for free.

SAS is used for statistical analysis and enables users to perform tasks such as importing data from multiple sources as well as analysing and reporting. By learning SAS Programming you will be able to mine, alter, manage, retrieve and combine data from a variety of sources. With free access to our software for learning you can take advantage of an abundance of easy-to-use analytical procedures that perform complex calculations.

Official Website: https://www.sas.com/en_gb/training/courses/sas-programming.html

Sass

Sass is the most mature, stable, and powerful professional grade CSS extension language in the world.

Scala

A programming language that scales with you: from small scripts to large multiplatform applications.

Scala lets you write less to do more. As a high-level language, its modern features increase productivity and lead to more readable code. With Scala, you can combine both functional and object-oriented programming styles to help structure programs.

Scala is well suited to building fast, concurrent, and distributed systems with its JVM, JavaScript and Native runtimes. Scala prioritises interoperability, giving easy access to many ecosystems of industry-proven libraries.

Scala's static types help you to build safe systems by default. Smart built-in checks and actionable error messages, combined with thread-safe data structures and collections, prevent many tricky bugs before the program first runs.

Scallop

Scallop can be used to develop a wide variety of applications in vision and NLP that involve symbolic reasoning. The reasoning component is specified via logic rules which can then be deeply integrated with machine learning models, such as convolutional neural networks and transformers.

Scheme

Scheme is a classic programming language in the Lisp family. It emphasizes functional programming and domain-specific languages but adapts to other styles. Known for its clean and minimalist design, Scheme is one of the longest-lived and best-studied dynamic languages, and has many fast and portable implementations.

Scratch

Scratch is the world's most popular coding community for kids. Millions of kids around the world are using Scratch to program their own interactive stories, games, and animations—and share their creations in an active online community. In the process, they are learning to think creatively, reason systematically, and work collaboratively, while also learning important mathematical and computational ideas. In the past year, more than 20 million people created projects with Scratch.

Official Website: https://www.media.mit.edu/projects/scratch/overview

Shake

Shake is a high level, object-oriented, multi-targeting, modern programming language. It can be compiled into different languages (targets), such as C, C++, C#, Java, JavaScript and binary executables as well as interpreted (currently the only implemented target is JavaScript). It also provides a scripting language for faster and more efficient creation of small projects.

Shard

Shard is an assembly inspired programming language, focusing on:

Unstructured Programming- Like in assembly the code is executed in sequence and forgetting to return will cause the program to continue executing the next instruction.
Freedom - Memory, Syscalls, Registers, labels, and jumps are all exposed to the programmer. Allowing for fine grained control over the program.
Operator Oriented Syntax - Most functions of the language are shortened to a single symbol, keywords and directives are all 3 characters.
Type Simplicity - There’s three types: struct, data, and pointer. You also aren’t limited by having to cast between types, you can just use the type as if it were another. The types are there for you not the compiler.

Shen

Our mission is to bring the power of Shen technology to every major programming platform used by industry and deliver to programmers the great power of Shen.

The word 'Shen' means 'highest spirit' in Chinese and indicates our goal is to transcend the divisions between computer languages.

Shiika

Shiika is a programming language that makes me most productive.

Easy to write like Ruby or Python
Static type checking (Null safety!)
Object-oriented but has enums and pattern-matching
Written in Rust, compiles to single binary via LLVM IR

Repository: https://github.com/shiika-lang/shiika

Sidef

Sidef is a modern, high-level, general-purpose programming language, inspired by Ruby, Raku and Julia.

Sigma

Sigma is a compiled, statically typed, C-like, data oriented language with a focus on performance and low-level optimization using GPU acceleration via kernels.

Repository: https://github.com/Goubermouche/sigma

Silice

Silice is an open source language that simplifies prototyping and writing algorithms on FPGA architectures.

Silice is an easy-to-learn, powerful hardware description language, that allows both to prototype ideas quickly and then refine designs to be compact and efficient.

Silice achieves this by offering a few, carefully designed high level design primitives atop a low level description language. In particular, Silice allows to write and combine algorithms, pipelines and per-cycle logic in a coherent, unified way. It features a powerful instantiation-time pre-processor, making it easy to describe parametric designs.

Silice offers a ready-to-go design environment, supporting many FPGA boards, both open-source and proprietary. It natively supports simulation and formal verification.

Silice syntax is simple, explicit and easy to read, and should feel familiar to C programmers and Verilog designers alike.

Repository: https://github.com/sylefeb/Silice

Silver

Silver is an extensible attribute grammar system that support many modern extensions to Knuth's original design. These include higher-order attributes, reference attributes, forwarding, aspects, and collections attributes. Its type system support parametric polymorphism. Silver is distributed with Copper, a parser and context-aware scanner generator.

It is designed for the modular development of composable language extensions, with language features and analyses to support this.

Slim

Slim is a template language whose goal is to reduce the view syntax to the essential parts without becoming cryptic. It started as an exercise to see how much could be removed from a standard html template (<, >, closing tags, etc...). As more people took an interest in Slim, the functionality grew and so did the flexibility of the syntax.

Smithy

Smithy is a language for defining services and SDKs.

Snapi

Snapi is new a data manipulation language designed to filter and combine data from many data sources in real-time. It has a rich built-in library with ready-to-use connectors to the most common data formats, data lakes and databases.

Repository: https://github.com/raw-labs/snapi

Solidity

A statically-typed curly-braces programming language designed for developing smart contracts that run on Ethereum.

Som

Som is functional programming made simple. It offers everything the casual functional programmer would want in a straightforward and consise manner. Because of this, it is great for both those who are newcomers to functional programming and those who feel like the big functional languages like Haskell are a bit too complex or hard-to-read.

Spice

Spice is a compiled language which sets a focus on performance and practicality. It is considered as a systems language, which means it is especially useful to write cli tools or device drivers. Spice supports cross-compilation to all target platforms.

SQL

SQL (short for Structured Query Language) is a domain-specific language used in programming and designed for managing data held in a relational databases.

Stylus

Expressive, dynamic, and robust CSS.

An expressive, robust, feature-rich CSS language built for Node.js

SuperCollider

An audio server, programming language, and IDE for sound synthesis and algorithmic composition.

SuperCollider is a platform for audio synthesis and algorithmic composition, used by musicians, artists, and researchers working with sound. It consists of:

scsynth, a real-time audio server with hundreds of unit generators ("UGens") for audio analysis, synthesis, and processing
supernova, an alternative server to scsynth with support for parallel DSP on multi-core processors
sclang, an interpreted programming language that controls the servers
scide, an editing environment for sclang with an integrated help system sclang comes with its own package manager, called Quarks. scsynth and supernova both support third-party plugins via C and C++ APIs.

SuperCollider is written in C++17 using several third-party libraries, including Qt and Boost. It can be used on Windows, macOS, a variety of Linux and BSD distributions, Raspberry Pi, and BeagleBone Black.

Sway

Sway is a domain-specific language (DSL) for the Fuel Virtual Machine (FuelVM), a blockchain-optimized VM designed for the Fuel blockchain. Sway is based on Rust, and includes syntax to leverage a blockchain VM without needlessly verbose boilerplate.

Swift

Swift is a general-purpose programming language built using a modern approach to safety, performance, and software design patterns.

The goal of the Swift project is to create the best available language for uses ranging from systems programming, to mobile and desktop apps, scaling up to cloud services. Most importantly, Swift is designed to make writing and maintaining correct programs easier for the developer.

Tao

A statically-typed functional language with polymorphism, typeclasses, algebraic effects, sum types, pattern-matching, first-class functions, currying, good diagnostics, and much more!

Tcl

Tcl (Tool Command Language) is a very powerful but easy to learn dynamic programming language, suitable for a very wide range of uses, including web and desktop applications, networking, administration, testing and many more. Open source and business-friendly, Tcl is a mature yet evolving language that is truly cross platform, easily deployed and highly extensible.

Tk is a graphical user interface toolkit that takes developing desktop applications to a higher level than conventional approaches. Tk is the standard GUI not only for Tcl, but for many other dynamic languages, and can produce rich, native applications that run unchanged across Windows, Mac OS X, Linux and more.

Tengo

Tengo is a small, dynamic, fast, secure script language for Go.

Tengo is fast and secure because it's compiled/executed as bytecode on stack-based VM that's written in native Go.

The

The Programming Language is a rapid, minimalistic, elegant, high-performance, high-level programming language.

Unique: The syntax was produced by a combination of best features of all known programming languages in the world
Fast: Speed of programs produced by The Programming Language is so fast that comparable with writing applications in The C Programming Language
Helpful: The Programming Language takes care of everything for you, so that you can focus on writing code
Portable: The Programming Language works on all popular operating systems
Cloud-Based: The Programming Language runs in cloud which allows to reduce time spent on installing and compiling
Official Website: https://thelang.io
Repository: https://github.com/thelang-io/the

TICKscript

The TICKscript language is an invocation chaining language used to define data processing pipelines.

Official Website: https://docs.influxdata.com/kapacitor/v1/reference/spec

Twig

Twig is a template language for PHP.

Twig uses a syntax similar to the Django and Jinja template languages which inspired the Twig runtime environment.

Toit

Toit is optimised for live reloading on your microcontroller. Your code runs incrementally as you write it and you get instant feedback. Push changes over your local WiFi in two seconds and reserve your USB cable for charging your phone. You iterate quickly, learn fast, and build better things.

Tokay

Tokay is a programming language designed for ad-hoc parsing.

Tokay is a programming language to quickly implement solutions for text processing problems. This can either be just simple data extractions, but also parsing entire structures or parts of it, and turning information into structured parse trees or abstract syntax trees for further processing.

TOML

TOML aims to be a minimal configuration file format that's easy to read due to obvious semantics. TOML is designed to map unambiguously to a hash table. TOML should be easy to parse into data structures in a wide variety of languages.

Triton

a language and compiler for writing highly efficient custom Deep-Learning primitives. The aim of Triton is to provide an open-source environment to write fast code at higher productivity than CUDA, but also with higher flexibility than other existing DSLs.

Tu

Tu lang is a programming language designed to create a very simple zero dependency (no glibc) dynamic&static language with fully static linking.

Repository: https://github.com/tu-lang/tu

Turbofuro

A dynamic visual programming language focused on developer experience, high-level abstractions and API consumption making it easy to build incredible apps quickly.

[Official Website]https://turbofuro.com): https://turbofuro.com
Repository: https://github.com/turbofuro/turbofuro

TypeScript

TypeScript is JavaScript with syntax for types.

TypeScript is a strongly typed programming language that builds on JavaScript, giving you better tooling at any scale.

Uiua

Uiua (wee-wuh 🔉) is a stack-oriented array programming language with a focus on simplicity, beauty, and tacit code.

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.

Repository: https://github.com/vtereshkov/umka-lang

Unison

Unison is a modern, statically-typed purely functional language with the ability to describe entire distributed systems using a single program.

No more writing encoders and decoders at every network boundary. Say where you want computations to run and it happens 🔮 — Dependencies are deployed on the fly.
Your codebase is always live and typechecks, even in the middle of a refactoring. Unison has structured refactoring sessions, not a big misleading list of type errors.
No more writing translation code between your values and the storage layer. Directly store values and unpersist them later without fear of dependency conflicts or version mismatches.
Other tools try to recover structure from text; Unison stores code in a database. This eliminates builds, provides for instant nonbreaking renames, type-based search, and lots more.
Many dependency conflicts arise from definitions competing for the same names. Since Unison references code by hash instead of by name, an entire class of conflicts can be eliminated.

unit

unit is a General Purpose Visual Programming Language and Environment built with a primary focus on Developer Experience.

It is heavily inspired by Live, Data Flow, Reactive, Functional and Object Oriented Programming paradigms. Formally, units are Multi Input Multi Output (MIMO) Finite State Machines (FSM). A program in unit is represented as a Graph.

Ursa

A friendly, stable, general-purpose programming-language.

Ursa helps you write code that will last a long time: a simple, general-purpose programming language that is easy to pick up and will work the same way long into the future.

V

Simple, fast, safe, compiled. For developing maintainable software.

V is very similar to Go. If you know Go, you already know ≈80% of V.

Vala

Vala is a programming language that aims to bring modern programming language features to GNOME developers without imposing any additional runtime requirements and without using a different ABI compared to applications and libraries written in C.

Official Website: https://vala.dev
Repository: hhttps://gitlab.gnome.org/GNOME/vala

Vale

Vale is a programming language that's aims to be not only fast and memory-safe, but also easy and flexible.

Fast: Vale is AOT compiled to LLVM, statically-typed, and uses the new generational references technique for memory safety with speed and flexibility, and will soon have region borrow checking to make it even faster.
Safe: It is the safest native language, thanks to generational references and Fearless FFI.
Easy: Vale has memory-safe single ownership without garbage collection or a borrow checker, which makes it easy to write safe, fast code.

Vein

Vein is an open source experimental high-level strictly-typed programming language with a standalone OS, arm and quantum computing support.

Virgil

Virgil is a programming language designed for building lightweight high-performance systems. Its design blends functional and object-oriented programming paradigms for expressiveness and performance. Virgil's compiler produces optimized, standalone native executables, WebAssembly modules, or JARs for the JVM. For quick turnaround in testing and debugging, programs can also be run directly on a built-in interpreter. It is well-suited to writing small and fast programs with little or no dependencies, which makes it ideal for the lowest level of software systems. On native targets, it includes features that allow building systems that talk directly to kernels, dynamically generate machine code, implement garbage collection, etc. It is currently being used for virtual machine and programming language research, in particular the development of a next-generation WebAssembly virtual machine, Wizard.

Repository: https://github.com/titzer/virgil

VisionScript

VisionScript is an abstract programming language for doing common computer vision tasks, fast.

VisionScript is built in Python, offering a simple syntax for running object detection, classification, and segmentation models.

VisualBasic

Visual Basic is an object-oriented programming language developed by Microsoft. Using Visual Basic makes it fast and easy to create type-safe .NET apps.

ViviFire

ViviFire is a brand new open-source programming language with modern features and a familiar syntax. It offers object-oriented programming with genericity and traits, modularity, units of measure, and more.

Void

Void is a virtual-machine-based programing language designed for developers to be able to create clean, fast and stable multi-platform applications.

It has has a relatively easy syntax, that follows most of the already existing code conventions.

Void features many utilities that enchant the experience of coding, such as object destruction, variable redeclaration, multi-returning, and much more.

Vox

Vox is a multiparadigm programming language inspired by D (60%), Jai (30%), and Zig (10%).

Repository: https://github.com/MrSmith33/vox

Vyper

Vyper is a contract-oriented, pythonic programming language that targets the Ethereum Virtual Machine (EVM).

Vyxal

Vyxal is a golfing language that takes the idea that conciseness comes at the cost of practicality and throws it out the window. That's right - where other golflangs throw you into the deep-end of keyboard mashing, Vyxal eases you into the concept of elegantly crafting built-ins into a functioning program.

Wa

Wa is a general-purpose programming language designed for developing robustness and maintainability WebAssembly software. Instead of requiring complex toolchains to set up, you can simply go install it - or run it in a browser.

Wasp

Wasp (Web Application Specification) is a Rails-like framework for React, Node.js and Prisma. Build your app in a day and deploy it with a single CLI command!

🚀 Quick start: Due to its expressiveness, you can create and deploy a production-ready web app from scratch with very few lines of concise, consistent, declarative code.
😌 No boilerplate: By abstracting away complex full-stack features, there is less boilerplate code. That means less code to maintain and understand! It also means easier upgrades.
🔓 No lock-in: You can deploy Wasp app anywhere you like. There is no lock-in into specific providers, you have full control over the code (and can actually check it out in .wasp/ dir if you are interested ).

WebX

A framework for building minimal but powerful web app backends, REST APIs, and hypermedia systems.

wenyan

文言, or wenyan, is an esoteric programming language that closely follows the grammar and tone of classical Chinese literature. Moreover, the alphabet of wenyan contains only traditional Chinese characters and 「」 quotes, so it is guaranteed to be readable by ancient Chinese people.

Wing

Wing combines infrastructure and runtime code in one language, enabling developers to stay in their creative flow, and to deliver better software, faster and more securely.

Wing is a new open-source programming language designed for the cloud (aka "cloud-oriented"). Wing enables developers to build distributed systems that leverage cloud services as first-class citizens by combining infrastructure and application code in a safe and unified programming model (aka "cloud-oriented"). Wing programs can be executed locally (yes, no internet required) using a fully-functional simulator, or deployed to any cloud provider (yes, Wing programs are portable across providers).

Wipple

Wipple is a programming language that’s natural to read, write and learn.

Wolfram

The Wolfram Language is a symbolic language that has been carefully designed to have the breadth and uniformity needed to rapidly develop powerful programs. By integrating high-level formats such as Image, GeoPolygon or Molecules, and high-level hyperfunctions such as ImageIdentify or ApplyReaction, the Wolfram Language makes it possible to quickly express complex ideas in computational form.

Official Website: https://www.wolfram.com/language

Wren

The Wren Programming Language. Wren is a small, fast, class-based concurrent scripting language.

Think Smalltalk in a Lua-sized package with a dash of Erlang and wrapped up in a familiar, modern syntax.

Wren is small. The VM implementation is under 4,000 semicolons. You can skim the whole thing in an afternoon. It’s small, but not dense. It is readable and lovingly-commented.
Wren is fast. A fast single-pass compiler to tight bytecode, and a compact object representation help Wren compete with other dynamic languages.
Wren is class-based. There are lots of scripting languages out there, but many have unusual or non-existent object models. Wren places classes front and center.
Wren is concurrent. Lightweight fibers are core to the execution model and let you organize your program into a flock of communicating coroutines.
Wren is a scripting language. Wren is intended for embedding in applications. It has no dependencies, a small standard library, and an easy-to-use C API. It compiles cleanly as C99, C++98 or anything later.

Wu

An expression oriented, gradually typed and mission-critical programming language.

Wybe

The Wybe programming language is intended to be easy to learn and easy to use, but powerful and efficient enough for practical use. It is intended to support best programming practice, but not necessarily common practice.

Wybe combines the best features of declarative and imperative languages, in particular borrowing features from functional, logic, imperative, and object-oriented languages, but does not neatly fit into any of these paradigms. Its main organising principle is interface integrity, which indicates that all information that flows between a procedure or function and its caller must be part of the interface (the signature) of that procedure or function. Semantically, values are immutable (Wybe has value semantics), but variables may be reassigned. This means that data structures may be passed around at will without worrying that they may be unexpectedly modified, yet conventional looping constructs can be used freely.

Repository: https://github.com/pschachte/wybe

Yak

In order to improve the development process of security products and hacking tools, we have created a new language ( Yaklang) and implemented a stack-based virtual machine (YakVM) for this language.

Yaklang is a Turing-complete procedural language defined by context-free grammar. It runs on YakVM.

Yaksha

A manual memory managed, compiled to C99.

programming language with off-side rule syntax.

Za

Za is a scripting language intended to perform system administration tasks. It can act as a control mechanism for Bash or other similarly-behaved shells.

Za comes with a small function library built-in for avoiding overly arcane means of performing simple shell tasks.

Za has a only a small set of dependencies which are most likely already installed on your target platforms.

Za is designed to inter-operate with the shell efficiently. Use cases are lightweight scripting, integration, system preparation and similar system administrator tasks.

Zenroom

Smart-contracts in human-like language.

Zenroom is a secure language interpreter of both Lua and its own secure domain specific language (DSL) to execute fast cryptographic operations using elliptic curve arithmetics.

The Zenroom VM is very small, has no external dependency, is fully deterministic and ready to run end-to-end encryption on any platform: desktop, embedded, mobile, cloud micro-services, web browsers. It can be embedded inside applications written in Javascript, Python3, Rust or Golang.

Zencode is the name of the DSL executed by Zenroom: it is similar to human language and can process large data structures while operating cryptographic transformations and basic logical operations on them.

Zurfur

Zurfur is a programming language taking inspiration from C#, Golang and Javascript

Zig

Zig is a general-purpose programming language and toolchain for maintaining robust, optimal and reusable software.

Focus on debugging your application rather than debugging your programming language knowledge.
Focus on debugging your application rather than debugging your programming language knowledge.
Incrementally improve your C/C++/Zig codebase.

Name		Name	Last commit message	Last commit date
Latest commit History 74 Commits
.gitignore		.gitignore
README.md		README.md

wyasher/programming-language-navigator

Folders and files

Latest commit

History

Repository files navigation

Introduction

Programming Languages

Functional programming language based on pure de Bruijn indexed lambda calculus.