Random Programming Language Generator

One press draws a programming language: year, paradigm and one fact, plus designer and typing where its article names them.

  1. sed1974. By Lee E. McMahon. Scripting. Short for stream editor: it transforms text by way of a script.
All 96

How it works

Press the button for a random programming language, in use today or of historical weight. Each card gives its first year, main paradigm and one line about it, plus designer and typing where its article names them.

Read the full guide

Pick by paradigm or decade

After your first press, a list under the button reads Any paradigm. Choose Procedural, Object-oriented, Functional, Logic and declarative, Array or Scripting, and each press draws from that group only. Its last entry, More filters, adds a decade, from Before 1970 to the 2010s.

Ways to use the draw

Draw one for a study group's language of the month. Press several times for a challenge night where everyone solves the same puzzle in a different language: no language comes twice until all have come up. For a history of computing lesson, choose Before 1970, press a few times and put the languages in date order.

Tips
  • The list is a selection, not a ranking: no card says one language is better or more popular than another.

Questions and answers

What coding languages should I learn?

This page does not choose for you, and no card ranks a language. Draw a few and read each card: some say what the language is used for, such as web pages, statistics, operating systems or teaching. The facts are the same whichever you pick.

How were the programming languages chosen?

It is our own selection of languages in wide use and languages that mattered historically, each with an encyclopedia article that gives a year and a paradigm. It is not complete, and it copies no popularity index.

What do static and dynamic typing mean on a card?

Static type checking verifies a program's type safety from its source code, before it runs. Dynamic type checking does so at runtime. A card repeats what the language's article gives and says nothing where the article gives neither.

All 96 languages

Procedural 32

  • ABC 1987. By Leo Geurts, Lambert Meertens and Steven Pemberton. Procedural. For teaching or prototyping.
  • Ada 1980. By Jean Ichbiah; later versions by Tucker Taft. Procedural, static typing. Inspired by Pascal.
  • ALGOL 60 1960. By Backus, Naur and eleven others. Procedural, static typing. Among the first with recursive functions.
  • ALGOL 68 1968. By A. van Wijngaarden and others. Procedural, static typing. Conceived as a successor to ALGOL 60.
  • BASIC 1964. By John G. Kemeny and Thomas E. Kurtz. Procedural. Made at Dartmouth College for non-science students.
  • BCPL 1967. By Martin Richards. Procedural. First meant for writing compilers; a cut-down version, B, led to C.
  • C 1972. By Dennis Ritchie. Procedural, static typing. Used for operating systems and device drivers.
  • CLU 1975. By Barbara Liskov and her students. Procedural. It introduced abstract data types and iterators.
  • COBOL 1960. By Howard Bromberg, Jean E. Sammet and others. Procedural, static typing. English-like, for business.
  • COMAL 1975. By Børge R. Christensen and Benedict Løfstedt. Procedural. Developed in Denmark and based on BASIC.
  • CPL 1963. By Christopher Strachey and others. Procedural. An early ancestor of C, by way of BCPL and B.
Show all 96 languages (85 more)

