List of concurrent and parallel programming languages

Short description: none

This article lists concurrent and parallel programming languages, categorizing them by a defining paradigm. Concurrent and parallel programming languages involve multiple timelines. Such languages provide synchronization constructs whose behavior is defined by a parallel execution model. A concurrent programming language is defined as one which uses the concept of simultaneously executing processes or threads of execution as a means of structuring a program. A parallel language is able to express programs that are executable on more than one processor. Both types are listed, as concurrency is a useful tool in expressing parallelism, but it is not necessary. In both cases, the features must be part of the language syntax and not an extension such as a library (libraries such as the posix-thread library implement a parallel execution model but lack the syntax and grammar required to be a programming language).

The following categories aim to capture the main, defining feature of the languages contained, but they are not necessarily orthogonal.

## Contents

* 1 Coordination languages
* 2 Dataflow programming
* 3 Distributed computing
* 4 Event-driven and hardware description
* 5 Functional programming
* 6 Logic programming
* 7 Monitor-based
* 8 Multi-threaded
* 9 Object-oriented programming
* 10 Partitioned global address space (PGAS)
* 11 Message passing
* 11.1 Actor model
* 11.2 CSP-based
* 12 APIs/frameworks
* 13 See also
* 14 References

## Coordination languages

* CnC (Concurrent Collections)
* Glenda
* Linda coordination language
* Millipede

## Dataflow programming

Main article: Dataflow programming

* Binary Modular Dataflow Machine (BMDFM)
* CAL
* E – and object-oriented
* Joule – and distributed
* LabVIEW – and synchronous, object-oriented
* Lustre – and synchronous
* Preesm – and synchronous
* SIGNAL – and synchronous
* SISAL

## Distributed computing

Main article: Distributed computing

* Bloom
* Emerald
* Hermes
* Julia
* Limbo
* MPD
* Oz \- Multi-paradigm language with particular support for constraint and distributed programming.
* Sequoia
* SR

## Event-driven and hardware description

Main articles: Event-driven programming and Hardware Description Language

* Esterel (also synchronous)
* SystemC
* SystemVerilog
* Verilog
* Verilog-AMS \- math modeling of continuous time systems
* VHDL

## Functional programming

Main article: Functional programming

* Clojure
* Concurrent ML
* Elixir
* Elm
* Erlang
* Futhark
* Gleam
* Haskell
* Id
* MultiLisp
* SequenceL

## Logic programming

Main article: Concurrent logic programming

* Constraint Handling Rules[1]
* Parlog
* Mercury

## Monitor-based

Main article: Monitor (synchronization)

* Concurrent Pascal
* Concurrent Euclid
* Emerald

## Multi-threaded

* C=
* Cilk
* Cilk Plus
* Cind
* C#
* Clojure
* Concurrent Pascal
* Delphi
* Emerald
* Fork – programming language for the PRAM model.
* Go
* Java
* LabVIEW
* ParaSail
* Python
* Rust[2]
* SequenceL

## Object-oriented programming

Main article: Object-oriented programming

* Ada
* C*
* C++
* C#
* JavaScript
* TypeScript
* C++ AMP
* Charm++
* Cind
* D
* Delphi
* Eiffel Simple Concurrent Object-Oriented Programming (SCOOP)
* Emerald
* Fortran – from ISO Fortran 2003 standard
* GDScript[3]
* Java
* Join Java – has features from join-calculus
* LabVIEW
* ParaSail
* Python[4]
* Ruby

## Partitioned global address space (PGAS)

Main article: Partitioned global address space

* Chapel
* Coarray Fortran (included in standard/ISO Fortran since Fortran 2008, further extensions were added with the Fortran 2018 standard)
* Fortress
* High Performance Fortran
* Titanium
* Unified Parallel C
* X10
* ZPL

## Message passing

Main article: Message passing

* Ateji PX \- An extension of Java with parallel primitives inspired from pi-calculus.
* Rust[5]
* Smalltalk[6]: p.17 Part IV, see table following fig. 11–29

### Actor model

Main article: Actor model

* Axum \- a domain-specific language being developed by Microsoft.
* Dart \- using Isolates
* Elixir (runs on BEAM, the Erlang virtual machine)
* Erlang
* Pony
* Janus
* Red
* SALSA
* Scala/Akka (toolkit)
* Smalltalk
* Akka.NET
* LabVIEW \- LabVIEW Actor Framework

### CSP-based

Main article: Communicating sequential processes

* Alef
* Crystal[7]
* Ease
* FortranM
* Go
* JCSP
* JoCaml
* Joyce
* Limbo (also distributed)
* Newsqueak
* Occam
* Occam-π – a derivative of Occam that integrates features from the pi-calculus
* PyCSP
* SuperPascal
* XC – a C-based language, integrating features from Occam, developed by XMOS

## APIs/frameworks

These application programming interfaces support parallelism in host languages.

* Apache Beam
* Apache Flink
* Apache Hadoop
* Apache Spark
* CUDA
* OpenCL
* OpenHMPP
* OpenMP for C, C++, and Fortran (shared memory and attached GPUs)
* Message Passing Interface for C, C++, and Fortran (distributed computing)
* SYCL

## See also

* Concurrent computing
* List of concurrent programming languages
* Parallel programming model

## References

1. ↑ Thom Frühwirth (9 July 2009). Constraint Handling Rules. Cambridge University Press. ISBN 978-0-521-87776-3. https://books.google.com/books?id=BKiy7ohjpBUC&q=concurrent.
2. ↑ "Using Threads to Run Code Simultaneously - The Rust Programming Language" (in en). https://doc.rust-lang.org/book/ch16-01-threads.html.
3. ↑ "Using multiple threads". https://docs.godotengine.org/en/stable/tutorials/performance/using_multiple_threads.html.
4. ↑ Documentation » The Python Standard Library: Concurrent Execution
5. ↑ "Using Message Passing to Transfer Data Between Threads - The Rust Programming Language" (in en). https://doc.rust-lang.org/book/ch16-02-message-passing.html.
6. ↑ Alan Kay The Early History Of Smalltalk
7. ↑ "Crystal Programming Language – Concurrency". https://crystal-lang.org/docs/guides/concurrency.html. Retrieved 10 August 2018.

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/List of concurrent and parallel programming languages. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=List_of_concurrent_and_parallel_programming_languages&oldid=4414715"