List of programming languages by type

This is a list of notable programming languages, grouped by their important features. Since a language can have many features, the same language might appear in more than one group. Understanding these groups helps people choose the right language for different kinds of projects. Programming languages are tools that let people tell computers what to do, and knowing their types can make it easier to learn and use them well. This list shows how different languages are used in many areas, from making websites to controlling big scientific tools.

Agent-oriented programming languages

Main article: Agent-oriented programming

Agent-oriented programming helps developers create and work with special parts of software called software agents. These agents can send messages to each other, making them different from regular objects in programming. Some languages that support this way of programming include Clojure, F#, GOAL, and SARL.

Array languages

Main category: Array programming languages

Array programming (also called vector or multidimensional) languages let you work with groups of numbers easily. Instead of dealing with one number at a time, you can apply the same operation to many numbers together, like in lists or grids. This makes it simpler to handle big sets of data or pictures in computer programs.

Aspect-oriented programming languages

Main article: Aspect-oriented programming

Aspect-oriented programming helps developers add new features to their code without changing the existing code. Instead, it uses something called a pointcut to add these features to specific parts of the program.

Some languages that use this approach include Ada, AspectJ, Groovy, Nemerle, and Raku.

Assembly languages

Main article: Assembly language

For a more comprehensive list, see Comparison of assemblers.

Assembly languages are special kinds of programming languages that closely match the basic instructions a computer can understand. They let programmers write code using easier-to-read names instead of complex numbers. Special programs called assemblers then turn these names into the actual instructions the computer uses. These languages also let programmers use shortcuts called macros and special values known as symbolic constants to make coding simpler.

Authoring languages

Main article: Authoring language

An authoring language is a type of programming language made for people who aren’t computer experts. It helps them easily make tutorials, websites, and other fun interactive programs on a computer.

Some examples of these languages include Darwin Information Typing Architecture (DITA), Lasso, PILOT, TUTOR, and Authorware.

Command-line interface languages

Main article: Command-line interface

Command-line interface (CLI) languages are special tools that help users give commands to computers through text. These are sometimes called batch languages or job control languages. Some common examples include:

• 4DOS (shell for IBM PCs)
• 4OS2 (shell for IBM PCs)
• Batch files for DOS and Windows
  • COMMAND.COM command language for DOS and pre-Windows NT Windows
  • cmd.exe command language for Windows NT
• sh
  • ksh
  • bash
  • zsh
• CLIST (MVS Command List)
• CMS EXEC
• csh
  • tcsh
  • Hamilton C shell
• DIGITAL Command Language CLI for OpenVMS
• EXEC 2
• Expect
• fish
• Nushell
• Windows PowerShell
• rc
• Rexx
• TACL (programming language)

Compiled languages

Main article: Compiled language

These are languages that are usually turned into machine code by special programs called compilers. While any language could potentially be compiled or interpreted, these languages are known for using compilers to prepare the code for execution.

Concatenative programming languages

Main article: Concatenative programming language

A concatenative programming language is a special kind of computer language where all commands represent actions, and putting commands next to each other means doing those actions one after another.

Some examples of these languages are Factor, Forth, jq, Joy, PostScript, and Raku.

Concurrent languages

Main category: Concurrent programming languages

For a more comprehensive list, see List of concurrent and parallel programming languages.

Some programming languages help computers do many things at once. These languages use special ways to let parts of a program talk to each other. One way is by sharing the same information, which many popular languages like Java use. Other languages let programs exchange messages, inspired by ideas from processes that can talk to each other.

Constraint programming languages

Main article: Constraint programming

A constraint programming language is a type of declarative programming where you set rules, called constraints, about how different values should relate to each other. The program works by trying to find values that fit all the rules you made.

• Claire
• Constraint Handling Rules
• CHIP
• ECLiPSe
• Kaleidoscope
• Oz
• Raku

Contract languages

Design by contract is a way of programming where certain rules, called preconditions, postconditions, and invariants, are set before and after actions to make sure programs work correctly. These rules help developers catch mistakes early and build better software.