Procedural, continued

  • D 2001. By Walter Bright. Procedural, static typing. Began as a re-engineering of C++.
  • FLOW-MATIC 1955. By Grace Hopper. Procedural. The first English-like data processing language; it helped shape COBOL.
  • Forth 1970. By Charles H. Moore. Procedural. A stack-oriented language and interactive development environment.
  • Fortran 1957. By John Backus. Procedural, static typing. For numeric computation and scientific computing.
  • Go 2009. By Robert Griesemer, Rob Pike and Ken Thompson. Procedural, static typing. Compiled; designed in 2007.
  • HyperTalk 1987. By Dan Winkler. Procedural. A discontinued language aimed at beginning programmers.
  • Icon 1977. By Ralph Griswold. Procedural, dynamic typing. Based on the concept of goal-directed execution.
  • JOVIAL 1960. Procedural, static typing. Based on ALGOL 58 and specialized for developing embedded systems.
  • Modula-2 1978. By Niklaus Wirth. Procedural, static typing. Made for the software of the Lilith workstation.
  • Modula-3 1988. By Luca Cardelli and five others. Procedural, static typing. Influential in research circles.
  • MUMPS 1966. By Neil Pappalardo and two others. Procedural. First built for hospital medical and laboratory records.
  • Nim 2008. By Andreas Rumpf. Procedural, static typing. A compiled system programming language.
  • Oberon 1987. By Niklaus Wirth. Procedural, static and dynamic typing. Made to reduce the complexity of Modula-2.
  • Occam 1983. By David May. Procedural. A concurrent language named after the philosopher William of Ockham.
  • Pascal 1970. By Niklaus Wirth. Procedural, static typing. Small and efficient, to encourage structured programming.
  • PL/I 1964. Procedural. Designed for scientific, engineering, business and system programming.
  • Plankalkül 1948. By Konrad Zuse. Procedural. The first high-level language designed for a computer.
  • PostScript 1982. By John Warnock, Chuck Geschke and others. Procedural, dynamic typing. A page description language.
  • SNOBOL 1962. By David J. Farber, Ralph Griswold and Ivan P. Polonsky. Procedural. Text-string-oriented languages.
  • Turing 1982. By Ric Holt and James Cordy. Procedural, static typing. A descendant of Pascal, made for students.
  • Zig 2016. By Andrew Kelley. Procedural, static typing. A system language designed as an improvement to C.

Object-oriented 25

  • ActionScript 1998. By Gary Grossman. Object-oriented, static typing. Influenced by HyperTalk; now a form of ECMAScript.
  • C# 2000. By Anders Hejlsberg. Object-oriented, static and dynamic typing. A general-purpose language.
  • C++ 1985. By Bjarne Stroustrup. Object-oriented, static typing. First released as an extension of C.
  • Chapel 2009. By David Callahan and three others. Object-oriented, static typing. A parallel programming language.
  • Crystal 2014. By Ary Borenszweig and two others. Object-oriented, static typing. Compiled; syntax inspired by Ruby.
  • Dart 2011. By Lars Bak and Kasper Lund. Object-oriented, static typing. For web, mobile, server and desktop apps.
  • Eiffel 1986. By Bertrand Meyer. Object-oriented, static typing. Aimed at more reliable commercial software.
  • Groovy 2003. By James Strachan. Object-oriented, static and dynamic typing. A language for the Java platform.
  • Haxe 2005. By Nicolas Cannasse. Object-oriented, static and dynamic typing. One code-base for many platforms.
  • Io 2002. By Steve Dekorte. Object-oriented, dynamic typing. Pure object-oriented, with a prototype-based model.
  • Java 1995. By James Gosling. Object-oriented, static typing. Compiled code runs on any Java virtual machine.
  • Kotlin 2011. By Andrey Breslav. Object-oriented, static typing. Designed to interoperate fully with Java.
  • Objective-C 1984. By Brad Cox and Tom Love. Object-oriented, static and dynamic typing. Smalltalk-style messaging in C.
  • Python 1991. By Guido van Rossum. Object-oriented, dynamic typing. Stresses code readability; indentation counts.
  • Ruby 1995. By Yukihiro Matsumoto. Object-oriented, dynamic typing. Everything is an object, even primitive types.
  • Rust 2012. By Graydon Hoare. Functional and object-oriented, static typing. Stresses performance and type safety.
  • S 1976. By John Chambers and others. Object-oriented, dynamic typing. A statistical programming language.
  • Self 1987. By David Ungar and Randall Smith. Object-oriented, dynamic typing. Based on the concept of prototypes.
  • Simula 1962. By Ole-Johan Dahl and Kristen Nygaard. Object-oriented, static typing. Simula 67 introduced classes.
  • Smalltalk 1972. By Alan Kay, Dan Ingalls and Adele Goldberg. Object-oriented, dynamic typing. First made for education.
  • Solidity 2014. By Gavin Wood. Object-oriented, static typing. For smart contracts on blockchain platforms.
  • Swift 2014. By Chris Lattner and four others. Object-oriented, static typing. Uses an LLVM-based compiler.
  • TypeScript 2012. By Anders Hejlsberg and Luke Hoban. Object-oriented. It adds static typing to JavaScript.
  • Vala 2006. By Jürg Billeter and Raffaele Sandrini. Object-oriented, static typing. Its compiler generates C code.
  • Visual Basic 1991. Object-oriented, static typing. Based on BASIC; known for rapid development of graphical interfaces.