Curly bracket languages

A curly bracket or curly brace language uses special symbols called curly brackets, or braces, {} to show groups of commands in its code. This way of writing code started with a language called BCPL in 1966 and became well-known because of the language C. Many other languages either came from C or were greatly inspired by it. Some examples of these languages include:

Dataflow languages

Dataflow programming languages use a special way to show how data moves to create a program. This is often shown in a picture. These languages are good for reacting to specific events or handling lots of data that flows continuously.

Data-oriented languages

Data-oriented languages help people find and change relationships between different groups of things, like in tables that show how one group connects to another. These languages include several types of programming tools that work with this idea of connecting data.

Decision table languages

Decision tables help make logic clear before writing a program. In the 1960s, some languages let you write code using decision tables right from the start. One of these languages was Filetab.

Declarative languages

Main category: Declarative programming languages

Declarative languages describe what a computation should achieve without detailing how it should be done. This is different from imperative programming, where steps are given in a specific order. Pure functional and logic-based programming languages are types of declarative languages. This section includes more examples that do not fall into these two groups.

Embeddable languages

Embeddable languages let you put small pieces of code inside other text, like on a web page.

For web pages you see in a browser, there are client-side languages. These work right in your browser to make pages more lively without needing to check back with the website’s computer.

For web pages made by the website’s computer, there are server-side languages. These are more flexible because many different languages can be used. The goal is to add more content to the web page automatically. When the page loads, the code disappears and only the result shows up.

Server-side examples include PHP, VBScript, and Tcl. Other languages like Erlang, Scala, Perl, and Ruby can also be used this way.

Client-side examples include ActionScript and JavaScript (aka ECMAScript or JScript), with VBScript working only on Windows.

Other languages can be added to bigger programs by including their interpreter. This lets users type in code that the program can understand. Smaller interpreters are usually chosen for this.

Educational programming languages

For a more comprehensive list, see List of educational programming languages.

These are programming languages made just for helping people learn how to program. They are designed to be easy and clear, so students and beginners can understand them better while they are learning.

Esoteric languages

Main category: Esoteric programming languages

An esoteric programming language is a special kind of language made to test how far we can push the rules of computer programming. These languages are sometimes created just to show a new idea or for fun.

Extension languages

Extension programming languages are special types of languages that fit inside bigger programs. They help add new features or change how things work in those programs.

Fourth-generation languages

Main category: Fourth-generation programming languages

Fourth-generation programming languages are special kinds of high-level programming languages that work closely with database systems. People often use them in businesses and companies for their tasks.

Functional languages

Main category: Functional languages

Functional programming languages let you create programs and small tasks by using math-like functions. These functions are very important and can be used just like any other value in the program. Some of these languages are called "impure" because they also include features from another type of programming. Many functional languages are often used with tools that help with math calculations. Examples of functional languages include:

Hardware description languages

For a more comprehensive list, see List of hardware description languages.

In electronics, a hardware description language (HDL) is a special type of computer language used to describe how electronic circuits are built and work. These languages are especially useful for designing digital logic circuits. The two most common HDLs used today are Verilog and VHDL.

HDLs for analog circuit design

• Verilog-AMS (Verilog for Analog and Mixed-Signal)
• VHDL-AMS (VHDL with Analog/Mixed-Signal extension)

HDLs for digital circuit design

Imperative languages

Imperative programming languages tell a computer exactly what steps to take to solve a problem. Many of these languages can also work in other ways besides just the imperative style. Here is a list of some languages that use the imperative paradigm:

Interactive mode languages

Interactive mode languages, also known as REPL, work like a shell. With these languages, you can type in expressions or commands one at a time and see the results right away. This makes it easy to test ideas and explore programming quickly.

Interpreted languages

Interpreted languages are types of programming languages where you can run programs directly from their original code using a special program called an interpreter. While some languages can be changed into a different form to run faster, interpreted languages are usually run this way right from the start. This makes them easy to use and test quickly.