Functional 20

  • Agda 1999. By Catarina Coquand (1.0) and Ulf Norell (2.0, 2007). Functional, static typing. Dependently typed.
  • Clojure 2007. By Rich Hickey. Functional, dynamic typing. A dialect of Lisp on the Java platform.
  • Common Lisp 1984. By Scott Fahlman, Guy Steele and four others. Functional, dynamic typing. A standardized Lisp dialect.
  • Elixir 2012. By José Valim. Functional, dynamic typing. Runs on the BEAM virtual machine and builds on Erlang.
  • Elm 2012. By Evan Czaplicki. Functional, static typing. For graphical user interfaces in the web browser.
  • Erlang 1986. By Joe Armstrong, Robert Virding and Mike Williams. Functional, dynamic typing. A concurrent language.
  • F# 2005. By Don Syme. Functional, static typing. Most often used as a cross-platform language on .NET.
  • Factor 2003. By Slava Pestov. Functional, dynamic typing. Stack-oriented, with automatic memory management.
  • Haskell 1990. By Paul Hudak, Simon Peyton Jones and others. Functional, static typing. Named after Haskell Curry.
  • Idris 2007. By Edwin Brady. Functional. Purely functional, with dependent types; also usable as a proof assistant.
  • Lisp 1960. By John McCarthy. Functional, dynamic typing. Parenthesized prefix notation; short for list processing.
  • Logo 1967. By Wally Feurzeig and two others. Functional, dynamic typing. A teaching language with turtle graphics.
  • Miranda 1985. By David Turner. Functional, static typing. A lazy, purely functional language.
  • ML 1973. By Robin Milner and others. Functional, static typing. Made for the Edinburgh LCF theorem prover.
  • OCaml 1996. By Xavier Leroy and others. Functional, static typing. Extends the Caml dialect of ML with objects.
  • R 1993. By Ross Ihaka and Robert Gentleman. Functional, dynamic typing. For statistics and data visualization.
  • Racket 1995. Functional, static and dynamic typing. A Lisp dialect descended from Scheme, made for language design.
  • Scala 2004. By Martin Odersky. Functional, static typing. Also object-oriented; it compiles to JVM bytecode.
  • Scheme 1975. By Guy L. Steele and Gerald Jay Sussman. Functional, dynamic typing. A dialect of Lisp.
  • Standard ML 1983. Functional, static typing. Popular for writing compilers and developing theorem provers.

Logic and declarative 4

  • Mercury 1995. By Zoltan Somogyi. Logic, static typing. A functional logic language related to Prolog and Haskell.
  • Oz 1991. By Gert Smolka and his students. Logic, dynamic typing. Made for programming-language education.
  • Prolog 1972. By Alain Colmerauer. Logic. A program is a set of facts and rules, with roots in first-order logic.
  • SQL 1973. By Donald D. Chamberlin and Raymond F. Boyce. Declarative, static typing. Manages relational data.

Array 4

  • APL 1966. By Kenneth E. Iverson. Array, dynamic typing. Built on multidimensional arrays, with special symbols.
  • J 1990. By Kenneth E. Iverson and Roger Hui. Array, dynamic typing. Based on APL, using only ASCII characters.
  • Julia 2012. By Jeff Bezanson and three others. Array, dynamic typing. Multiple dispatch is a core paradigm.
  • MATLAB Late 1970s. By Cleve Moler. Array, dynamic typing. For matrices and plots; the name means Matrix Laboratory.

Scripting 10

  • AWK 1977. By Alfred Aho, Peter Weinberger and Brian Kernighan. Scripting. For text processing and reporting.
  • Bash 1989. By Brian Fox. Scripting. A command language for Unix-like systems; short for Bourne Again SHell.
  • CoffeeScript 2009. By Jeremy Ashkenas. Scripting, dynamic typing. Compiles to JavaScript; syntax inspired by Ruby.
  • JavaScript 1995. By Brendan Eich. Scripting, dynamic typing. A core technology of the Web, alongside HTML and CSS.
  • Lua 1993. By Roberto Ierusalimschy and two others. Scripting, dynamic typing. For embedded use in applications.
  • Perl 1987. By Larry Wall. Scripting, dynamic typing. A Unix scripting language made to ease report processing.
  • PHP 1995. By Rasmus Lerdorf. Scripting, dynamic typing. Geared toward web development.
  • PowerShell 2006. By Jeffrey Snover and two others. Scripting, dynamic typing. A shell for task automation.
  • Rexx 1979. By Mike Cowlishaw. Scripting, dynamic typing. For scripting, application macros and applications.
  • sed 1974. By Lee E. McMahon. Scripting. Short for stream editor: it transforms text by way of a script.

Other 1

  • Scratch 2003. By Mitchel Resnick, Yasmin Kafai and others. Event-driven, block-based. A visual language for children.

How this list was compiled: Own selection of 96 programming languages, in use today or of historical weight, written for this page on 2026-10-01. It is a selection, not a complete list, and it ranks nothing and copies no popularity index. Coverage was checked against https://en.wikipedia.org/wiki/List_of_programming_languages and https://en.wikipedia.org/wiki/Timeline_of_programming_languages . Every card's year, designer, paradigm and typing were read from the infobox and opening section of the language's own English Wikipedia article through the Wikipedia API on 2026-10-01 (address kept in x.src), and a script confirmed that the year, the names and the words of each line stand in that text. The year is the year the article's infobox gives for the first appearance; where the infobox gives none, it is the year the opening section gives. The designer is given only where the article names people; a company or committee is not printed, so five cards name no one. Where the article names more than three people the card names up to three and counts or mentions the others; every name is kept in x.designer. Where the article says that others took part (CPL, ML, S, Oz, Scratch), the card says and others or and his students; the D card names its first designer, and Andrei Alexandrescu, who joined in 2007, is kept in x.designer. The paradigm group is our reading of the main paradigm among those the article lists (kept in x.paradigmFromArticle); one language (Rust) sits in two groups because its opening names both and no main one. Two exceptions: the article on Julia marks multiple dispatch as its primary paradigm, which is none of the six groups, so Julia sits under Array, one of the others it lists; and the article on Scratch lists only event-driven and block-based, so Scratch sits in no paradigm group and its card repeats those two words. Six languages (Rexx, Perl, Bash, JavaScript, PHP and PowerShell) sit under Scripting on the wording of the article's text, which calls each a scripting language or a shell that runs scripts, not on its infobox. Static or dynamic typing repeats the article's typing field and is left out where the field gives neither word. The Decade filter puts the 17 languages that appeared before 1970 under one value. The official site or reference page named in the article's infobox was also fetched for 53 languages on 2026-10-01; 16 of those front pages name the designer or give the year, and x.siteCheck says which. The other cards rest on the Wikipedia article alone. Left out on purpose: markup languages, esoteric languages, and anything about which language to learn first, which is advice. The definitions of static and dynamic type checking in the page copy are from https://en.wikipedia.org/wiki/Type_system , read the same day. Language names are the names of the things listed; this site is not affiliated with any language's maker or foundation. Licence: own work