Iterative languages

Iterative languages are designed around or include features called generators. These help manage repeated tasks in a program more efficiently.

Languages by memory management type

Some programming languages help manage memory for you, while others let you do it yourself. Memory management is how a computer keeps track of the space it uses for programs.

Garbage Collection (GC) is a way for computers to clean up memory that programs no longer need. This happens automatically.

Other languages need you to manage memory yourself, which can be more work but gives you more control. Some languages offer choices, letting you decide how to manage memory.

List-based languages – LISPs

List-based languages are special kinds of programming languages that use a data structure called a list to organize information.

Some examples of these languages include Joy, R, Source, Tcl (which also includes Tea), and TRAC.

Little languages

Little languages are special tools used for solving specific problems.

For example, awk helps change text files, sed can parse and change text, and SQL is used to work with databases, though it has fewer features than full programming languages. XPL was made mainly for creating other programming languages.

Logic-based languages

Main category: Logic programming languages

Logic-based languages describe what a solution should look like, instead of how to find it.

Some well-known languages in this category are:

• ALF
• Alma-0
• Curry
• Datalog
• Fril
• Flix (a functional programming language with special rules)
• Janus
• λProlog (a logic programming language with flexible types and modules)
• Oz, and Mozart Programming System cross-platform Oz
• Prolog (uses math-like logic to solve problems)
  • Mercury (based on Prolog)
  • Visual Prolog (an object-oriented version of Prolog)
• ROOP
• Soufflé

Machine languages

Machine languages are special sets of instructions that a computer's brain, called the CPU, can understand and run right away. These instructions are made up of patterns of zeros and ones, often shown in octal or hexadecimal form. Each pattern tells the CPU to do a basic job, like adding numbers or moving data.

Because each type of CPU is built differently, machine languages are unique to each family of processors. This means that code written for one type of CPU usually won’t work on another type unless that CPU has special features to support it. Both the machine language and its easier-to-read version, called assembly language, are created by the people who make the CPU. Some well-known machine code instruction sets include:

Macro languages

Main category: Macro programming languages

Macro languages help change one piece of code into another. They work by replacing short pieces of text with longer ones, sometimes using special rules. These tools can make writing code easier by letting you reuse parts of it.

Some macro languages only work on special parts of the code, like those starting with a #. Others can work anywhere but still need to understand basic code rules to avoid mistakes. They can be used with many different programming languages.

• C preprocessor
• m4 (originally from AT&T, bundled with Unix)
• ML/I (general-purpose macro processor)
• TTM (developed at the California Institute of Technology)

Scripting languages like Tcl and JavaScript are also used inside applications. Sometimes these are called macro languages too, even though they work a bit differently from the simple text-replacing macros.

Metaprogramming languages

Metaprogramming is when you write programs that can create or change other programs. These special programs can do some of the work that usually happens when the computer is running, but they do it earlier, when the program is being prepared. This helps programmers finish their work faster because they don't have to write every single line of code themselves.

Modular languages

Main article: Comparison of programming languages (syntax) § Consuming external software

Modular programming is a way to organize parts of a program into separate pieces called modules. This helps make programs easier to understand and manage.

Multiparadigm languages

Main article: Comparison of multi-paradigm programming languages

Multiparadigm languages can use more than one way to write programs. This means programmers can pick the best style for each part of their work, because no single way works perfectly for every problem.

Numerical analysis

See also: List of numerical-analysis software and List of numerical libraries

Some general-purpose programming languages, like C and Python, are used for technical computing. This list highlights languages mainly used for technical computing.

Non-English-based languages

Main article: Non-English-based programming languages

Some programming languages use words from other languages instead of English. For example, there are languages that use Chinese, Icelandic, French, Russian, and Tamil to give commands to computers. These languages help people who speak those languages to work more easily with computers.

Object-oriented class-based languages

Class-based object-oriented programming languages let you create objects based on their class. These classes include data that belongs to the object. Sending messages is an important idea in these languages, sometimes even the main idea.

Functions that can change based on the type of object they work with are often called methods. In languages with single dispatch, classes usually include the definitions of these methods. In languages with multiple dispatch, methods are part of generic functions. Some languages mix these ideas, like Bigloo’s object system.

Object-oriented prototype-based languages

Prototype-based languages are a type of object-oriented languages. In these languages, the difference between classes and individual objects is not made. This means objects can directly create other objects without needing a class as a blueprint.

Off-side rule languages

Main article: Off-side rule § Off-side rule languages

Some programming languages use how far a line of code is pushed to the right to decide where a group of commands starts and ends. This is called the off-side rule. In these languages, spaces or tabs at the beginning of a line are important and help organize the code.

Procedural languages

Procedural programming languages are based on the idea of steps and the range of data that each step can see. A program made with these languages is built from one or more parts, either written by a user or found in a code library. Each part is made of one or more procedures, which can also be called functions, routines, subroutines, or methods, depending on the language. Examples of these types of languages include:

Query languages

Main article: Query language

Query languages are special tools used to ask questions and get information from databases. They help people find exactly what they need by using simple commands. These languages are important for working with large amounts of data and making sense of it.

Reflective languages

Reflective programming languages allow programs to look at and change their own structure while they are running or being created. This feature is often found in high-level programming environments like Smalltalk, and it is less common in lower-level languages like C.

Some languages and systems that support this ability include:

See also: Aspect-oriented programming

Rule-based languages

Rule-based languages are special kinds of programming languages that use rules. These rules only start working when certain conditions in the data are met. When the conditions are right, the rules choose what to do next and run the statements linked to them.

Scripting languages

Main article: Scripting language

Scripting languages are special kinds of computer languages that help control what a computer does. They are often used to make things happen automatically, like when you click a button on a website. These languages can be very easy to learn and use for small tasks or big projects.

Stack-based languages

Main category: Stack-oriented programming languages

Stack-based languages are a special kind of programming language that use a structure called a stack. A stack is like a pile where you add things on top and take things off from the top. These languages work by using this pile-like structure to manage their data.

Synchronous languages

Main category: Synchronous programming languages

Synchronous programming languages are special types of languages made to help build systems that react quickly, even when they get interrupted often. These systems are sometimes called realtime systems and are used in tiny computers inside other devices, known as embedded systems.

Some examples of these languages include:

• Argus
• Averest
• Esterel
• Lustre
• Signal
• Céu (programming language)

Shading languages

See also: Category:Shading languages

A shading language is a special type of computer language used to create effects in graphics. These languages include unique data types, such as "color" and "normal", to help design visual effects.

Shading languages are used in two main ways. For real-time rendering, they allow programmers more control and flexibility, creating richer content without using too many resources. In offline rendering, these languages focus on producing the highest image quality, but the process can take a lot of time and computational power to achieve photorealistic results.

Syntax-handling languages

These languages help create tools that can read and understand code by breaking it down into smaller parts. They are useful for building other programming languages or tools that process text.

Some examples include ANTLR, Coco/R, GNU bison, GNU Flex, JavaCC, lex, M4, Parsing expression grammar, Prolog, Emacs Lisp, Lisp, Raku, SableCC, Scheme, yacc, and XPL.

System languages

A system programming language is used for important tasks like managing memory or handling tasks. These languages help create the software that makes computers work, such as operating systems and tools that support other programs.

Examples of system languages include:

Transformation languages

Main article: Transformation language

Transformation languages help change code written in one way into another way. They are often used in big systems to make sure that one part's results can be used by the next part. This makes complex tasks easier to manage.

Visual languages

Main category: Visual programming languages

Visual programming languages allow people to create programs using pictures and layouts instead of just text. These special languages can help make programming easier to understand by using graphics. Some types of dataflow programming are also considered visual languages.

Wirth languages

Computer scientist Niklaus Wirth created several important programming languages. One of these languages is PL360.

XML-based languages

These are languages that are based on or work with XML. They help organize and share information in a structured way.