{
  "id": "programming-languages-paradigms",
  "name": "Programming Languages with Paradigms and History",
  "title": "Programming Languages with Paradigms and History",
  "description": "692 programming languages with structured metadata including first release year, programming paradigms (object-oriented, functional, imperative, etc.), type system characteristics, and Wikipedia source links.",
  "category": "tech",
  "source": "https://github.com/raulpy271/languagesDataset",
  "source_url": "https://github.com/raulpy271/languagesDataset",
  "updated": "2026-04",
  "record_count": 692,
  "columns": [
    {
      "key": "name",
      "label": "Name",
      "type": "string"
    },
    {
      "key": "source",
      "label": "Source",
      "type": "string"
    },
    {
      "key": "about",
      "label": "About",
      "type": "string"
    },
    {
      "key": "first_release",
      "label": "First Release",
      "type": "number"
    },
    {
      "key": "types",
      "label": "Types",
      "type": "string"
    },
    {
      "key": "paradigms",
      "label": "Paradigms",
      "type": "string"
    },
    {
      "key": "website",
      "label": "Website",
      "type": "string"
    }
  ],
  "rows": [
    {
      "name": "a.net",
      "source": "https://en.wikipedia.org/wiki/A_Sharp_(.NET)",
      "about": "A# is a port of the Ada programming language to the Microsoft .NET platform. A# is freely distributed by the Department of Computer Science at the United States Air Force Academy as a service to the Ada community under the terms of the GNU General Public License.",
      "first_release": "2004",
      "types": "",
      "paradigms": "",
      "website": "http://www.asharp.martincarlisle.com/"
    },
    {
      "name": "a-0 system",
      "source": "https://en.wikipedia.org/wiki/A-0_System",
      "about": "The A-0 system (Arithmetic Language version 0), written by Grace Murray Hopper [1] in 1951 and 1952 for the UNIVAC I, was an early[2] compiler related tool developed for electronic computers.[3] The A-0 functioned more as a loader or linker than the modern notion of a compiler. A program was specified as a sequence of subroutines and arguments. The subroutines were identified by a numeric code and the arguments to the subroutines were written directly after each subroutine code. The A-0 system converted the specification into machine code that could be fed into the computer a second time to execute the said program.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "a+",
      "source": "https://en.wikipedia.org/wiki/A%2B_(programming_language)",
      "about": "A+ is an array programming language descended from the programming language A, which in turn was created to replace APL in 1988.[2] Arthur Whitney developed the A portion of A+, while other developers at Morgan Stanley extended it, adding a graphical user interface and other language features. A+ is a high-level, interactive, interpreted language, designed for numerically intensive applications, especially those found in financial applications. A+ runs on many Unix variants, including Linux. It is free and open source software released under a GNU General Public License.",
      "first_release": "1988",
      "types": "Dynamic, strong",
      "paradigms": "Array",
      "website": "http://www.aplusdev.org/"
    },
    {
      "name": "abap",
      "source": "https://en.wikipedia.org/wiki/ABAP",
      "about": "ABAP (Advanced Business Application Programming, originally Allgemeiner Berichts-Aufbereitungs-Prozessor, German for \"general report creation processor\"[3]) is a high-level programming language created by the German software company SAP SE. It is extracted from the base computing languages Java, C, C++ and Python. It is currently positioned, alongside Java, as the language for programming the SAP NetWeaver Application Server, which is part of the SAP NetWeaver platform for building business applications.",
      "first_release": "1983",
      "types": "Static, strong, safe, nominative",
      "paradigms": "Object-oriented, structured, imperative",
      "website": "http://scn.sap.com/community/abap"
    },
    {
      "name": "abc",
      "source": "https://en.wikipedia.org/wiki/ABC_(programming_language)",
      "about": "ABC is an imperative general-purpose programming language and integrated development environment (IDE) developed at Centrum Wiskunde & Informatica (CWI), Netherlands by Leo Geurts, Lambert Meertens, and Steven Pemberton. It is interactive, structured, high-level, and intended to be used instead of BASIC, Pascal, or AWK. It is intended for teaching or prototyping, but not as a systems-programming language.",
      "first_release": "1987",
      "types": "strong, polymorphic",
      "paradigms": "multi-paradigm, imperative, procedural, structured",
      "website": "https://homepages.cwi.nl/~steven/abc/"
    },
    {
      "name": "abc algol",
      "source": "https://en.wikipedia.org/wiki/ABC_ALGOL",
      "about": "ABC ALGOL is an extension of the programming language ALGOL 60 with arbitrary data structures and user-defined operators, intended for computer algebra (symbolic mathematics). Despite its advances, it was never used as widely as Algol proper.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "acc",
      "source": "https://en.wikipedia.org/wiki/ACC_(programming_language)",
      "about": "ACC is a near-C compiler for the MS-DOS operating system on the IBM PC line of computers for programs.[1] The compiler and compiled programs will run on any Intel 80386 or above PC running MS-DOS. Included with the compiler are a 386 assembler and a linker for combining multiple object files.[2] There are also two libraries, which are a protected mode DOS extender (based on Thomas Pytel's, AKA Tran's PMODE30B + PMODE307 DOS extenders), and a library of functions callable by C programs.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "accent",
      "source": "https://en.wikipedia.org/wiki/Accent_(programming_language)",
      "about": "Rational Synergy is a software tool that provides software configuration management (SCM) capabilities for all artifacts related to software development including source code, documents and images as well as the final built software executable and libraries. Rational Synergy also provides the repository for the change management tool known as Rational Change. Together these two tools form an integrated configuration management and change management environment that is used in software development organizations that need controlled SCM processes and an understanding of what is in a build of their software.",
      "first_release": "1990",
      "types": "",
      "paradigms": "",
      "website": "http://www.ibm.com/software/products/en/ratisyne"
    },
    {
      "name": "ace dasl",
      "source": "https://en.wikipedia.org/wiki/Distributed_Application_Specification_Language",
      "about": "The DASL Programming Language (Distributed Application Specification Language) is a high-level, strongly typed programming language originally developed at Sun Microsystems Laboratories between 1999 and 2003 as part of the Ace Project. The goals of the project were to enable rapid development of web-based applications based on Sun's J2EE architecture, and to eliminate the steep learning curve of platform-specific details.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "action!",
      "source": "https://en.wikipedia.org/wiki/Action!_(programming_language)",
      "about": "Action! is a procedural programming language similar to ALGOL that is intended to produce high-performance programs for the Atari 8-bit family. The language was written by Clinton Parker and distributed on ROM cartridge by Optimized Systems Software (OSS) starting in 1983. It was one of the first of OSS's bank switching \"Super Cartridges\", with a total of 16 kB of code.",
      "first_release": "1983",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "actionscript",
      "source": "https://en.wikipedia.org/wiki/ActionScript",
      "about": "ActionScript is an object-oriented programming language originally developed by Macromedia Inc. (later acquired by Adobe Systems). It is influenced by HyperTalk, the scripting language for HyperCard.[2] It is now an implementation of ECMAScript (meaning it is a superset of the syntax and semantics of the language more widely known as JavaScript), though it originally arose as a sibling, both being influenced by HyperTalk.",
      "first_release": "1998",
      "types": "strong, static",
      "paradigms": "Multi-paradigm, object-oriented, prototype-based, functional, imperative, scripting",
      "website": "https://www.adobe.com/devnet/actionscript/articles/actionscript3_overview.html"
    },
    {
      "name": "actor",
      "source": "https://en.wikipedia.org/wiki/Actor_(programming_language)",
      "about": "The Actor programming language was invented by Charles Duff of The Whitewater Group in 1988. It was an offshoot of some object-oriented extensions to the Forth language he had been working on.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "ada",
      "source": "https://en.wikipedia.org/wiki/Ada_(programming_language)",
      "about": "Ada is a structured, statically typed, imperative, and object-oriented high-level programming language, extended from 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. Ada improves code safety and maintainability by using the compiler to find errors in favor of runtime errors. Ada is an international technical standard, jointly defined by the International Organization for Standardization (ISO), and the International Electrotechnical Commission (IEC). As of 2020, the standard, called Ada 2012 informally,[7] is ISO/IEC 8652:2012.[8]",
      "first_release": "1980",
      "types": "static, strong, safe, nominative",
      "paradigms": "Multi-paradigm",
      "website": "http://www.adaic.org/"
    },
    {
      "name": "adenine",
      "source": "https://en.wikipedia.org/wiki/Adenine_(programming_language)",
      "about": "Haystack is a project at the Massachusetts Institute of Technology to research and develop several applications around personal information management and the Semantic Web. The most notable of those applications is the Haystack client, a research personal information manager (PIM) and one of the first to be based on semantic desktop technologies. The Haystack client is published as open source software under the BSD license.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "advpl",
      "source": "https://en.wikipedia.org/wiki/AdvPL",
      "about": "AdvPL (Advanced Protheus Language) is a proprietary programming language based on xBase. It was released in 1999 and is used for development of applications in the ERP Protheus made by TOTVS.[2][1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "agda",
      "source": "https://en.wikipedia.org/wiki/Agda_(theorem_prover)",
      "about": "Agda is a dependently typed functional programming language originally developed by Ulf Norell at Chalmers University of Technology with implementation described in his PhD thesis.[2] The original Agda system was developed at Chalmers by Catarina Coquand in 1999.[3] The current version, originally known as Agda 2, is a full rewrite, which should be considered a new language that shares a name and tradition.",
      "first_release": "1999",
      "types": "strong, static, dependent, nominal, manifest, inferred",
      "paradigms": "Functional",
      "website": "http://wiki.portal.chalmers.se/agda"
    },
    {
      "name": "agilent vee",
      "source": "https://en.wikipedia.org/wiki/Agilent_VEE",
      "about": "Keysight VEE is a graphical dataflow programming software development environment from Keysight Technologies for automated test, measurement, data analysis and reporting. VEE originally stood for Visual Engineering Environment and developed by HP designated as HP VEE; it has since been officially renamed to Keysight VEE. Keysight VEE has been widely used in various industries, serving the entire stage of a product lifecycle, from design, validation to manufacturing. It is optimized in instrument control and automation with test and measurement devices such as data acquisition instruments like digital voltmeters and oscilloscopes, and source devices like signal generators and programmable power supplies.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.keysight.com/find/vee"
    },
    {
      "name": "agora",
      "source": "https://en.wikipedia.org/wiki/Agora_(programming_language)",
      "about": "Agora is a reflective, prototype-based, object-oriented programming language that is based exclusively on message passing and not delegation. Agora was intended to show that even subject to that limit, it is possible to build a full object-oriented language that features inheritance, cloning and reflective operators.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "aimms",
      "source": "https://en.wikipedia.org/wiki/AIMMS",
      "about": "AIMMS (acronym for Advanced Interactive Multidimensional Modeling System) is a prescriptive analytics software company with offices in the Netherlands, United States, China and Singapore.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.aimms.com/"
    },
    {
      "name": "aldor",
      "source": "https://en.wikipedia.org/wiki/Aldor",
      "about": "Aldor is a programming language. It is the successor of A# as the extension language of the Axiom computer algebra system.",
      "first_release": "1990",
      "types": "",
      "paradigms": "Multi-paradigm, object-oriented, functional, imperative, dependent typed, logic",
      "website": "http://www.aldor.org/"
    },
    {
      "name": "alef",
      "source": "https://en.wikipedia.org/wiki/Alef_(programming_language)",
      "about": "Alef is a discontinued concurrent programming language, designed as part of the Plan 9 operating system by Phil Winterbottom of Bell Labs. It implemented the channel-based concurrency model of Newsqueak in a compiled, C-like language.",
      "first_release": "1992",
      "types": "Static, strong",
      "paradigms": "compiled, concurrent, structured",
      "website": ""
    },
    {
      "name": "alf",
      "source": "https://en.wikipedia.org/wiki/Algebraic_Logic_Functional_programming_language",
      "about": "Algebraic Logic Functional programming language, also known as ALF, is a programming language which combines functional and logic programming techniques. Its foundation is Horn clause logic with equality which consists of predicates and Horn clauses for logic programming, and functions and equations for functional programming.",
      "first_release": "",
      "types": "",
      "paradigms": "multi-paradigm, logic, functional",
      "website": "http://www.informatik.uni-kiel.de/~mh/systems/ALF/README"
    },
    {
      "name": "algol 58",
      "source": "https://en.wikipedia.org/wiki/ALGOL_58",
      "about": "ALGOL 58, originally named IAL, is one of the family of ALGOL computer programming languages. It was an early compromise design soon superseded by ALGOL 60. According to John Backus[2]",
      "first_release": "1958",
      "types": "Static, strong",
      "paradigms": "procedural, imperative, structured",
      "website": ""
    },
    {
      "name": "algol 60",
      "source": "https://en.wikipedia.org/wiki/ALGOL_60",
      "about": "ALGOL 60 (short for Algorithmic Language 1960) is a member of the ALGOL family of computer programming languages. It followed on from ALGOL 58 which had introduced code blocks and the begin and end pairs for delimiting them, representing a key advance in the rise of structured programming. ALGOL 60 was the first language implementing nested function definitions with lexical scope. It gave rise to many other programming languages, including CPL, Simula, BCPL, B, Pascal, and C. Practically every computer of the era had a systems programming language based on ALGOL 60 concepts.",
      "first_release": "1960",
      "types": "Static, strong",
      "paradigms": "procedural, imperative, structured",
      "website": ""
    },
    {
      "name": "algol 68",
      "source": "https://en.wikipedia.org/wiki/ALGOL_68",
      "about": "ALGOL 68 (short for Algorithmic Language 1968) is an imperative programming language that was conceived as a successor to the ALGOL 60 programming language, designed with the goal of a much wider scope of application and more rigorously defined syntax and semantics.",
      "first_release": "1968",
      "types": "static, strong, safe, structural",
      "paradigms": "Multi-paradigm, concurrent, imperative",
      "website": ""
    },
    {
      "name": "algol w",
      "source": "https://en.wikipedia.org/wiki/ALGOL_W",
      "about": "ALGOL W is a programming language. It is based on a proposal for ALGOL X by Niklaus Wirth and Tony Hoare as a successor to ALGOL 60 in International Federation for Information Processing (IFIP) IFIP Working Group 2.1 on Algorithmic Languages and Calculi, which specified, maintains, and supports the languages ALGOL 60 and ALGOL 68.[1] When the committee decided that the proposal was an insufficient advance over ALGOL 60, the proposal was published as A contribution to the development of ALGOL.[2] After making small modifications to the language[3] Wirth supervised a high quality implementation for the IBM System/360 at Stanford University that was widely distributed.[4]",
      "first_release": "1966",
      "types": "Static, strong",
      "paradigms": "Multi-paradigm, procedural, imperative, structured",
      "website": ""
    },
    {
      "name": "alice",
      "source": "https://en.wikipedia.org/wiki/Alice_(programming_language)",
      "about": "Alice ML is a programming language designed by the Programming Systems Laboratory[2] at Saarland University, Saarbrücken, Germany. It is a dialect of Standard ML, augmented with support for lazy evaluation, concurrency (multithreading and distributed computing via remote procedure calls) and constraint programming.",
      "first_release": "2000",
      "types": "strong, static, inferred",
      "paradigms": "Multi-paradigm, imperative, functional, distributed, concurrent",
      "website": "http://www.ps.uni-saarland.de/alice"
    },
    {
      "name": "alma-0",
      "source": "https://en.wikipedia.org/wiki/Alma-0",
      "about": "Alma-0 is a multi-paradigm computer programming language. This language is an augmented version of the imperative Modula-2 language with logic-programming features and convenient backtracking ability.[1] It is small, strongly typed, and combines constraint programming, a limited number of features inspired by logic programming and supports imperative paradigms. The language advocates declarative programming. The designers claim that search-oriented solutions built with it are substantially simpler than their counterparts written in purely imperative or logic programming style.[2] Alma-0 provides natural, high-level constructs for building search trees.[3]",
      "first_release": "1997",
      "types": "static",
      "paradigms": "multi-paradigm, constraint, imperative, logic",
      "website": "http://www.cwi.nl/en/alma"
    },
    {
      "name": "ambienttalk",
      "source": "https://en.wikipedia.org/wiki/AmbientTalk",
      "about": "AmbientTalk is an experimental object-oriented distributed programming language developed at the Programming Technology Laboratory at the Vrije Universiteit Brussel, Belgium. The language is primarily targeted at writing programs deployed in mobile ad hoc networks.",
      "first_release": "2006",
      "types": "dynamic, strong",
      "paradigms": "object-oriented, prototype-based, Concurrent, Event-driven, Reflective",
      "website": "http://soft.vub.ac.be/amop"
    },
    {
      "name": "amiga e",
      "source": "https://en.wikipedia.org/wiki/Amiga_E",
      "about": "Amiga E, or very often simply E, is a programming language created by Wouter van Oortmerssen on the Amiga. He has since moved on to develop the SHEEP programming language for the new AmigaDE platform and the CryScript language (also known as DOG) used during the development of the video game Far Cry.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "amos",
      "source": "https://en.wikipedia.org/wiki/AMOS_(programming_language)",
      "about": "AMOS BASIC is a dialect of the BASIC programming language implemented on the Amiga computer. AMOS BASIC was published by Europress Software and originally written by François Lionet with Constantin Sotiropoulos.",
      "first_release": "1990",
      "types": "",
      "paradigms": "Imperative, Procedural",
      "website": "https://web.archive.org/web/20120204085705/http://www.clickteam.com/eng/downloadcenter.php?i=58"
    },
    {
      "name": "ampl",
      "source": "https://en.wikipedia.org/wiki/AMPL",
      "about": "AMPL (A Mathematical Programming Language) is an algebraic modeling language to describe and solve high-complexity problems for large-scale mathematical computing (i.e., large-scale optimization and scheduling-type problems).[1] It was developed by Robert Fourer, David Gay, and Brian Kernighan at Bell Laboratories. AMPL supports dozens of solvers, both open source and commercial software, including CBC, CPLEX, FortMP, Gurobi, MINOS, IPOPT, SNOPT, KNITRO, and LGO. Problems are passed to solvers as nl files. AMPL is used by more than 100 corporate clients, and by government agencies and academic institutions.[2]",
      "first_release": "1985",
      "types": "",
      "paradigms": "Multi-paradigm, declarative, imperative",
      "website": "http://www.ampl.com/"
    },
    {
      "name": "angelscript",
      "source": "https://en.wikipedia.org/wiki/AngelScript",
      "about": "AngelScript is a game-oriented compiled scripting language.",
      "first_release": "2003",
      "types": "static, strong",
      "paradigms": "Multi-paradigm, scripting, imperative, procedural, object-oriented",
      "website": "http://angelcode.com/angelscript"
    },
    {
      "name": "apache pig latin",
      "source": "https://en.wikipedia.org/wiki/Apache_Pig",
      "about": "Apache Pig[1] is a high-level platform for creating programs that run on Apache Hadoop. The language for this platform is called Pig Latin.[1] Pig can execute its Hadoop jobs in MapReduce, Apache Tez, or Apache Spark.[2] Pig Latin abstracts the programming from the Java MapReduce idiom into a notation which makes MapReduce programming high level, similar to that of SQL for relational database management systems. Pig Latin can be extended using user-defined functions (UDFs) which the user can write in Java, Python, JavaScript, Ruby or Groovy[3] and then call directly from the language.",
      "first_release": "2008",
      "types": "",
      "paradigms": "",
      "website": "https://pig.apache.org/"
    },
    {
      "name": "apex",
      "source": "https://en.wikipedia.org/wiki/Apex_(programming_language)",
      "about": "Salesforce.com, Inc. is an American cloud-based software company headquartered in San Francisco, California. It provides customer relationship management (CRM) service and also provides a complementary suite of enterprise applications focused on customer service, marketing automation, analytics, and application development.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://salesforce.com/"
    },
    {
      "name": "apl",
      "source": "https://en.wikipedia.org/wiki/APL_(programming_language)",
      "about": "APL (named after the book A Programming Language)[3] is a programming language developed in the 1960s by Kenneth E. Iverson. Its central datatype is the multidimensional array. It uses a large range of special graphic symbols[4] to represent most functions and operators, leading to very concise code. It has been an important influence on the development of concept modeling, spreadsheets, functional programming,[5] and computer math packages.[6] It has also inspired several other programming languages.[7][8]",
      "first_release": "1966",
      "types": "Dynamic",
      "paradigms": "Array, functional, structured, modular",
      "website": ""
    },
    {
      "name": "app inventor for android's visual block language",
      "source": "https://en.wikipedia.org/wiki/App_Inventor_for_Android_(programming_language)",
      "about": "MIT App Inventor is a web application integrated development environment originally provided by Google, and now maintained by the Massachusetts Institute of Technology (MIT). It allows newcomers to computer programming to create application software(apps) for two operating systems (OS): Android, and iOS, which, as of 8 July 2019, is in final beta testing. It is free and open-source software released under dual licensing: a Creative Commons Attribution ShareAlike 3.0 Unported license, and an Apache License 2.0 for the source code.",
      "first_release": "2010",
      "types": "",
      "paradigms": "",
      "website": "http://appinventor.mit.edu/"
    },
    {
      "name": "applescript",
      "source": "https://en.wikipedia.org/wiki/AppleScript",
      "about": "AppleScript is a scripting language created by Apple Inc. that facilitates automated control over scriptable Mac applications. First introduced in System 7, it is currently included in all versions of macOS as part of a package of system automation tools.[2][3] The term \"AppleScript\" may refer to the language itself, to an individual script written in the language, or, informally, to the macOS Open Scripting Architecture that underlies the language.[2][3]",
      "first_release": "1993",
      "types": "Weak, dynamic",
      "paradigms": "Natural language programming, Scripting",
      "website": "https://developer.apple.com/library/content/documentation/AppleScript/Conceptual/AppleScriptX/AppleScriptX.html"
    },
    {
      "name": "apt",
      "source": "https://en.wikipedia.org/wiki/APT_(programming_language)",
      "about": "APT (Automatically Programmed Tool)[1] is a high-level computer programming language most commonly used to generate instructions for numerically controlled machine tools. Douglas T. Ross[2] is considered by many to be the father of APT: as head of the newly created Computer Applications Group of the Servomechanisms Laboratory at MIT in 1956, he led its technical effort. APT is a language and system that alleviates the tedious mathematics of writing toolpaths for numerically controlled equipment. This early language was used widely through the 1970s and is still a standard internationally.[3] Derivatives of APT were later developed.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "arc",
      "source": "https://en.wikipedia.org/wiki/Arc_(programming_language)",
      "about": "Arc is a programming language, a dialect of the language Lisp, developed by Paul Graham and Robert Morris. It is free and open-source software released under the Artistic License 2.0.",
      "first_release": "2008",
      "types": "Dynamic",
      "paradigms": "Multi-paradigm, functional, meta, procedural",
      "website": "http://arclanguage.org/"
    },
    {
      "name": "arexx",
      "source": "https://en.wikipedia.org/wiki/ARexx",
      "about": "ARexx is an implementation of the Rexx language for the Amiga, written in 1987 by William S. Hawes, with a number of Amiga-specific features beyond standard REXX facilities. Like most REXX implementations, ARexx is an interpreted language. Programs written for ARexx are called \"scripts\", or \"macros\"; several programs offer the ability to run ARexx scripts in their main interface as macros.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "argus",
      "source": "https://en.wikipedia.org/wiki/Argus_(programming_language)",
      "about": "Argus is a programming language created at MIT by Barbara Liskov between 1982 and 1988, in collaboration with Maurice Herlihy, Paul Johnson, Robert Scheifler, and William Weihl.[1] It is an extension of the CLU language, and utilizes most of the same syntax and semantics.[1] Argus was designed to support the creation of distributed programs, by encapsulating related procedures within objects called guardians, and by supporting atomic operations called actions.[1][2]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "assembly language",
      "source": "https://en.wikipedia.org/wiki/Assembly_language",
      "about": "In computer programming, assembly language (or assembler language),[1] often abbreviated asm, is any low-level programming language in which there is a very strong correspondence between the instructions in the language and the architecture's machine code instructions.[2] Because assembly depends on the machine code instructions, every assembly language is designed for exactly one specific computer architecture. Assembly language may also be called symbolic machine code.[3][4]",
      "first_release": "1949",
      "types": "",
      "paradigms": "Imperative, unstructured",
      "website": ""
    },
    {
      "name": "autohotkey",
      "source": "https://en.wikipedia.org/wiki/AutoHotkey",
      "about": "AutoHotkey is a free, open-source custom scripting language for Microsoft Windows, initially aimed at providing easy keyboard shortcuts or hotkeys, fast macro-creation and software automation that allows users of most levels of computer skill to automate repetitive tasks in any Windows application. User interfaces can easily be extended or modified by AutoHotkey (for example, overriding the default Windows control key commands with their Emacs equivalents).[6] The AutoHotkey installation includes its own extensive help file, and web-based documentation is also available.[7]",
      "first_release": "2003",
      "types": "",
      "paradigms": "",
      "website": "http://autohotkey.com/"
    },
    {
      "name": "autoit",
      "source": "https://en.wikipedia.org/wiki/AutoIt",
      "about": "AutoIt /ɔːtoʊ ɪt/[3] is a freeware programming language for Microsoft Windows. In its earliest release, it was primarily intended to create automation scripts (sometimes called macros) for Microsoft Windows programs[4] but has since grown to include enhancements in both programming language design and overall functionality.",
      "first_release": "1999",
      "types": "",
      "paradigms": "Object-oriented, imperative, functional, procedural, reflective",
      "website": "https://www.autoitscript.com/"
    },
    {
      "name": "autolisp / visual lisp",
      "source": "https://en.wikipedia.org/wiki/AutoLISP",
      "about": "AutoLISP is a dialect of the programming language Lisp built specifically for use with the full version of AutoCAD and its derivatives, which include AutoCAD Map 3D, AutoCAD Architecture and AutoCAD Mechanical.[1] Neither the application programming interface (API) nor the interpreter to execute AutoLISP code are included in the AutoCAD LT product line.[2]",
      "first_release": "1986",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "averest",
      "source": "https://en.wikipedia.org/wiki/Averest",
      "about": "Averest is a synchronous programming language and set of tools to specify, verify, and implement reactive systems. It includes a compiler for synchronous programs, a symbolic model checker, and a tool for hardware/software synthesis.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "awk",
      "source": "https://en.wikipedia.org/wiki/AWK",
      "about": "AWK (awk)[4] is a domain-specific language designed for text processing and typically used as a data extraction and reporting tool. Like sed and grep, it is a filter,[4] and is a standard feature of most Unix-like operating systems.",
      "first_release": "1977",
      "types": "",
      "paradigms": "Scripting, procedural, data-driven, [1]",
      "website": ""
    },
    {
      "name": "axum",
      "source": "https://en.wikipedia.org/wiki/Axum_(programming_language)",
      "about": "Axum (previously codenamed Maestro) is a domain-specific concurrent programming language, based on the Actor model, that was under active development by Microsoft[1] between 2009 and 2011.[2] It is an object-oriented language based on the .NET Common Language Runtime using a C-like syntax which, being a domain-specific language, is intended for development of portions of a software application that is well-suited to concurrency. But it contains enough general-purpose constructs that one need not switch to a general-purpose programming language (like C#) for the sequential parts of the concurrent components.[1]",
      "first_release": "2009",
      "types": "",
      "paradigms": "",
      "website": "http://msdn.microsoft.com/en-us/devlabs/dd795202.aspx"
    },
    {
      "name": "b",
      "source": "https://en.wikipedia.org/wiki/B_(programming_language)",
      "about": "B is a programming language developed at Bell Labs circa 1969. It was developed by Ken Thompson and Dennis Ritchie.",
      "first_release": "1969",
      "types": "word",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "babbage",
      "source": "https://en.wikipedia.org/wiki/Babbage_(programming_language)",
      "about": "Babbage is the high level assembly language for the GEC 4000 series minicomputers.[1] It was named after Charles Babbage, an English computing pioneer.",
      "first_release": "1971",
      "types": "",
      "paradigms": "procedural, structured, High-level assembler",
      "website": ""
    },
    {
      "name": "ballerina",
      "source": "https://en.wikipedia.org/wiki/Ballerina_(programming_language)",
      "about": "Ballerina is an open source general-purpose programming language and platform designed by WSO2 for cloud-era application programmers. It is easy to write and modify and is suitable for application programmers.[5][6][7]",
      "first_release": "2017",
      "types": "Structural, strong, static, inferred",
      "paradigms": "",
      "website": "http://ballerina.io/"
    },
    {
      "name": "bash",
      "source": "https://en.wikipedia.org/wiki/Bash_(Unix_shell)",
      "about": "Bash is a Unix shell and command language written by Brian Fox for the GNU Project as a free software replacement for the Bourne shell.[7][8] First released in 1989,[9] it has been used as the default login shell for most Linux distributions.[10] A version is also available for Windows 10 via the Windows Subsystem for Linux.[11] It is also the default user shell in Solaris 11.[12] Bash also was the default shell in all versions of Apple macOS prior to 2019.[13]",
      "first_release": "1989",
      "types": "",
      "paradigms": "",
      "website": "https://www.gnu.org/software/bash/"
    },
    {
      "name": "basic",
      "source": "https://en.wikipedia.org/wiki/BASIC",
      "about": "BASIC (Beginners' All-purpose Symbolic Instruction Code)[1] is a family of general-purpose, high-level programming languages whose design philosophy emphasizes ease of use. The original version was designed by John G. Kemeny and Thomas E. Kurtz and released at Dartmouth College in 1964. They wanted to enable students in fields other than science and mathematics to use computers. At the time, nearly all use of computers required writing custom software, which was something only scientists and mathematicians tended to learn.",
      "first_release": "1964",
      "types": "",
      "paradigms": "Non-structured, procedural, object-oriented",
      "website": ""
    },
    {
      "name": "batch file",
      "source": "https://en.wikipedia.org/wiki/Batch_file",
      "about": "A batch file is a script file in DOS, OS/2 and Microsoft Windows. It consists of a series of commands to be executed by the command-line interpreter, stored in a plain text file. A batch file may contain any command the interpreter accepts interactively and use constructs that enable conditional branching and looping within the batch file, such as IF, FOR, and GOTO labels. The term \"batch\" is from batch processing, meaning \"non-interactive execution\", though a batch file may not process a batch of multiple data.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "bc",
      "source": "https://en.wikipedia.org/wiki/Bc_(programming_language)",
      "about": "bc, for basic calculator (often referred to as bench calculator), is \"an arbitrary-precision calculator language\" with syntax similar to the C programming language. bc is typically used as either a mathematical scripting language or as an interactive mathematical shell.",
      "first_release": "1975",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "bcpl",
      "source": "https://en.wikipedia.org/wiki/BCPL",
      "about": "BCPL (\"Basic Combined Programming Language\") is a procedural, imperative, and structured programming language. Originally intended for writing compilers for other languages, BCPL is no longer in common use. However, its influence is still felt because a stripped down and syntactically changed version of BCPL, called B, was the language on which the C programming language was based. BCPL introduced several features of many modern programming languages, including using curly braces to delimit code blocks.[3] BCPL was first implemented by Martin Richards of the University of Cambridge in 1967.[1]",
      "first_release": "1967",
      "types": "word",
      "paradigms": "procedural, imperative, structured",
      "website": ""
    },
    {
      "name": "beanshell",
      "source": "https://en.wikipedia.org/wiki/BeanShell",
      "about": "BeanShell is a Java-like scripting language, invented by Patrick Niemeyer. It runs in the Java Runtime Environment (JRE) and uses a variation of the Java syntax, in addition to scripting commands and syntax.",
      "first_release": "1999",
      "types": "Dynamic, strong",
      "paradigms": "Object-oriented, scripting",
      "website": "http://www.beanshell.org/"
    },
    {
      "name": "bertrand",
      "source": "https://en.wikipedia.org/wiki/Bertrand_(programming_language)",
      "about": "Bertrand (named after Bertrand Russell) is a computer programming language for creating constraint programming systems. The language was created by Wm Leler in the mid-1980s as part of his doctoral research. Bertrand has a declarative programming syntax and differentiates itself from other programming languages by use of a technique called augmented term rewriting.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "beta",
      "source": "https://en.wikipedia.org/wiki/BETA_(programming_language)",
      "about": "BETA is a pure object-oriented language originating within the \"Scandinavian School\" in object-orientation where the first object-oriented language Simula was developed.[1] Among its notable features, it introduced nested classes, and unified classes with procedures into so called patterns.",
      "first_release": "",
      "types": "",
      "paradigms": "Object-oriented",
      "website": "http://beta.cs.au.dk/"
    },
    {
      "name": "bliss",
      "source": "https://en.wikipedia.org/wiki/BLISS_(programming_language)",
      "about": "BLISS is a system programming language developed at Carnegie Mellon University by W. A. Wulf, D. B. Russell, and A. N. Habermann around 1970. It was perhaps the best known systems programming language right up until C made its debut a few years later. Since then, C took off and BLISS faded into obscurity. When C was in its infancy, a few projects within Bell Labs were debating the merits of BLISS vs. C[citation needed].",
      "first_release": "1970",
      "types": "",
      "paradigms": "Structured, imperative, procedural",
      "website": "http://pdp-10.trailing-edge.com/bb-m836d-bm/"
    },
    {
      "name": "blockly",
      "source": "https://en.wikipedia.org/wiki/Blockly",
      "about": "Blockly is a client-side library for the programming language JavaScript for creating block-based visual programming languages (VPLs) and editors. A project of Google, it is free and open-source software released under the Apache License 2.0.[1] It typically runs in a web browser, and visually resembles the language Scratch. It is also being implemented for the mobile operating systems Android and iOS, though not all of its browser-based features will be available on those platforms.",
      "first_release": "2012",
      "types": "",
      "paradigms": "",
      "website": "http://developers.google.com/blockly"
    },
    {
      "name": "bloop",
      "source": "https://en.wikipedia.org/wiki/BlooP_and_FlooP",
      "about": "BlooP and FlooP are simple programming languages designed by Douglas Hofstadter to illustrate a point in his book Gödel, Escher, Bach.[1] BlooP is a non-Turing-complete programming language whose main control flow structure is a bounded loop (i.e. recursion is not permitted). All programs in the language must terminate, and this language can only express primitive recursive functions.[2]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "boo",
      "source": "https://en.wikipedia.org/wiki/Boo_(programming_language)",
      "about": "Boo is an object-oriented, statically typed, general-purpose programming language that seeks to make use of the Common Language Infrastructure's support for Unicode, internationalization, and web applications, while using a Python-inspired syntax[2] and a special focus on language and compiler extensibility. Some features of note include type inference, generators, multimethods, optional duck typing, macros, true closures, currying, and first-class functions.",
      "first_release": "2003",
      "types": "static, strong, inferred, duck",
      "paradigms": "Object oriented",
      "website": "https://github.com/boo-lang"
    },
    {
      "name": "boomerang",
      "source": "https://en.wikipedia.org/wiki/Boomerang_(programming_language)",
      "about": "Boomerang is a programming language for writing lenses—well-behaved bidirectional transformations —that operate on ad-hoc, textual data formats.",
      "first_release": "2008",
      "types": "",
      "paradigms": "",
      "website": "http://www.seas.upenn.edu/~harmony/"
    },
    {
      "name": "bosque",
      "source": "https://en.wikipedia.org/wiki/Bosque_(programming_language)",
      "about": "Bosque is a free and open-source programming language developed by Microsoft that was inspired by the syntax and types of TypeScript and the semantics of ML and Node/JavaScript.[3][4] Design goals for the language include better software quality and improved developer productivity.[5][6]",
      "first_release": "2019",
      "types": "",
      "paradigms": "Multi-paradigm, functional, typed language",
      "website": "https://www.microsoft.com/en-us/research/project/bosque-programming-language/"
    },
    {
      "name": "c",
      "source": "https://en.wikipedia.org/wiki/C_(programming_language)",
      "about": "C (/siː/, as in the letter c) is a general-purpose, procedural computer programming language supporting structured programming, lexical variable scope, and recursion, with a static type system. By design, C provides constructs that map efficiently to typical machine instructions. It has found lasting use in applications previously coded in assembly language. Such applications include operating systems and various application software for computer architectures that range from supercomputers to PLCs and embedded systems.",
      "first_release": "1972",
      "types": "Static, weak, manifest, nominal",
      "paradigms": "Imperative, procedural, structured",
      "website": "https://www.iso.org/standard/74528.html"
    },
    {
      "name": "c--",
      "source": "https://en.wikipedia.org/wiki/C--",
      "about": "C-- (pronounced see minus minus) is a C-like programming language. Its creators, functional programming researchers Simon Peyton Jones and Norman Ramsey, designed it to be generated mainly by compilers for very high-level languages rather than written by human programmers. Unlike many other intermediate languages, its representation is plain ASCII text, not bytecode or another binary format.[1][2]",
      "first_release": "1997",
      "types": "static, weak",
      "paradigms": "imperative",
      "website": "https://www.cs.tufts.edu/~nr/c--/index.html"
    },
    {
      "name": "c++",
      "source": "https://en.wikipedia.org/wiki/C%2B%2B",
      "about": "C++ (/ˌsiːˌplʌsˈplʌs/) is a general-purpose programming language created by Bjarne Stroustrup as an extension of the C programming language, or \"C with Classes\". The language has expanded significantly over time, and modern C++ now 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, Oracle, and IBM, so it is available on many platforms.[9]",
      "first_release": "1985",
      "types": "Static, nominative, partially inferred",
      "paradigms": "Multi-paradigm, procedural, functional, object-oriented, generic, modular",
      "website": "https://isocpp.org/"
    },
    {
      "name": "c*",
      "source": "https://en.wikipedia.org/wiki/C*",
      "about": "C* (or C-star) is an object-oriented, data-parallel superset of ANSI C with synchronous semantics.",
      "first_release": "1987",
      "types": "static, weak, manifest",
      "paradigms": "multi-paradigm, object-oriented, imperative, parallel",
      "website": ""
    },
    {
      "name": "c#",
      "source": "https://en.wikipedia.org/wiki/C_Sharp_(programming_language)",
      "about": "C# (pronounced see sharp, like the musical note C♯, but written with the number sign)[b] is a general-purpose, multi-paradigm programming language encompassing static typing, strong typing, lexically scoped, imperative, declarative, functional, generic, object-oriented (class-based), and component-oriented programming disciplines.[16]",
      "first_release": "2000",
      "types": "Static, dynamic, [3], strong, safe, nominative, partially inferred",
      "paradigms": "Structured, imperative, object-oriented, event-driven, task-driven, functional, generic, reflective, concurrent",
      "website": "http://csharp.net/"
    },
    {
      "name": "c/al",
      "source": "https://en.wikipedia.org/wiki/C/AL",
      "about": "C/AL (Client/server Application Language) was the programming language used within C/SIDE the Client/Server Integrated Development Environment in Microsoft Dynamics NAV (Formerly known as Navision Attain) and Microsoft Dynamics 365 Business Central up until (and including) version 14. It has been replaced by AL. C/AL is a Database specific programming language, and is primarily used for retrieving, inserting and modifying records in a Navision database. C/AL resembles the Pascal language on which it is based. The original C/AL compiler was written by Michael Nielsen.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "caché objectscript",
      "source": "https://en.wikipedia.org/wiki/Cach%C3%A9_ObjectScript",
      "about": "Caché ObjectScript is a part of the Caché database system sold by InterSystems. The language is a functional superset of the ANSI-standard MUMPS programming language. Since Caché is at its core a MUMPS implementation, it can run ANSI MUMPS routines with no change. To appeal as a commercial product, Caché implements support for object-oriented programming, a macro preprocessing language, embedded SQL for ANSI-standard SQL access to M's built-in database, procedure and control blocks using C-like brace syntax, procedure-scoped variables, and relaxed whitespace syntax limitations.",
      "first_release": "1997",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "c shell",
      "source": "https://en.wikipedia.org/wiki/C_Shell",
      "about": "The C shell (csh or the improved version, tcsh) is a Unix shell created by Bill Joy while he was a graduate student at University of California, Berkeley in the late 1970s. It has been widely distributed, beginning with the 2BSD release of the Berkeley Software Distribution (BSD) which Joy first distributed in 1978.[2][3] Other early contributors to the ideas or the code were Michael Ubell, Eric Allman, Mike O'Brien and Jim Kulp.[4]",
      "first_release": "1978",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "caml",
      "source": "https://en.wikipedia.org/wiki/Caml",
      "about": "Caml (originally an acronym for Categorical Abstract Machine Language) is a multi-paradigm, general-purpose programming language which is a dialect of the ML programming language family. Caml was developed in France at INRIA and ENS.",
      "first_release": "1985",
      "types": "Inferred, static, strong",
      "paradigms": "Multi-paradigm, functional, imperative",
      "website": "http://caml.inria.fr/"
    },
    {
      "name": "cayenne",
      "source": "https://en.wikipedia.org/wiki/Cayenne_(programming_language)",
      "about": "Lennart Augustsson is a Swedish computer scientist. He was previously a lecturer at the Computing Science Department at Chalmers University of Technology. His research field is functional programming and implementations of functional languages.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "cduce",
      "source": "https://en.wikipedia.org/wiki/CDuce",
      "about": "CDuce is an XML-oriented functional language, which extends XDuce in a few directions. It features XML regular expression types, XML regular expression patterns, XML iterators. CDuce is not strictly speaking an XML transformation language since it can be used for general-purpose programming.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "cecil",
      "source": "https://en.wikipedia.org/wiki/Cecil_(programming_language)",
      "about": "Cecil is a pure object-oriented programming language that was developed by Craig Chambers at the University of Washington in 1992 to be part of the Vortex project there. Cecil has many similarities to other object-oriented languages, most notably Objective-C, Modula-3, and Self.[1][2] The main goals of the project were extensibility, orthogonality, efficiency, and ease-of-use.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "cesil",
      "source": "https://en.wikipedia.org/wiki/Cesil",
      "about": "Cesil, or Computer Education in Schools Instruction Language, was a programming language designed to introduce pupils in British schools to Assembly language. It is a low level language containing a total of fourteen instructions:",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "céu",
      "source": "https://en.wikipedia.org/wiki/C%C3%A9u_(programming_language)",
      "about": "Céu is \"Structured Synchronous Reactive Programming\" [1] According to its web page, Céu supports synchronous concurrency with shared memory and deterministic execution and has a small memory footprint.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "ceylon",
      "source": "https://en.wikipedia.org/wiki/Ceylon_(programming_language)",
      "about": "Ceylon was an object-oriented, strongly statically typed programming language with an emphasis on immutability, created by Red Hat. Ceylon programs run on the Java virtual machine (JVM), and could be compiled to JavaScript.[6][7] The language design focuses on source code readability, predictability, toolability, modularity, and metaprogrammability.[8]",
      "first_release": "2011",
      "types": "Static, strong, safe",
      "paradigms": "Object-oriented",
      "website": "http://ceylon-lang.org/"
    },
    {
      "name": "cfengine",
      "source": "https://en.wikipedia.org/wiki/CFEngine",
      "about": "CFEngine is an open-source configuration management system, written by Mark Burgess. Its primary function is to provide automated configuration and maintenance of large-scale computer systems, including the unified management of servers, desktops, consumer and industrial devices, embedded networked devices, mobile smartphones, and tablet computers.",
      "first_release": "1993",
      "types": "",
      "paradigms": "",
      "website": "https://cfengine.com/"
    },
    {
      "name": "cg",
      "source": "https://en.wikipedia.org/wiki/Cg_(programming_language)",
      "about": "The High-Level Shader Language[1] or High-Level Shading Language[2] (HLSL) is a proprietary shading language developed by Microsoft for the Direct3D 9 API to augment the shader assembly language, and went on to become the required shading language for the unified shader model of Direct3D 10 and higher.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "ch",
      "source": "https://en.wikipedia.org/wiki/Ch_(computer_programming)",
      "about": "Ch /ˌsiːˈeɪtʃ/ is a proprietary cross-platform C and C++ interpreter and scripting language environment, originally designed by Harry H. Cheng as a scripting language for beginners to learn mathematics, computing, numerical analysis (numeric methods), and programming in C/C++. Ch is now developed and marketed by SoftIntegration, Inc. A student edition is freely available. Ch Professional Edition for Raspberry Pi is free for non-commercial use.",
      "first_release": "2001",
      "types": "",
      "paradigms": "",
      "website": "http://www.softintegration.com/"
    },
    {
      "name": "chapel",
      "source": "https://en.wikipedia.org/wiki/Chapel_(programming_language)",
      "about": "Chapel, the Cascade High Productivity Language, is a parallel programming language developed by Cray.[3] It is being developed as part of the Cray Cascade project, a participant in DARPA's High Productivity Computing Systems (HPCS) program, which had the goal of increasing supercomputer productivity by the year 2010. It is being developed as an open source project, under version 2 of the Apache license.[4]",
      "first_release": "2009",
      "types": "static, inferred",
      "paradigms": "Object-oriented, Partitioned global address space, Parallel programming",
      "website": "https://chapel-lang.org/"
    },
    {
      "name": "charm",
      "source": "https://en.wikipedia.org/wiki/Charm_(language)",
      "about": "Charm is a computer programming language devised in the early 1990s with similarities to the RTL/2, Pascal and C languages in addition to containing some unique features of its own. The Charm language is defined by a context-free grammar amenable to being processed by recursive descent parser as described in seminal books on compiler design.[1][2]",
      "first_release": "1996",
      "types": "",
      "paradigms": "Structured programming",
      "website": "http://charm.qu-bit.co.uk/"
    },
    {
      "name": "chill",
      "source": "https://en.wikipedia.org/wiki/CHILL",
      "about": "In computing, CHILL (an acronym for CCITT High Level Language) is a procedural programming language designed for use in telecommunication switches (the hardware used inside telephone exchanges). The language is still used for legacy systems in some telecommunication companies and for signal box programming.",
      "first_release": "1980",
      "types": "static, strong",
      "paradigms": "procedural",
      "website": ""
    },
    {
      "name": "chip-8",
      "source": "https://en.wikipedia.org/wiki/CHIP-8",
      "about": "CHIP-8 is an interpreted programming language, developed by Joseph Weisbecker. It was initially used on the COSMAC VIP and Telmac 1800 8-bit microcomputers in the mid-1970s. CHIP-8 programs are run on a CHIP-8 virtual machine. It was made to allow video games to be more easily programmed for these computers.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "chomski",
      "source": "https://en.wikipedia.org/wiki/Chomski",
      "about": "pattern parsing virtual machine (previously called 'chomski' after Noam Chomsky) and pep refer to both a command line computer language and utility (interpreter for that language) which can be used to parse and transform text patterns and (formal mathematical) languages. The utility reads input files character by character (sequentially), applying the operation which has been specified via the command line or a pep script, and then outputs the line. It was developed from 2006 in the C language. Pep has derived a number of ideas and syntax elements from Sed, a command line text stream editor.",
      "first_release": "2007",
      "types": "",
      "paradigms": "scripting language",
      "website": "http://bumble.sourceforge.net/books/pars/"
    },
    {
      "name": "chuck",
      "source": "https://en.wikipedia.org/wiki/ChucK",
      "about": "ChucK is a concurrent, strongly timed audio programming language for real-time synthesis, composition, and performance,[3] which runs on Linux, Mac OS X, Microsoft Windows, and iOS. It is designed to favor readability and flexibility for the programmer over other considerations such as raw performance. It natively supports deterministic concurrency and multiple, simultaneous, dynamic control rates. Another key feature is the ability to live code; adding, removing, and modifying code on the fly, while the program is running, without stopping or restarting. It has a highly precise timing/concurrency model, allowing for arbitrarily fine granularity. It offers composers and researchers a powerful and flexible programming tool for building and experimenting with complex audio synthesis programs, and real-time interactive control.[4]",
      "first_release": "2003",
      "types": "Strong",
      "paradigms": "Multi-paradigm",
      "website": "http://chuck.cs.princeton.edu/"
    },
    {
      "name": "cilk",
      "source": "https://en.wikipedia.org/wiki/Cilk",
      "about": "Cilk, Cilk++ and Cilk Plus are general-purpose programming languages designed for multithreaded parallel computing. They are based on the C and C++ programming languages, which they extend with constructs to express parallel loops and the fork–join idiom.",
      "first_release": "1994",
      "types": "static, weak, manifest",
      "paradigms": "imperative, procedural, structured, parallel",
      "website": "https://www.cilkplus.org/"
    },
    {
      "name": "cl",
      "source": "https://en.wikipedia.org/wiki/AS/400_Control_Language",
      "about": "The IBM i Control Language (CL) is a scripting language for the IBM's IBM i platform (previously called OS/400 when running on AS/400 systems) bearing a resemblance to the IBM Job Control Language and consisting of an ever-expanding set of command objects (*CMD) used to invoke traditional AS/400 programs and/or get help on what those programs do. CL can also be used to create CL programs (congruent to shell scripts) where there are additional commands that provide program-like functionality (IF/ELSE, variable declaration, file input, etc.)",
      "first_release": "",
      "types": "",
      "paradigms": "imperative",
      "website": ""
    },
    {
      "name": "claire",
      "source": "https://en.wikipedia.org/wiki/Claire_(programming_language)",
      "about": "Claire is a high-level functional and object-oriented programming language with rule processing abilities. It was designed by Yves Caseau at Bouygues' e-Lab research laboratory, and received its final definition in 2004.",
      "first_release": "1994",
      "types": "strong, static, dynamic",
      "paradigms": "multi-paradigm, functional, object-oriented, class-based, rule processing, reflective",
      "website": "http://www.claire-language.com/"
    },
    {
      "name": "clarion",
      "source": "https://en.wikipedia.org/wiki/Clarion_(programming_language)",
      "about": "Clarion is a commercial, proprietary, fourth-generation programming language (4GL), multi-paradigm, programming language and integrated development environment (IDE) from SoftVelocity used to program database applications. It is compatible with indexed sequential access method (ISAM), Structured Query Language (SQL), and ActiveX Data Objects (ADO) data access methods, reads and writes several flat file desktop database formats including ASCII, comma-separated values (CSV), DOS (binary), FoxPro, Clipper, dBase, and some relational databases via ODBC, Microsoft SQL Server, Sybase SQL Anywhere, and Oracle Database through the use of accelerated native database drivers, and XML, Clarion can be used to output to HTML, XML, plain text, and Portable Document Format (PDF), among others.",
      "first_release": "1986",
      "types": "",
      "paradigms": "Imperative, structured, object-oriented",
      "website": "http://www.softvelocity.com/"
    },
    {
      "name": "clean",
      "source": "https://en.wikipedia.org/wiki/Clean_(programming_language)",
      "about": "Clean is a general-purpose purely functional computer programming language. For much of the language's active development history it was called Concurrent Clean, but this was dropped at some point. Clean is being developed by a group of researchers from the Radboud University in Nijmegen since 1987.",
      "first_release": "1987",
      "types": "strong, static, dynamic",
      "paradigms": "functional",
      "website": "http://clean.cs.ru.nl/"
    },
    {
      "name": "clipper",
      "source": "https://en.wikipedia.org/wiki/Clipper_(programming_language)",
      "about": "Clipper is an xBase compiler that implements a variant of the xBase computer programming language. It is used to create or extend software programs that originally operated primarily under MS-DOS. Although it is a powerful general-purpose programming language, it was primarily used to create database/business programs.",
      "first_release": "1985",
      "types": "",
      "paradigms": "",
      "website": "http://www.grafxsoft.com/clipper.htm"
    },
    {
      "name": "clips",
      "source": "https://en.wikipedia.org/wiki/CLIPS_(programming_language)",
      "about": "CLIPS is a public domain software tool for building expert systems. The name is an acronym for \"C Language Integrated Production System.\" The syntax and name was inspired by Charles Forgy's OPS5. The first versions of CLIPS were developed starting in 1985 at NASA-Johnson Space Center (as an alternative for existing system ART*Inference) until the mid-1990s when the development group's responsibilities ceased to focus on expert system technology. The original name of the project was NASA's AI Language (NAIL).",
      "first_release": "1985",
      "types": "",
      "paradigms": "expert systems",
      "website": "http://www.clipsrules.net/"
    },
    {
      "name": "clist",
      "source": "https://en.wikipedia.org/wiki/CLIST",
      "about": "CLIST (Command List) (pronounced \"C-List\") is a procedural programming language for TSO in MVS systems. It originated in OS/360 Release 20 and has assumed a secondary role since the availability of Rexx in TSO/E Version 2. The term CLIST is also used for command lists written by users of NetView.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "clojure",
      "source": "https://en.wikipedia.org/wiki/Clojure",
      "about": "Clojure (/ˈkloʊʒər/, like closure)[15][16] is a modern, dynamic, and functional dialect of the Lisp programming language on the Java platform.[17][18] Like other Lisp dialects, Clojure treats code as data and has a Lisp macro system.[19] The current development process is community-driven,[20] overseen by Rich Hickey as its benevolent dictator for life (BDFL).[21]",
      "first_release": "2007",
      "types": "dynamic, strong",
      "paradigms": "multi-paradigm, agent-oriented, [1], concurrent, [2], [3], functional, [4], logic, [5], macro, [6], pipeline, [7]",
      "website": "https://clojure.org/"
    },
    {
      "name": "clu",
      "source": "https://en.wikipedia.org/wiki/CLU_(programming_language)",
      "about": "CLU is a programming language created at the Massachusetts Institute of Technology (MIT) by Barbara Liskov and her students between 1974 and 1975. While it did not find extensive use, it introduced many features that are used widely now, and is seen as a step in the development of object-oriented programming (OOP).",
      "first_release": "1975",
      "types": "strong",
      "paradigms": "multi-paradigm, object-oriented, procedural",
      "website": "http://www.pmg.lcs.mit.edu/CLU.html"
    },
    {
      "name": "cms-2",
      "source": "https://en.wikipedia.org/wiki/CMS-2_(programming_language)",
      "about": "CMS-2 is an embedded systems programming language used by the United States Navy.[2] It was an early attempt to develop a standardized high-level computer programming language intended to improve code portability and reusability. CMS-2 was developed primarily for the US Navy’s tactical data systems (NTDS).[1]",
      "first_release": "1968",
      "types": "",
      "paradigms": "Imperative",
      "website": ""
    },
    {
      "name": "cobol",
      "source": "https://en.wikipedia.org/wiki/COBOL",
      "about": "COBOL (/ˈkoʊbɒl, -bɔːl/; an acronym for \"common business-oriented language\") is a compiled English-like computer programming language designed for business use. It is imperative, procedural and, since 2002, it is an object-oriented language. COBOL is primarily used in business, finance, and administrative systems for companies and governments. COBOL is still widely used in applications deployed on mainframe computers, such as large-scale batch and transaction processing jobs. However, due to its declining popularity and the retirement of experienced COBOL programmers, programs are being migrated to new platforms, rewritten in modern languages or replaced with software packages.[8] Most programming in COBOL is now purely to maintain existing applications; however, many large financial institutions were still developing new systems in COBOL as late as 2006 due to the mainframe processing speed.[9]",
      "first_release": "1959",
      "types": "Weak, static",
      "paradigms": "Procedural, imperative, object-oriented",
      "website": ""
    },
    {
      "name": "cobolscript",
      "source": "https://en.wikipedia.org/wiki/CobolScript",
      "about": "CobolScript is a programming language created by Matthew Dean and Charles Schereda of Deskware in 1999.[1] The language was intended to provide web-enabled COBOL, and was targeted at businesses using legacy software written in that language.[1] [2]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "cobra",
      "source": "https://en.wikipedia.org/wiki/Cobra_(programming_language)",
      "about": "Cobra is a discontinued general-purpose, object-oriented programming language.[1] Cobra is designed by Charles Esterbrook, and runs on the Microsoft .NET and Mono platforms.[2] It is strongly influenced by Python, C#, Eiffel, Objective-C, and other programming languages.[3] It supports both static and dynamic typing.[4][5] It has support for unit tests and contracts.[4] It has lambda expressions, closures, list comprehensions, and generators.[6]",
      "first_release": "2006",
      "types": "strong, static, dynamic, inferred",
      "paradigms": "Multi-paradigm, object-oriented",
      "website": "http://cobra-language.com/"
    },
    {
      "name": "coffeescript",
      "source": "https://en.wikipedia.org/wiki/CoffeeScript",
      "about": "CoffeeScript is a programming language that compiles to JavaScript. It adds syntactic sugar inspired by Ruby, Python and Haskell in an effort to enhance JavaScript's brevity and readability.[4] Specific additional features include list comprehension and destructuring assignment.",
      "first_release": "2009",
      "types": "",
      "paradigms": "Multi-paradigm, prototype-based, functional, imperative, scripting",
      "website": "https://coffeescript.org/"
    },
    {
      "name": "coldfusion",
      "source": "https://en.wikipedia.org/wiki/ColdFusion",
      "about": "Adobe ColdFusion is a commercial rapid web-application development computing platform created by J. J. Allaire in 1995.[4] (The programming language used with that platform is also commonly called ColdFusion, though is more accurately known as CFML.) ColdFusion was originally designed to make it easier to connect simple HTML pages to a database. By version 2 (1996), it became a full platform that included an IDE in addition to a full scripting language.",
      "first_release": "1995",
      "types": "",
      "paradigms": "",
      "website": "https://www.adobe.com/products/coldfusion-family.html"
    },
    {
      "name": "comal",
      "source": "https://en.wikipedia.org/wiki/COMAL",
      "about": "COMAL (Common Algorithmic Language) is a computer programming language developed in Denmark by Børge R. Christensen and Benedict Løfstedt and originally released in 1975. COMAL was one of the few structured programming languages that was available for and comfortably usable on 8-bit home computers. It was based on the seminal BASIC programming language, adding multi-line statements and well-defined subroutines among other additions.",
      "first_release": "1975",
      "types": "Strong",
      "paradigms": "Structured",
      "website": ""
    },
    {
      "name": "combined programming language",
      "source": "https://en.wikipedia.org/wiki/Combined_Programming_Language",
      "about": "CPL (Combined Programming Language) is a multi-paradigm programming language, that was developed in the early 1960s. It is an early ancestor of the C language via the BCPL and B languages.",
      "first_release": "1963",
      "types": "",
      "paradigms": "Multi-paradigm, procedural, imperative, structured, functional",
      "website": ""
    },
    {
      "name": "comit",
      "source": "https://en.wikipedia.org/wiki/COMIT",
      "about": "COMIT was the first string processing language (compare SNOBOL, TRAC, and Perl), developed on the IBM 700/7000 series computers by Dr. Victor Yngve and collaborators at MIT from 1957 to 1965. Yngve created the language for supporting computerized research in the field of linguistics, and more specifically, the area of machine translation for natural language processing. The creation of COMIT led to the creation of SNOBOL.",
      "first_release": "1957",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "common intermediate language",
      "source": "https://en.wikipedia.org/wiki/Common_Intermediate_Language",
      "about": "Common Intermediate Language (CIL), formerly called Microsoft Intermediate Language (MSIL) or Intermediate Language (IL),[1] is the intermediate language binary instruction set defined within the Common Language Infrastructure (CLI) specification.[2] CIL instructions are executed by a CLI-compatible runtime environment such as the Common Language Runtime. Languages which target the CLI compile to CIL. CIL is object-oriented, stack-based bytecode. Runtimes typically just-in-time compile CIL instructions into native code.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "common lisp",
      "source": "https://en.wikipedia.org/wiki/Common_Lisp",
      "about": "Common Lisp (CL) is a dialect of the Lisp programming language, published in ANSI standard document ANSI INCITS 226-1994 (S20018)[1] (formerly X3.226-1994 (R1999)).[2] The Common Lisp HyperSpec, a hyperlinked HTML version, has been derived from the ANSI Common Lisp standard.[3]",
      "first_release": "1994",
      "types": "Dynamic, strong",
      "paradigms": "Multi-paradigm, procedural, functional, object-oriented, meta, reflective, generic",
      "website": "http://common-lisp.net/"
    },
    {
      "name": "compass",
      "source": "https://en.wikipedia.org/wiki/COMPASS",
      "about": "COMPASS, COMPrehensive ASSembler,[1] is any of a family of macro assembly languages on Control Data Corporation's 3000 series, and on the 60-bit CDC 6000 series, 7600 and Cyber 70 and 170 series mainframe computers. While the architectures are very different, the macro and conditional assembly facilities are similar.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "component pascal",
      "source": "https://en.wikipedia.org/wiki/Component_Pascal",
      "about": "Component Pascal is a programming language in the tradition of Niklaus Wirth's Pascal,[1] Modula-2,[2] Oberon[3][4] and Oberon-2.[5] It bears the name of the language Pascal and preserves its heritage, but is incompatible with Pascal. Instead, it is a minor variant and refinement of Oberon-2 with a more expressive type system and built-in string support. Component Pascal was originally named Oberon/L, and was designed and supported by a small ETH Zürich spin-off company named Oberon microsystems. They developed an integrated development environment (IDE) named BlackBox Component Builder. Since 2014, development and support has been taken over by a small group of volunteers. The first version of the IDE was released in 1994, as Oberon/F. At the time, it presented a novel approach to graphical user interface (GUI) construction based on editable forms, where fields and command buttons are linked to exported variables and executable procedures. This approach bears some similarity to the code-behind way used in Microsoft's .NET 3.0 to access code in Extensible Application Markup Language (XAML), which was released in 2008.",
      "first_release": "1997",
      "types": "Strong, static",
      "paradigms": "Imperative, structured, modular, object-oriented",
      "website": "http://blackboxframework.org/"
    },
    {
      "name": "constraint handling rules",
      "source": "https://en.wikipedia.org/wiki/Constraint_Handling_Rules",
      "about": "Constraint Handling Rules (CHR) is a declarative, rule-based language, introduced in 1991 by Thom Frühwirth at the time with ECRC (European Computer-Industry Research Centre) in Munich, Germany.[1][2] Originally intended for constraint programming, CHR finds applications in grammar induction,[3] abductive reasoning, multi-agent systems, natural language processing, compilation, scheduling, spatial-temporal reasoning, testing and verification, and type systems.",
      "first_release": "1991",
      "types": "",
      "paradigms": "Constraint logic programming",
      "website": ""
    },
    {
      "name": "comtran",
      "source": "https://en.wikipedia.org/wiki/COMTRAN",
      "about": "COMTRAN (COMmercial TRANslator) is an early programming language developed at IBM. It was intended as the business programming equivalent of the scientific programming language FORTRAN (FORmula TRANslator). It served as one of the forerunners to the COBOL language. Developed by Bob Bemer, in 1957, the language was the first to feature the programming language element known as a picture clause.",
      "first_release": "1957",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "cool",
      "source": "https://en.wikipedia.org/wiki/Cool_(programming_language)",
      "about": "Cool, an acronym for Classroom Object Oriented Language, is a computer programming language designed by Alexander Aiken for use in an undergraduate compiler course project. While small enough for a one term project, Cool still has many of the features of modern programming languages, including objects, automatic memory management, strong static typing and simple reflection.",
      "first_release": "1996",
      "types": "Static, strong, manifest",
      "paradigms": "Object-oriented",
      "website": ""
    },
    {
      "name": "coq",
      "source": "https://en.wikipedia.org/wiki/Coq",
      "about": "Coq is an interactive theorem prover first released in 1989. It allows for the expression of mathematical assertions, mechanically checks proofs of these assertions, helps to find formal proofs, and extracts a certified program from the constructive proof of its formal specification. Coq works within the theory of the calculus of inductive constructions, a derivative of the calculus of constructions. Coq is not an automated theorem prover but includes automatic theorem proving tactics (procedures) and various decision procedures.",
      "first_release": "1989",
      "types": "",
      "paradigms": "",
      "website": "https://coq.inria.fr/"
    },
    {
      "name": "coral 66",
      "source": "https://en.wikipedia.org/wiki/Coral_66",
      "about": "CORAL, short for Computer On-line Real-time Applications Language is a programming language originally developed in 1964 at the Royal Radar Establishment (RRE), Malvern, Worcestershire, in the United Kingdom.[1] The R was originally for \"radar\", not \"real-time\".[2] It was influenced primarily by JOVIAL, and thus ALGOL, but is not a subset of either.",
      "first_release": "1964",
      "types": "Static, strong",
      "paradigms": "procedural, imperative, structured",
      "website": ""
    },
    {
      "name": "corvision",
      "source": "https://en.wikipedia.org/wiki/CorVision",
      "about": "CorVision is a fourth generation programming tool (4GL) currently owned by Attunity, Inc. CorVision was developed by Cortex Corporation for the VAX/VMS ISAM environment. Although Cortex beta tested CorVision-10 which was generated for PCs but CorVision itself stayed anchored on VMS. CorVision-10 proved more difficult than hoped, and was never released.",
      "first_release": "1986",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "cowsel",
      "source": "https://en.wikipedia.org/wiki/COWSEL",
      "about": "COWSEL (COntrolled Working SpacE Language) is a programming language designed between 1964 and 1966 by Robin Popplestone. It was based on an RPN form of Lisp combined with some ideas from CPL.",
      "first_release": "1964",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "cpl",
      "source": "https://en.wikipedia.org/wiki/CPL_(programming_language)",
      "about": "CPL (Combined Programming Language) is a multi-paradigm programming language, that was developed in the early 1960s. It is an early ancestor of the C language via the BCPL and B languages.",
      "first_release": "1963",
      "types": "",
      "paradigms": "Multi-paradigm, procedural, imperative, structured, functional",
      "website": ""
    },
    {
      "name": "cryptol",
      "source": "https://en.wikipedia.org/wiki/Cryptol",
      "about": "Cryptol is a domain specific programming language for cryptography developed by the Portland, Oregon based software development firm, Galois, Inc..[1][2] The language was originally developed for use by the United States National Security Agency.[1][3] The language is also used by private firms that provide information technology systems, such as the American company Rockwell Collins provides to aerospace and defense contractors in the United States.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "crystal",
      "source": "https://en.wikipedia.org/wiki/Crystal_(programming_language)",
      "about": "Crystal is a general-purpose, object-oriented programming language, designed and developed by Ary Borenszweig, Juan Wajnerman, Brian Cardiff and more than 300 contributors.[4] With syntax inspired by the language Ruby,[3] it is a compiled language with static type-checking, but specifying the types of variables or method arguments is generally unneeded. Types are resolved by an advanced global type inference algorithm.[5] Crystal is currently in active development. It is released as free and open-source software under the Apache License version 2.0.",
      "first_release": "2014",
      "types": "static, inferred, structural, duck",
      "paradigms": "Multi-paradigm, object-oriented, concurrent",
      "website": "https://crystal-lang.org/"
    },
    {
      "name": "csound",
      "source": "https://en.wikipedia.org/wiki/Csound",
      "about": "Csound is a domain-specific computer programming language for audio programming. It is called Csound because it is written in C, as opposed to some of its predecessors.",
      "first_release": "1986",
      "types": "",
      "paradigms": "",
      "website": "http://csound.com/"
    },
    {
      "name": "cuneiform",
      "source": "https://en.wikipedia.org/wiki/Cuneiform_(programming_language)",
      "about": "Cuneiform is an open-source workflow language for large-scale scientific data analysis.[1][2] It is a statically typed functional programming language promoting parallel computing. It features a versatile foreign function interface allowing users to integrate software from many external programming languages. At the organizational level Cuneiform provides facilities like conditional branching and general recursion making it Turing-complete. In this, Cuneiform is the attempt to close the gap between scientific workflow systems like Taverna, KNIME, or Galaxy and large-scale data analysis programming models like MapReduce or Pig Latin while offering the generality of a functional programming language.",
      "first_release": "2013",
      "types": "",
      "paradigms": "functional, scientific workflow",
      "website": "https://cuneiform-lang.org/"
    },
    {
      "name": "curl",
      "source": "https://en.wikipedia.org/wiki/Curl_(programming_language)",
      "about": "Curl is a reflective object-oriented programming language for interactive web applications whose goal is to provide a smoother transition between formatting and programming. It makes it possible to embed complex objects in simple documents without needing to switch between programming languages or development platforms. The Curl implementation initially consisted of just an interpreter, but a compiler was added later.",
      "first_release": "1998",
      "types": "strong",
      "paradigms": "multi-paradigm, object-oriented, markup",
      "website": "http://www.curl.com/"
    },
    {
      "name": "curry",
      "source": "https://en.wikipedia.org/wiki/Curry_(programming_language)",
      "about": "Curry[1] is an experimental functional logic programming language,[2] based on the Haskell language. It merges elements of functional and logic programming, including constraint programming integration.",
      "first_release": "",
      "types": "static, strong, inferred",
      "paradigms": "functional, logic",
      "website": "http://curry-lang.org/"
    },
    {
      "name": "cybil",
      "source": "https://en.wikipedia.org/wiki/Cybil_(programming_language)",
      "about": "Cybil (short for the Cyber Implementation Language of the Control Data Network Operating System) was a Pascal-like language developed at Control Data Corporation for the Cyber computer family.[1][2] Cybil was used as the implementation language for the NOS/VE operating system[3] on the CDC Cyber series and was also used to write the eOS operating system for the ETA10 supercomputer in the 1980s.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "cyclone",
      "source": "https://en.wikipedia.org/wiki/Cyclone_(programming_language)",
      "about": "The Cyclone programming language is intended to be a safe dialect of the C language. Cyclone is designed to avoid buffer overflows and other vulnerabilities that are possible in C programs, without losing the power and convenience of C as a tool for system programming.",
      "first_release": "2002",
      "types": "",
      "paradigms": "",
      "website": "http://cyclone.thelanguage.org/"
    },
    {
      "name": "cypher query language",
      "source": "https://en.wikipedia.org/wiki/Cypher_Query_Language",
      "about": "Cypher is a declarative graph query language that allows for expressive and efficient data querying in a property graph.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "cython",
      "source": "https://en.wikipedia.org/wiki/Cython",
      "about": "Cython is a programming language that aims to be a superset of the Python programming language, designed to give C-like performance with code that is written mostly in Python with optional additional C-inspired syntax.[4][5]",
      "first_release": "2007",
      "types": "",
      "paradigms": "",
      "website": "https://cython.org/"
    },
    {
      "name": "ceemac",
      "source": "https://en.wikipedia.org/wiki/CEEMAC",
      "about": "CEEMAC is a programming language developed in the 1980s for the Apple II family of computers. It was authored by Brooke Boering and published by Vagabondo Enterprises,[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "d",
      "source": "https://en.wikipedia.org/wiki/D_(programming_language)",
      "about": "D, also known as Dlang, is a multi-paradigm system programming language created by Walter Bright at Digital Mars and released in 2001. Andrei Alexandrescu joined the design and development effort in 2007. Though it originated as a re-engineering of C++, D is a distinct language. It has redesigned some core C++ features, while also sharing characteristics of other languages, notably Java, Python, Ruby, C#, and Eiffel.",
      "first_release": "2001",
      "types": "Inferred, static, strong",
      "paradigms": "Multi-paradigm, functional, imperative, object-oriented",
      "website": "https://dlang.org/"
    },
    {
      "name": "dart",
      "source": "https://en.wikipedia.org/wiki/Dart_(programming_language)",
      "about": "Dart is a client-optimized[9] programming language for apps on multiple platforms. It is developed by Google and is used to build mobile, desktop, server, and web applications.[10]",
      "first_release": "2011",
      "types": "Optional, Inferred, [5], static, strong",
      "paradigms": "Multi-paradigm, functional, imperative, object-oriented, reflective, [1]",
      "website": "https://dart.dev/"
    },
    {
      "name": "darwin",
      "source": "https://en.wikipedia.org/wiki/Darwin_(programming_language)",
      "about": "Darwin is a closed source[1] programming language developed by Gaston Gonnet and colleagues at ETH Zurich.[2][3] It is used to develop the OMA orthology inference software,[4] which was also initially developed by Gonnet.[5] The language backend consists of the kernel, responsible for performing simple mathematical calculations, for transporting and storing data and for interpreting the user's commands, and the library, a set of programs which can perform more complicated calculations.[6] The target audience for the language is the biosciences, so the library consisted of routines such as those to compute pairwise alignments, phylogenetic trees, multiple sequence alignments, and to make secondary structure predictions.",
      "first_release": "1991",
      "types": "Dynamic, Strong",
      "paradigms": "imperative, structured, object-oriented",
      "website": ""
    },
    {
      "name": "dataflex",
      "source": "https://en.wikipedia.org/wiki/DataFlex",
      "about": "DataFlex is an object-oriented high-level programming language and a fourth generation visual tool 4GL for developing Windows, web and mobile software applications on one framework-based platform. It was introduced and developed by Data Access Corporation beginning in 1982.[5][2][6][7]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.dataaccess.com/DataFlex"
    },
    {
      "name": "datalog",
      "source": "https://en.wikipedia.org/wiki/Datalog",
      "about": "Datalog is a declarative logic programming language that syntactically is a subset of Prolog. It is often used as a query language for deductive databases. In recent years, Datalog has found new application in data integration, information extraction, networking, program analysis, security, cloud computing and machine learning.[1][2]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "datatrieve",
      "source": "https://en.wikipedia.org/wiki/DATATRIEVE",
      "about": "DATATRIEVE is a database query and report writer tool originally from Digital Equipment Corporation. It runs on the OpenVMS operating system, as well as several PDP-11 operating systems. DATATRIEVE's command structure is nearly plain English, and it is an early example of a Fourth Generation Language (4GL).",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "dbase",
      "source": "https://en.wikipedia.org/wiki/DBase",
      "about": "dBase (also stylized dBASE) was one of the first database management systems for microcomputers, and the most successful in its day.[2] The dBase system includes the core database engine, a query system, a forms engine, and a programming language that ties all of these components together. dBase's underlying file format, the .dbf file, is widely used in applications needing a simple format to store structured data.[citation needed]",
      "first_release": "1979",
      "types": "",
      "paradigms": "Imperative, declarative",
      "website": "http://www.dbase.com/"
    },
    {
      "name": "dc",
      "source": "https://en.wikipedia.org/wiki/Dc_(computer_program)",
      "about": "dc (desk calculator) is a cross-platform reverse-polish calculator which supports arbitrary-precision arithmetic.[1] Written by Robert Morris while at Bell Labs,[2] it is one of the oldest Unix utilities, preceding even the invention of the C programming language. Like other utilities of that vintage, it has a powerful set of features but terse syntax.[3][4] Traditionally, the bc calculator program (with infix notation) was implemented on top of dc.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "dcl",
      "source": "https://en.wikipedia.org/wiki/DIGITAL_Command_Language",
      "about": "DIGITAL Command Language (DCL) is the standard command language adopted by most of the operating systems that were sold by the former Digital Equipment Corporation. DCL had its roots in IAS, TOPS-20, and RT-11 and was implemented as a standard across most of Digital's operating systems, notably RSX-11 and RSTS/E, but took its most powerful form in VAX/VMS (later OpenVMS). DCL continues to be developed by VSI as part of OpenVMS.[3]",
      "first_release": "",
      "types": "",
      "paradigms": "imperative",
      "website": ""
    },
    {
      "name": "delphi",
      "source": "https://en.wikipedia.org/wiki/Delphi_(software)",
      "about": "Delphi is 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.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://embarcadero.com/products/delphi"
    },
    {
      "name": "dinkc",
      "source": "https://en.wikipedia.org/wiki/Dink_Smallwood",
      "about": "Dink Smallwood is an action role-playing video game, developed by Robinson Technologies, at the time consisting of Seth Robinson, Justin Martin, and Greg Smith. It was first released in 1998 before being released as freeware on October 17, 1999.[1] Mitch Brink composed several of the game's music tracks, while others are MIDI forms of classical music, such as Debussy's \"Reverie\". The game has a small but constant fan following that continues to develop add-ons for the game more than a decade after its release.[2] The game is also notable for its humorous dialogue and surrealistic themes in various scenes between the gameplay.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "dibol",
      "source": "https://en.wikipedia.org/wiki/DIBOL",
      "about": "DIBOL or Digital's Business Oriented Language is a general-purpose, procedural, imperative programming language, designed for use in Management Information Systems (MIS) software development.",
      "first_release": "1970",
      "types": "static",
      "paradigms": "procedural, imperative, structured",
      "website": ""
    },
    {
      "name": "dog",
      "source": "https://en.wikipedia.org/wiki/Dog_(programming_language)",
      "about": "Sepandar David Kamvar (born 1977), also known as Sep Kamvar, is a computer scientist, artist, author and entrepreneur.[1][2][3][4] He is currently the founder of Celo, a cryptocurrency startup.[5][6] He was previously the LG Career Development Professor of Media Arts and Sciences at MIT, and director of the Social Computing group at the MIT Media Lab.[3][7]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "draco",
      "source": "https://en.wikipedia.org/wiki/Draco_(programming_language)",
      "about": "Draco was a shareware programming language created by Chris Gray. First developed for CP/M systems, Amiga version followed in 1987.[1]",
      "first_release": "1990",
      "types": "static, strong, manifest",
      "paradigms": "imperative, procedural, structured",
      "website": ""
    },
    {
      "name": "drakon",
      "source": "https://en.wikipedia.org/wiki/DRAKON",
      "about": "DRAKON is an algorithmic visual programming and modeling language developed within the Buran space project following ergonomic design principles. The language provides a uniform way to represent flowcharts of any complexity that are easy to read and understand.",
      "first_release": "1996",
      "types": "",
      "paradigms": "visual",
      "website": "http://drakon-editor.sourceforge.net/"
    },
    {
      "name": "dylan",
      "source": "https://en.wikipedia.org/wiki/Dylan_(programming_language)",
      "about": "Dylan is a multi-paradigm programming language that includes support for functional and object-oriented programming (OOP), and is dynamic and reflective while providing a programming model designed to support generating efficient machine code, including fine-grained control over dynamic and static behaviors. It was created in the early 1990s by a group led by Apple Computer.",
      "first_release": "1992",
      "types": "",
      "paradigms": "multi-paradigm, functional, object-oriented",
      "website": "http://opendylan.org/"
    },
    {
      "name": "dynamo",
      "source": "https://en.wikipedia.org/wiki/DYNAMO_(programming_language)",
      "about": "DYNAMO (DYNAmic MOdels) is a historically important simulation language and accompanying graphical notation developed within the system dynamics analytical framework. It was originally for industrial dynamics but was soon extended to other applications, including population and resource studies[1][2] and urban planning.[3][4]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "dax",
      "source": "https://en.wikipedia.org/wiki/Data_analysis_expressions",
      "about": "Data Analysis Expressions (DAX) is the native formula and query language for Microsoft PowerPivot, Power BI Desktop and SQL Server Analysis Services (SSAS) Tabular models. DAX includes some of the functions that are used in Excel formulas with additional functions that are designed to work with relational data and perform dynamic aggregation. It is, in part, an evolution of the Multidimensional Expression (MDX) language developed by Microsoft for Analysis Services multidimensional models (often called cubes) combined with Excel formula functions. It is designed to be simple and easy to learn, while exposing the power and flexibility of PowerPivot and SSAS tabular models.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "e",
      "source": "https://en.wikipedia.org/wiki/E_(programming_language)",
      "about": "E is an object-oriented programming language for secure distributed computing, created by Mark S. Miller[1], Dan Bornstein, Douglas Crockford[2], Chip Morningstar[3] and others at Electric Communities in 1997. E is mainly descended from the concurrent language Joule and from Original-E, a set of extensions to Java for secure distributed programming. E combines message-based computation with Java-like syntax. A concurrency model based on event loops and promises ensures that deadlock can never occur.[citation needed]",
      "first_release": "1997",
      "types": "Strong, dynamic",
      "paradigms": "Multi-paradigm, object-oriented, message passing",
      "website": "http://erights.org/"
    },
    {
      "name": "ease",
      "source": "https://en.wikipedia.org/wiki/Ease_(programming_language)",
      "about": "Ease is a general purpose parallel programming language. It is designed by Steven Ericsson-Zenith, a researcher at Yale University, the Institute for Advanced Science & Engineering in Silicon Valley, California, the Ecole Nationale Supérieure des Mines de Paris, and the Pierre and Marie Curie University, the science department of the Sorbonne.[1]",
      "first_release": "1991",
      "types": "Strong",
      "paradigms": "Concurrent, communicating sequential processes",
      "website": ""
    },
    {
      "name": "easy pl/i",
      "source": "https://en.wikipedia.org/wiki/PL/I",
      "about": "PL/I (Programming Language One, pronounced /piː ɛl wʌn/ and sometimes written PL/1)[2] is a procedural, imperative computer programming language developed and published by IBM. It is designed for scientific, engineering, business and system programming. It has been used by academic, commercial and industrial organizations since it was introduced in the 1960s, and is still used.[3]",
      "first_release": "1964",
      "types": "",
      "paradigms": "Procedural, imperative, structured",
      "website": "http://bitsavers.trailing-edge.com/pdf/ibm/360/pli/"
    },
    {
      "name": "easytrieve plus",
      "source": "https://en.wikipedia.org/wiki/Easytrieve",
      "about": "CA Technologies, formerly known as CA, Inc. and Computer Associates International, Inc., is an American multinational corporation headquartered in New York City. Since November 5, 2018, the company has been a subsidiary of Broadcom Inc.[6]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.ca.com/"
    },
    {
      "name": "ec",
      "source": "https://en.wikipedia.org/wiki/EC_(programming_language)",
      "about": "eC (Ecere C) is an object-oriented programming language, defined as a super-set of the C language.",
      "first_release": "2004",
      "types": "Static, nominative, partially inferred",
      "paradigms": "Multi-paradigm, procedural, object-oriented, generic",
      "website": "http://ec-lang.org/"
    },
    {
      "name": "ecmascript",
      "source": "https://en.wikipedia.org/wiki/ECMAScript",
      "about": "ECMAScript (/i.si.ɛmˈeɪskrɪpt/) (or ES)[1] is a general-purpose programming language, standardized by Ecma International according to the document ECMA-262. It is a JavaScript standard meant to ensure the interoperability of Web pages across different Web browsers.[2] ECMAScript is commonly used for client-side scripting on the World Wide Web, and it is increasingly being used for writing server applications and services using Node.js.",
      "first_release": "1997",
      "types": "weak, dynamic",
      "paradigms": "Multi-paradigm, prototype-based, functional, imperative",
      "website": "http://www.ecma-international.org/"
    },
    {
      "name": "edinburgh imp",
      "source": "https://en.wikipedia.org/wiki/Edinburgh_IMP",
      "about": "Edinburgh IMP is a development of Atlas Autocode, initially developed around 1966-1969 at the University of Edinburgh, Scotland. It is a general-purpose programming language which was used heavily for systems programming.",
      "first_release": "1966",
      "types": "Static, strong",
      "paradigms": "Procedural, imperative, structured",
      "website": ""
    },
    {
      "name": "egl",
      "source": "https://en.wikipedia.org/wiki/EGL_(programming_language)",
      "about": "EGL (Enterprise Generation Language), originally developed by IBM and now available as the EDT (EGL Development Tools)[1] open source project under the Eclipse Public License (EPL), is a programming technology designed to meet the challenges of modern, multi-platform application development by providing a common language and programming model across languages, frameworks, and runtime platforms.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.eclipse.org/edt/"
    },
    {
      "name": "eiffel",
      "source": "https://en.wikipedia.org/wiki/Eiffel_(programming_language)",
      "about": "Eiffel is an object-oriented programming language designed by Bertrand Meyer (an object-orientation proponent and author of Object-Oriented Software Construction) and Eiffel Software. Meyer conceived the language in 1985 with the goal of increasing the reliability of commercial software development;[5] the first version becoming available in 1986. In 2005, Eiffel became an ISO-standardized language.",
      "first_release": "1986",
      "types": "static",
      "paradigms": "Object-oriented, Class-based, Generic, Concurrent",
      "website": "https://www.eiffel.org/"
    },
    {
      "name": "elan",
      "source": "https://en.wikipedia.org/wiki/ELAN_(programming_language)",
      "about": "ELAN is an educational programming language for learning and teaching systematic programming.",
      "first_release": "1974",
      "types": "",
      "paradigms": "",
      "website": "https://www.cs.ru.nl/elan/"
    },
    {
      "name": "elixir",
      "source": "https://en.wikipedia.org/wiki/Elixir_(programming_language)",
      "about": "Elixir is a functional, concurrent, general-purpose programming language that runs on the BEAM virtual machine used to implement the Erlang programming language.[3] Elixir builds on top of Erlang and shares the same abstractions for building distributed, fault-tolerant applications. Elixir also provides productive tooling and an extensible design. The latter is supported by compile-time metaprogramming with macros and polymorphism via protocols.[4]",
      "first_release": "2011",
      "types": "dynamic, strong, duck",
      "paradigms": "multi-paradigm, functional, concurrent, distributed, process-oriented",
      "website": "https://elixir-lang.org/"
    },
    {
      "name": "elm",
      "source": "https://en.wikipedia.org/wiki/Elm_(programming_language)",
      "about": "Elm is a domain-specific programming language for declaratively creating web browser-based graphical user interfaces. Elm is purely functional, and is developed with emphasis on usability, performance, and robustness. It advertises \"no runtime exceptions in practice\",[6] made possible by the Elm compiler's static type checking.",
      "first_release": "2012",
      "types": "Static, Strong, Inferred",
      "paradigms": "Functional",
      "website": "https://elm-lang.org/"
    },
    {
      "name": "emacs lisp",
      "source": "https://en.wikipedia.org/wiki/Emacs_Lisp",
      "about": "Emacs Lisp is a dialect of the Lisp programming language used as a scripting language by Emacs (a text editor family most commonly associated with GNU Emacs and XEmacs). It is used for implementing most of the editing functionality built into Emacs, the remainder being written in C, as is the Lisp interpreter. Emacs Lisp is also termed Elisp, although there is also an older, unrelated Lisp dialect with that name.[1]",
      "first_release": "1985",
      "types": "Dynamic, strong",
      "paradigms": "Functional, meta, reflective",
      "website": ""
    },
    {
      "name": "emerald",
      "source": "https://en.wikipedia.org/wiki/Emerald_(programming_language)",
      "about": "Emerald is a distributed, object-oriented programming language developed in the 1980s by Andrew P. Black, Norman C. Hutchinson, Eric B. Jul, and Henry M. Levy, in the Department of Computer Science at the University of Washington.[1]",
      "first_release": "1980",
      "types": "strong, static",
      "paradigms": "object-oriented",
      "website": "http://www.emeraldprogramminglanguage.org/"
    },
    {
      "name": "epigram",
      "source": "https://en.wikipedia.org/wiki/Epigram_(programming_language)",
      "about": "Epigram is a functional programming language with dependent types, and the integrated development environment (IDE) usually packaged with the language. Epigram's type system is strong enough to express program specifications. The goal is to support a smooth transition from ordinary programming to integrated programs and proofs which correctness can be checked and certified by the compiler. Epigram exploits the Curry–Howard correspondence, also termed the propositions as types principle, and is based on intuitionistic type theory.",
      "first_release": "2004",
      "types": "strong, static, dependent",
      "paradigms": "Functional",
      "website": "https://web.archive.org/web/20120717070845/http://www.e-pig.org/darcs/Pig09/web/"
    },
    {
      "name": "epl",
      "source": "https://en.wikipedia.org/wiki/Easy_Programming_Language",
      "about": "Easy Programming Language (EPL, Chinese: 易语言) is a visual compiled multilingual[1] proprietary programming language. EPL is somewhat popular in China because it features a full Chinese environment. (The language has traditional Chinese, simplified Chinese, English and Japanese variants.)",
      "first_release": "2004",
      "types": "",
      "paradigms": "Multi-paradigm, compiled, imperative, procedural, object-oriented, functional",
      "website": "http://epl.eyuyan.com/"
    },
    {
      "name": "epl",
      "source": "https://en.wikipedia.org/wiki/Eltron_Programming_Language",
      "about": "Eltron Programming Language (EPL) is a printer control language used to produce printed labels for various Eltron model printers.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "erlang",
      "source": "https://en.wikipedia.org/wiki/Erlang_(programming_language)",
      "about": "Erlang (/ˈɜːrlæŋ/ UR-lang) is a general-purpose, concurrent, functional programming language, and a garbage-collected runtime system. The term Erlang is used interchangeably with Erlang/OTP, or Open Telecom Platform (OTP), which consists of the Erlang runtime system, several ready-to-use components (OTP) mainly written in Erlang, and a set of design principles for Erlang programs.[3]",
      "first_release": "1986",
      "types": "Dynamic, strong",
      "paradigms": "Multi-paradigm, concurrent, functional",
      "website": "http://www.erlang.org/"
    },
    {
      "name": "es",
      "source": "https://en.wikipedia.org/wiki/Es_(Unix_shell)",
      "about": "rc (for \"run commands\") is the command line interpreter for Version 10 Unix and Plan 9 from Bell Labs operating systems. It resembles the Bourne shell, but its syntax is somewhat simpler. It was created by Tom Duff, who is better known for an unusual C programming language construct (\"Duff's device\").[1]",
      "first_release": "1989",
      "types": "weak",
      "paradigms": "imperative, pipeline",
      "website": "http://doc.cat-v.org/plan_9/4th_edition/papers/rc"
    },
    {
      "name": "escher",
      "source": "https://en.wikipedia.org/wiki/Escher_(programming_language)",
      "about": "Escher (named for M. C. Escher, \"a master of endless loops\") is a declarative programming language that supports both functional programming and logic programming models, developed by J.W. Lloyd in the mid-1990s. It was designed mostly as a research and teaching vehicle. The basic view of programming exhibited by Escher and related languages is that a program is a representation of a theory in some logic framework, and the program's execution (computation) is a deduction from the theory. The logic framework for Escher is Alonzo Church's simple theory of types.",
      "first_release": "1990",
      "types": "static, manifest",
      "paradigms": "declarative, functional, logic",
      "website": ""
    },
    {
      "name": "espol",
      "source": "https://en.wikipedia.org/wiki/Executive_Systems_Problem_Oriented_Language",
      "about": "The Executive Systems Problem Oriented Language (ESPOL) is a programming language, a superset of ALGOL 60, that provides abilities of what would later be termed a system programming language or machine oriented high order language (mohol), such as interrupting a processor on a multiprocessing system (the Burroughs large systems were multiprocessor systems). ESPOL was used to write the Master Control Program (MCP) on Burroughs computer systems from the B5000 to the B6700. The single-pass compiler for ESPOL could compile over 250 lines per second.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "esterel",
      "source": "https://en.wikipedia.org/wiki/Esterel",
      "about": "Esterel is a synchronous programming language for the development of complex reactive systems. The imperative programming style of Esterel allows the simple expression of parallelism and preemption. As a consequence, it is well suited for control-dominated model designs.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "etoys",
      "source": "https://en.wikipedia.org/wiki/Etoys_(programming_language)",
      "about": "Etoys is a child-friendly computer environment and object-oriented prototype-based programming language for use in education.",
      "first_release": "1996",
      "types": "dynamic",
      "paradigms": "object-oriented, prototype-based, educational",
      "website": ""
    },
    {
      "name": "euclid",
      "source": "https://en.wikipedia.org/wiki/Euclid_(programming_language)",
      "about": "Euclid is an imperative programming language for writing verifiable programs. It was designed by Butler Lampson and associates at the Xerox PARC lab in the mid-1970s. The implementation was led by Ric Holt at the University of Toronto and James Cordy was the principal programmer for the first implementation of the compiler. It was originally designed for the Motorola 6809 microprocessor. It was considered innovative for the time; the compiler development team had a $2 million budget over 2 years and was commissioned by the Defense Advanced Research Projects Agency of the U.S. Department of Defense and the Canadian Department of National Defence. It was used for a few years at I. P. Sharp Associates, MITRE Corporation, SRI International and various other international institutes for research in systems programming and secure software systems.",
      "first_release": "1970",
      "types": "strong, static",
      "paradigms": "multi-paradigm, structured, imperative, functional",
      "website": ""
    },
    {
      "name": "euler",
      "source": "https://en.wikipedia.org/wiki/Euler_(programming_language)",
      "about": "Euler is a programming language created by Niklaus Wirth and Helmut Weber, conceived as an extension and generalization of ALGOL 60.[1][2][3] The designers' goals were to create a language that is:",
      "first_release": "1965",
      "types": "dynamic",
      "paradigms": "Multi-paradigm, procedural, imperative, structured",
      "website": ""
    },
    {
      "name": "euphoria",
      "source": "https://en.wikipedia.org/wiki/Euphoria_(programming_language)",
      "about": "Euphoria is a programming language created by Robert Craig of Rapid Deployment Software[1] in Toronto, Ontario, Canada. Initially developed (though not publicly released) on the Atari ST,[2] the first commercial release[3] was for the 16-bit DOS platform and was proprietary. In 2006, with the release of version 3,[4] Euphoria became open-source software. The openEuphoria Group continues to administer and develop the project.[5] In December 2010, the openEuphoria Group released version 4[6] of openEuphoria along with a new identity and mascot for the project. OpenEuphoria is currently available for Windows, Linux, macOS and three flavors of *BSD.",
      "first_release": "1993",
      "types": "",
      "paradigms": "Imperative, procedural",
      "website": "http://openeuphoria.org/"
    },
    {
      "name": "euslisp robot programming language",
      "source": "https://en.wikipedia.org/wiki/EusLisp_Robot_Programming_Language",
      "about": "EusLisp is a Lisp-based programming system. Built on the basis of object orientation, it is designed specifically for developing robotics software. The first version of it ran in 1986 on Unix-System5/Ustation-E20.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "cms exec",
      "source": "https://en.wikipedia.org/wiki/CMS_EXEC",
      "about": "CMS EXEC, or EXEC, is an interpreted, command procedure control, computer scripting language used by the CMS EXEC Processor supplied with the IBM Virtual Machine/Conversational Monitor System (VM/CMS) operating system.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "exec 2",
      "source": "https://en.wikipedia.org/wiki/EXEC_2",
      "about": "EXEC 2 is an interpreted, command procedure control, computer scripting language used by the EXEC 2 Processor supplied with the IBM Virtual Machine/System Product (VM/SP) operating system.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "executable uml",
      "source": "https://en.wikipedia.org/wiki/Executable_UML",
      "about": "Executable UML (xtUML or xUML) is both a software development method and a highly abstract software language. It was described for the first time in 2002 in the book \"Executable UML: A Foundation for Model-Driven Architecture\".[1] The language \"combines a subset of the UML (Unified Modeling Language) graphical notation with executable semantics and timing rules.\"[2] The Executable UML method is the successor to the Shlaer–Mellor method.[3]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "ezhil",
      "source": "https://en.wikipedia.org/wiki/Ezhil_(programming_language)",
      "about": "Ezhil, in Tamil language script (Tamil: எழில், romanized: Eḻil, lit. 'beauty', Tamil pronunciation: [eɻil̪]), is a compact, open source, interpreted, programming language, originally designed to enable native-Tamil speaking students, K-12 age-group to learn computer programming, and enable learning numeracy and computing, outside of linguistic expertise in predominately English language-based computer systems.",
      "first_release": "2007",
      "types": "strong, dynamic",
      "paradigms": "interpreted, imperative, structured",
      "website": "http://ezhillang.org/"
    },
    {
      "name": "f",
      "source": "https://en.wikipedia.org/wiki/F_(programming_language)",
      "about": "F is a modular, compiled, numeric programming language, designed for scientific programming and scientific computation.[1] F was developed as a modern Fortran, thus making it a subset of Fortran 95.[2] It combines both numerical and data abstraction features from these languages. F is also backwards compatible with Fortran 77, allowing calls to Fortran 77 programs. F was first included in the g95 compiler.",
      "first_release": "",
      "types": "static, manifest",
      "paradigms": "procedural, modular",
      "website": ""
    },
    {
      "name": "f#",
      "source": "https://en.wikipedia.org/wiki/F_Sharp_(programming_language)",
      "about": "F# (pronounced F sharp) is a functional-first, general purpose, strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. F# is most often used as a cross-platform Common Language Infrastructure (CLI) language on .NET Core, but it can also generate JavaScript[9] and graphics processing unit (GPU) code.[10]",
      "first_release": "2005",
      "types": "Static, strong, inferred",
      "paradigms": "Multi-paradigm, functional, imperative, object-oriented, metaprogramming, reflective, concurrent",
      "website": "http://fsharp.org/"
    },
    {
      "name": "f*",
      "source": "https://en.wikipedia.org/wiki/F*_(programming_language)",
      "about": "F* (pronounced F star) is a functional programming language inspired by ML and aimed at program verification. Its type system includes dependent types, monadic effects, and refinement types. This allows expressing precise specifications for programs, including functional correctness and security properties. The F* type-checker aims to prove that programs meet their specifications using a combination of SMT solving and manual proofs. Programs written in F* can be translated to OCaml, F#, and C for execution. Previous versions of F* could also be translated to JavaScript.",
      "first_release": "",
      "types": "Dependent, inferred, static, strong",
      "paradigms": "Multi-paradigm, functional, imperative",
      "website": "https://www.fstar-lang.org/"
    },
    {
      "name": "factor",
      "source": "https://en.wikipedia.org/wiki/Factor_(programming_language)",
      "about": "Factor is a stack-oriented programming language created by Slava Pestov. Factor is dynamically typed and has automatic memory management, as well as powerful metaprogramming features. The language has a single implementation featuring a self-hosted optimizing compiler and an interactive development environment. The Factor distribution includes a large standard library.",
      "first_release": "2003",
      "types": "strong, dynamic",
      "paradigms": "multi-paradigm, functional, concatenative, stack-oriented",
      "website": "http://factorcode.org/"
    },
    {
      "name": "fantom",
      "source": "https://en.wikipedia.org/wiki/Fantom_(programming_language)",
      "about": "Fantom is a general purpose object-oriented programming language created by Brian and Andy Frank[4] that runs on the Java Runtime Environment (JRE), JavaScript, and the .NET Common Language Runtime (CLR) (.NET support is considered \"prototype\"[5] status). Its primary design goal is to provide a standard library API[6] that abstracts away the question of whether the code will ultimately run on the JRE or CLR. Like C# and Java, Fantom uses a curly brace syntax. The language supports functional programming through closures and concurrency through the Actor model. Fantom takes a \"middle of the road\" approach to its type system, blending together aspects of both static and dynamic typing.",
      "first_release": "2005",
      "types": "static, dynamic",
      "paradigms": "multi-paradigm",
      "website": "http://www.fantom.org/"
    },
    {
      "name": "faust",
      "source": "https://en.wikipedia.org/wiki/FAUST_(programming_language)",
      "about": "FAUST (Functional AUdio STream) is a domain-specific purely functional programming language for implementing signal processing algorithms in the form of libraries, audio plug-ins, or standalone applications. A FAUST program denotes a signal processor: a mathematical function that is applied to some input signal and then fed out.",
      "first_release": "2002",
      "types": "",
      "paradigms": "",
      "website": "http://faust.grame.fr/"
    },
    {
      "name": "ffp",
      "source": "https://en.wikipedia.org/wiki/FFP_(programming_language)",
      "about": "FP (short for functional programming)[2] is a programming language created by John Backus to support the function-level programming[2] paradigm. This allows eliminating named variables. The language was introduced in Backus's 1977 Turing Award paper, \"Can Programming Be Liberated from the von Neumann Style?\", subtitled \"a functional style and its algebra of programs.\" The paper sparked interest in functional programming research,[3] eventually leading to modern functional languages, and not the function-level paradigm Backus had hoped.",
      "first_release": "1977",
      "types": "",
      "paradigms": "Function-level",
      "website": ""
    },
    {
      "name": "fish",
      "source": "https://en.wikipedia.org/wiki/Friendly_interactive_shell",
      "about": "fish is a Unix shell that attempts to be more interactive and user-friendly than those with a longer history (i.e. most other Unix shells) or those formulated as function-compatible replacements for the aforementioned (e.g. zsh, the Falstad shell). The design goal of fish is to give the user a rich set of powerful features in a way that is easy to discover, remember, and use.[4] fish is considered an \"exotic shell\",[citation needed] in that its syntax derives from neither the Bourne shell (ksh, Bash, zsh) nor the C shell (csh, tcsh). Also unlike previous shells, which disable certain features by default to save system resources, fish enables all features by default.",
      "first_release": "2005",
      "types": "",
      "paradigms": "",
      "website": "http://fishshell.com/"
    },
    {
      "name": "fjölnir",
      "source": "https://en.wikipedia.org/wiki/Fj%C3%B6lnir_(programming_language)",
      "about": "Fjölnir (also Fjolnir or Fjoelnir) is a programming language developed by professor Snorri Agnarsson of computer science at Háskóli Íslands (University of Iceland) that was mostly used in the 1980s. The source files usually have the extension fjo or sma.",
      "first_release": "1980",
      "types": "",
      "paradigms": "object-oriented",
      "website": ""
    },
    {
      "name": "fl",
      "source": "https://en.wikipedia.org/wiki/FL_(programming_language)",
      "about": "FL (short for \"Function Level\") is a programming language created at the IBM Almaden Research Center by John Backus, John Williams, and Edward Wimmers in the 1980s and documented in a report from 1989.[1] FL was designed as a successor of Backus' earlier FP language, providing specific support for what Backus termed function-level programming.",
      "first_release": "1989",
      "types": "Dynamic",
      "paradigms": "Function-level, functional",
      "website": ""
    },
    {
      "name": "flavors",
      "source": "https://en.wikipedia.org/wiki/Flavors_(programming_language)",
      "about": "Flavors,[1] an early object-oriented extension to Lisp developed by Howard Cannon at the MIT Artificial Intelligence Laboratory for the Lisp machine and its programming language Lisp Machine Lisp, was the first programming language to include mixins.[2] Symbolics used it for its Lisp machines, and eventually developed it into New Flavors; both the original and new Flavors were message passing OO models. It was hugely influential in the development of the Common Lisp Object System (CLOS).[3]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "flex",
      "source": "https://en.wikipedia.org/wiki/Flex_(language)",
      "about": "In computing, the FLEX language was developed by Alan Kay in the late 1960s while exploring ideas that would later evolve into the Smalltalk programming language.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "flix",
      "source": "https://en.wikipedia.org/wiki/Flix_(programming_language)",
      "about": "Flix is a functional, imperative, and logic programming language developed at Aarhus University, with funding from the Independent Research Fund Denmark,[2] and by a community of open source contributors.[3] The Flix language supports algebraic data types, pattern matching, parametric polymorphism, currying, higher-order functions, extensible records,[4] channel and process-based concurrency, and tail call elimination. Two notable features of Flix are its type and effect system[5] and its support for first-class Datalog constraints.[6]",
      "first_release": "",
      "types": "inferred, static, strong, structural",
      "paradigms": "Multi-paradigm, functional, imperative, logic",
      "website": "https://flix.dev/"
    },
    {
      "name": "floop",
      "source": "https://en.wikipedia.org/wiki/BlooP_and_FlooP",
      "about": "BlooP and FlooP are simple programming languages designed by Douglas Hofstadter to illustrate a point in his book Gödel, Escher, Bach.[1] BlooP is a non-Turing-complete programming language whose main control flow structure is a bounded loop (i.e. recursion is not permitted). All programs in the language must terminate, and this language can only express primitive recursive functions.[2]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "flow-matic",
      "source": "https://en.wikipedia.org/wiki/FLOW-MATIC",
      "about": "FLOW-MATIC, originally known as B-0 (Business Language version 0), was the first English-like data processing language. It was developed for the UNIVAC I at Remington Rand under Grace Hopper from 1955 to 1959, and helped shape the development of COBOL.",
      "first_release": "1955",
      "types": "",
      "paradigms": "imperative",
      "website": ""
    },
    {
      "name": "focal",
      "source": "https://en.wikipedia.org/wiki/FOCAL_(programming_language)",
      "about": "FOCAL is an interactive interpreted programming language based on JOSS and primarily used on Digital Equipment Corporation (DEC) PDP-series machines. The name is an acronym for Formulating On-Line Calculations in Algebraic Language,[1] or for FOrmula CALculator.[2]",
      "first_release": "1968",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "focus",
      "source": "https://en.wikipedia.org/wiki/FOCUS",
      "about": "FOCUS is a fourth-generation programming language (4GL) computer programming language and development environment that is used to build database queries. Produced by Information Builders Inc., it was originally developed for data handling and analysis on the IBM mainframe. Subsequently versions for minicomputers and such as the VAX and other platforms[1] were implemented.[2][3] FOCUS was later extended to personal computers and (in 1997) to the World Wide Web: the WebFOCUS product.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "foil",
      "source": "https://en.wikipedia.org/wiki/FOIL_(programming_language)",
      "about": "FOIL was the name for two different programming languages.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "formac",
      "source": "https://en.wikipedia.org/wiki/FORMAC_(programming_language)",
      "about": "FORMAC, the FORmula MAnipulation Compiler, was the first computer algebra system to have significant use.[1] It was developed by Jean E. Sammet and her team, as an extension of FORTRAN IV. The compiler was implemented as a preprocessor taking the FORMAC program and converting it to a FORTRAN IV program which was in turn compiled without further user intervention.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "@formula",
      "source": "https://en.wikipedia.org/wiki/Formula_language",
      "about": "The Formula language is a scripting language used by Lotus Notes. It is often referred to as @Formula language (pronounced at-formula) because many language elements start with the @-character. Here is an example of a selection formula:",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "forth",
      "source": "https://en.wikipedia.org/wiki/Forth_(programming_language)",
      "about": "Forth is an imperative stack-based computer programming language and environment originally designed by Chuck Moore. Language features include structured programming, reflection (the ability to examine and modify program structure during execution), concatenative programming (functions are composed with juxtaposition) and extensibility (the programmer can create new commands). Although not an acronym, the language's name is sometimes spelled with all capital letters as FORTH, following the customary usage during its earlier years.",
      "first_release": "1970",
      "types": "typeless",
      "paradigms": "Procedural, stack-oriented, reflective, concatenative",
      "website": ""
    },
    {
      "name": "fortran",
      "source": "https://en.wikipedia.org/wiki/Fortran",
      "about": "Fortran (/ˈfɔːrtræn/; formerly FORTRAN, derived from Formula Translation[2]) is a general-purpose, compiled imperative programming language that is especially suited to numeric computation and scientific computing.",
      "first_release": "1957",
      "types": "strong, static, manifest",
      "paradigms": "multi-paradigm, structured, imperative, procedural, object-oriented, generic, array",
      "website": "https://fortran-lang.org/"
    },
    {
      "name": "fortress",
      "source": "https://en.wikipedia.org/wiki/Fortress_(programming_language)",
      "about": "Fortress is a discontinued experimental programming language for high-performance computing, created by Sun Microsystems with funding from DARPA's High Productivity Computing Systems project. One of the language designers was Guy L. Steele Jr., whose previous work includes Scheme, Common Lisp, and Java.",
      "first_release": "2006",
      "types": "Static",
      "paradigms": "",
      "website": "https://github.com/stokito/fortress-lang"
    },
    {
      "name": "fp",
      "source": "https://en.wikipedia.org/wiki/FP_(programming_language)",
      "about": "FP (short for functional programming)[2] is a programming language created by John Backus to support the function-level programming[2] paradigm. This allows eliminating named variables. The language was introduced in Backus's 1977 Turing Award paper, \"Can Programming Be Liberated from the von Neumann Style?\", subtitled \"a functional style and its algebra of programs.\" The paper sparked interest in functional programming research,[3] eventually leading to modern functional languages, and not the function-level paradigm Backus had hoped.",
      "first_release": "1977",
      "types": "",
      "paradigms": "Function-level",
      "website": ""
    },
    {
      "name": "franz lisp",
      "source": "https://en.wikipedia.org/wiki/Franz_Lisp",
      "about": "In computer programming, Franz Lisp is a discontinued Lisp programming language system written at the University of California, Berkeley (UC Berkeley, UCB) by Professor Richard Fateman and several students, based largely on Maclisp and distributed with the Berkeley Software Distribution (BSD) for the Digital Equipment Corporation (DEC) VAX minicomputer.[1] Piggybacking on the popularity of the BSD package, Franz Lisp was probably the most widely distributed and used Lisp system of the 1970s and 1980s.[2]",
      "first_release": "1980",
      "types": "Dynamic, strong",
      "paradigms": "Multi-paradigm, functional, procedural, reflective, meta",
      "website": ""
    },
    {
      "name": "futhark",
      "source": "https://en.wikipedia.org/wiki/Futhark_(programming_language)",
      "about": "Futhark is a functional data parallel array programming language originally developed at DIKU as part of the HIPERFIT project.[1] It focuses on enabling data parallel programs written in a functional style to be executed with high performance on massively parallel hardware, in particular on GPUs. Futhark is strongly inspired by NESL, but imposes constraints on how parallelism can be expressed in order to enable more aggressive compiler optimisations. In particular, irregular nested data parallelism is not supported.[2]",
      "first_release": "2014",
      "types": "static, strong",
      "paradigms": "Array, functional",
      "website": "https://futhark-lang.org/"
    },
    {
      "name": "f-script",
      "source": "https://en.wikipedia.org/wiki/F-Script_(programming_language)",
      "about": "F-Script is an object-oriented scripting programming language for Apple's macOS operating system developed by Philippe Mougin. F-Script is an interactive language based on Smalltalk, using macOS's native Cocoa API.",
      "first_release": "2009",
      "types": "dynamic",
      "paradigms": "multi-paradigm, object-oriented, array",
      "website": "https://github.com/pmougin/F-Script"
    },
    {
      "name": "game maker language",
      "source": "https://en.wikipedia.org/wiki/Game_Maker_Language",
      "about": "GameMaker (originally Animo and later Game Maker until 2011) is a series of cross-platform game engines created by Mark Overmars in 1999 and developed by YoYo Games since 2007. The latest iteration is GameMaker Studio 2, first released in 2017.",
      "first_release": "1999",
      "types": "",
      "paradigms": "",
      "website": "https://www.yoyogames.com/gamemaker"
    },
    {
      "name": "scripting language",
      "source": "https://en.wikipedia.org/wiki/Scripting_language",
      "about": "A scripting or script language is a programming language for a special run-time environment that automates the execution of tasks;[1] the tasks could alternatively be executed one-by-one by a human operator. Scripting languages are often interpreted, rather than compiled.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "gamemonkey script",
      "source": "https://en.wikipedia.org/wiki/GameMonkey_Script",
      "about": "GameMonkey Script is a small, cross-platform scripting language designed for embedding into games. GameMonkey bears many similarities to Lua, except the syntax is more similar to that of C.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "gams",
      "source": "https://en.wikipedia.org/wiki/General_Algebraic_Modeling_System",
      "about": "The General Algebraic Modeling System (GAMS) is a high-level modeling system for mathematical optimization. GAMS is designed for modeling and solving linear, nonlinear, and mixed-integer optimization problems. The system is tailored for complex, large-scale modeling applications and allows the user to build large maintainable models that can be adapted to new situations. The system is available for use on various computer platforms. Models are portable from one platform to another.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "https://www.gams.com/"
    },
    {
      "name": "gap",
      "source": "https://en.wikipedia.org/wiki/GAP_computer_algebra_system",
      "about": "GAP (Groups, Algorithms and Programming) is a computer algebra system for computational discrete algebra with particular emphasis on computational group theory.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "https://www.gap-system.org/"
    },
    {
      "name": "g-code",
      "source": "https://en.wikipedia.org/wiki/G-code",
      "about": "G-code (also RS-274) is the most widely used computer numerical control (CNC) programming language. It is used mainly in computer-aided manufacturing to control automated machine tools, and has many variants.",
      "first_release": "1950",
      "types": "",
      "paradigms": "Procedural, Imperative",
      "website": ""
    },
    {
      "name": "gdscript",
      "source": "https://en.wikipedia.org/wiki/GDScript",
      "about": "Godot is a 2D and 3D, cross-platform, free and open-source game engine released under the MIT license. It was initially developed by Argentinians Juan Linietsky and Ariel Manzur[5] for several companies in Latin America prior to its public release.[6] The development environment runs on multiple operating systems including Linux, BSDs, macOS, and Microsoft Windows. Godot can create games targeting PC, mobile, and web platforms.",
      "first_release": "2014",
      "types": "",
      "paradigms": "",
      "website": "https://godotengine.org/"
    },
    {
      "name": "genie",
      "source": "https://en.wikipedia.org/wiki/Genie_(programming_language)",
      "about": "Genie is a modern, general-purpose high-level programming language in development since 2008.[1] It was designed as an alternative, simpler and cleaner dialect for the Vala compiler, while preserving the same functionality of the Vala language. Genie uses the same compiler and libraries as Vala; the two can indeed be used alongside each other.[2] The differences are only syntactic.",
      "first_release": "2008",
      "types": "static, strong",
      "paradigms": "multi-paradigm, imperative, structured, object-oriented",
      "website": "https://wiki.gnome.org/Projects/Genie"
    },
    {
      "name": "gdl",
      "source": "https://en.wikipedia.org/wiki/Geometric_Description_Language",
      "about": "In computer-aided design, Geometric Description Language (GDL) is the programming language of ArchiCAD library parts. GSM is the file format of these CAD objects.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "george",
      "source": "https://en.wikipedia.org/wiki/GEORGE_(programming_language)",
      "about": "GEORGE (General Order Generator) is a programming language invented by Charles Leonard Hamblin in 1957.[1][2][3][4]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "glsl",
      "source": "https://en.wikipedia.org/wiki/GLSL",
      "about": "OpenGL Shading Language (GLSL) is a high-level shading language with a syntax based on the C programming language. It was created by the OpenGL ARB (OpenGL Architecture Review Board) to give developers more direct control of the graphics pipeline without having to use ARB assembly language or hardware-specific languages.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "gnu e",
      "source": "https://en.wikipedia.org/wiki/GNU_E",
      "about": "GNU E is an extension of C++ designed for writing software systems to support persistent applications. It was designed as part of the Exodus project.",
      "first_release": "1991",
      "types": "strong",
      "paradigms": "object-oriented",
      "website": "ftp://ftp.cs.wisc.edu/exodus/E/"
    },
    {
      "name": "gnu guile",
      "source": "https://en.wikipedia.org/wiki/GNU_Guile",
      "about": "GNU Ubiquitous Intelligent Language for Extensions[3] (GNU Guile) is the preferred extension language system for the GNU Project[4] and features an implementation of the programming language Scheme. Its first version was released in 1993.[1] In addition to large parts of Scheme standards, Guile Scheme includes modularized extensions for many different programming tasks.[5][6]",
      "first_release": "1993",
      "types": "",
      "paradigms": "",
      "website": "https://gnu.org/software/guile"
    },
    {
      "name": "go",
      "source": "https://en.wikipedia.org/wiki/Go_(programming_language)",
      "about": "Go is a statically typed, compiled programming language designed at Google[14] by Robert Griesemer, Rob Pike, and Ken Thompson.[12] Go is syntactically similar to C, but with memory safety, garbage collection, structural typing,[6] and CSP-style concurrency.[15] The language is often referred to as Golang because of its domain name, golang.org, but the proper name is Go.[16]",
      "first_release": "2009",
      "types": "Inferred, static, strong, structural, [6], [7]",
      "paradigms": "Multi-paradigm, concurrent, functional, [1], imperative, object-oriented, [2], [3]",
      "website": "https://golang.org/"
    },
    {
      "name": "go!",
      "source": "https://en.wikipedia.org/wiki/Go!_(programming_language)",
      "about": "Go! is an agent-based programming language in the tradition of logic-based programming languages like Prolog.[1] It was introduced in a 2003 paper by Francis McCabe and Keith Clark.[2]",
      "first_release": "2003",
      "types": "strong",
      "paradigms": "Multi-paradigm, concurrent, logic, functional, imperative, object-based",
      "website": ""
    },
    {
      "name": "goal",
      "source": "https://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp",
      "about": "Game Oriented Assembly Lisp (GOAL) is a programming language, a dialect of the language Lisp, made for video games developed by Andy Gavin and the Jak and Daxter team at the company Naughty Dog.",
      "first_release": "2001",
      "types": "Dynamic, latent, strong",
      "paradigms": "Multi-paradigm",
      "website": ""
    },
    {
      "name": "gödel",
      "source": "https://en.wikipedia.org/wiki/G%C3%B6del_(programming_language)",
      "about": "Gödel is a declarative, general-purpose programming language that adheres to the logic programming paradigm. It is a strongly typed language, the type system being based on many-sorted logic with parametric polymorphism. It is named after logician Kurt Gödel.",
      "first_release": "1992",
      "types": "strong",
      "paradigms": "declarative, logic",
      "website": ""
    },
    {
      "name": "golo",
      "source": "https://en.wikipedia.org/wiki/Golo_(programming_language)",
      "about": "Golo is computer software, a programming language for the Java virtual machine (JVM). It is simple, with dynamic, weak typing. It was created in 2012 as part of the research activities of the DynaMid group of the Centre of Innovation in Telecommunications and Integration of service (CITI) Laboratory at Institut national des sciences appliquées de Lyon (INSA). It is distributed as free and open-source software under the Eclipse Public License 2.0.",
      "first_release": "2012",
      "types": "Dynamic, weak",
      "paradigms": "",
      "website": "http://golo-lang.org/"
    },
    {
      "name": "gom",
      "source": "https://en.wikipedia.org/wiki/MAD_(programming_language)",
      "about": "MAD (Michigan Algorithm Decoder) is a programming language and compiler for the IBM 704 and later the IBM 709, IBM 7090, IBM 7040, UNIVAC 1107, UNIVAC 1108, Philco 210-211, and eventually the IBM S/370 mainframe computers. Developed in 1959 at the University of Michigan by Bernard Galler, Bruce Arden and Robert M. Graham, MAD is a variant of the ALGOL language. It was widely used to teach programming at colleges and universities during the 1960s and played a minor role in the development of CTSS, Multics, and the Michigan Terminal System computer operating systems.[1]",
      "first_release": "1959",
      "types": "",
      "paradigms": "Imperative",
      "website": ""
    },
    {
      "name": "google apps script",
      "source": "https://en.wikipedia.org/wiki/Google_Apps_Script",
      "about": "Apps Script is a scripting platform developed by Google for light-weight application development in the Google Workspace platform. Google Apps Script was initially developed by Mike Harm as a side project whilst working as a developer on Google Sheets.[2] Google Apps Script was first publicly announced in May 2009 when a beta testing program was announced by Jonathan Rochelle, then Product Manager, Google Docs.[3] In August 2009 Google Apps Script was subsequently made available to all Google Apps Premier and Education Edition customers.[4] It is based on JavaScript 1.6, but also includes some portions of 1.7 and 1.8 and a subset of the ECMAScript 5 API.[5] Apps Script projects run server-side on Google's infrastructure. According to Google, Apps Script \"provides easy ways to automate tasks across Google products and third party services.\"[6] Apps Script is also the tool that powers the add-ons for Google Docs, Sheets and Slides.[7]",
      "first_release": "2009",
      "types": "",
      "paradigms": "",
      "website": "https://script.google.com/"
    },
    {
      "name": "gosu",
      "source": "https://en.wikipedia.org/wiki/Gosu_(programming_language)",
      "about": "Gosu is a statically-typed general-purpose programming language that runs on the Java Virtual Machine. Its influences include Java, C#, and ECMAScript. Development of Gosu began in 2002 internally for Guidewire Software, and the language saw its first community release in 2010 under the Apache 2 license.[1]",
      "first_release": "",
      "types": "static",
      "paradigms": "",
      "website": "http://gosu-lang.org/"
    },
    {
      "name": "gotran",
      "source": "https://en.wikipedia.org/wiki/IBM_1620",
      "about": "The IBM 1620 was announced by IBM on October 21, 1959,[1] and marketed as an inexpensive \"scientific computer\".[2] After a total production of about two thousand machines, it was withdrawn on November 19, 1970. Modified versions of the 1620 were used as the CPU of the IBM 1710 and IBM 1720 Industrial Process Control Systems (making it the first digital computer considered reliable enough for real-time process control of factory equipment).[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "gpss",
      "source": "https://en.wikipedia.org/wiki/GPSS",
      "about": "General Purpose Simulation System (GPSS) is a discrete time simulation general-purpose programming language, where a simulation clock advances in discrete steps. A system is modelled as transactions enter the system and are passed from one service (represented by blocks) to another. It is used primarily as a process flow oriented simulation language;[1] this is particularly well-suited for problems such as a factory.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "graphtalk",
      "source": "https://en.wikipedia.org/wiki/Computer_Sciences_Corporation",
      "about": "Computer Sciences Corporation (CSC) was an American multinational corporation that provided information technology (IT) services and professional services. On April 3, 2017, it merged with the Enterprise Services line of business of HP Enterprise (formerly Electronic Data Systems) to create DXC Technology.[2][3]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "grass",
      "source": "https://en.wikipedia.org/wiki/GRASS_(programming_language)",
      "about": "GRASS (GRAphics Symbiosis System) is a programming language created to script 2D vector graphics animations. GRASS was similar to BASIC in syntax, but added numerous instructions for specifying 2D object animation, including scaling, translation and rotation over time. These functions were directly supported by the Vector General 3D graphics terminal GRASS was written for. It quickly became a hit with the artistic community who were experimenting with the new medium of computer graphics, and is most famous for its use by Larry Cuba to create the original \"attacking the Death Star will not be easy\" animation in Star Wars (1977).",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "grasshopper",
      "source": "https://en.wikipedia.org/wiki/Grasshopper_3D",
      "about": "Grasshopper is a visual programming language and environment that runs within the Rhinoceros 3D computer-aided design (CAD) application. The program was created by David Rutten at Robert McNeel & Associates.[1][2] Programs are created by dragging components onto a canvas. The outputs to these components are then connected to the inputs of subsequent components.",
      "first_release": "2007",
      "types": "",
      "paradigms": "visual programming",
      "website": "http://grasshopper3d.com/"
    },
    {
      "name": "groovy",
      "source": "https://en.wikipedia.org/wiki/Groovy_(programming_language)",
      "about": "Apache Groovy is a Java-syntax-compatible object-oriented programming language for the Java platform. It is both a static and dynamic language with features similar to those of Python, Ruby, and Smalltalk. It can be used as both a programming language and a scripting language for the Java Platform, is compiled to Java virtual machine (JVM) bytecode, and interoperates seamlessly with other Java code and libraries. Groovy uses a curly-bracket syntax similar to Java's. Groovy supports closures, multiline strings, and expressions embedded in strings. Much of Groovy's power lies in its AST transformations, triggered through annotations.",
      "first_release": "2003",
      "types": "Dynamic, static, strong, duck",
      "paradigms": "Object-oriented, imperative, scripting",
      "website": "https://groovy-lang.org/"
    },
    {
      "name": "hack",
      "source": "https://en.wikipedia.org/wiki/Hack_(programming_language)",
      "about": "Hack is a programming language for the HipHop Virtual Machine (HHVM), created by Facebook as a dialect of PHP. The language implementation is open-source, licensed under the MIT License.[2][3][4]",
      "first_release": "2014",
      "types": "Static, dynamic, weak, gradual",
      "paradigms": "",
      "website": "https://hacklang.org/"
    },
    {
      "name": "haggis",
      "source": "https://en.wikipedia.org/wiki/HAGGIS",
      "about": "Haggis is a high-level reference programming language used primarily to examine computing science for Scottish pupils taking SQA courses on the subject.[1] Haggis is used as a tool to bridge the gap between pseudocode and typical computer programming.[2]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "hal/s",
      "source": "https://en.wikipedia.org/wiki/HAL/S",
      "about": "HAL/S (High-order Assembly Language/Shuttle)[1][2] is a real-time aerospace programming language compiler and cross-compiler for avionics applications used by NASA and associated agencies (JPL, etc.). It has been used in many U.S. space projects since 1973 and its most significant use was in the Space Shuttle program (approximately 85% of the Shuttle software is coded in HAL/S).[3] It was designed by Intermetrics in 1972 for NASA and delivered in 1973. HAL/S is written in XPL, a dialect of PL/I.[4] Although HAL/S is designed primarily for programming on-board computers, it is general enough to meet nearly all the needs in the production, verification, and support of aerospace and other real-time applications. According to documentation from 2005, it is been maintained by the HAL/S project of United Space Alliance.[5]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "halide",
      "source": "https://en.wikipedia.org/wiki/Halide_(programming_language)",
      "about": "Halide is a computer programming language designed for writing digital image processing code that takes advantage of memory locality, vectorized computation and multi-core CPUs and GPUs.[1] Halide is implemented as an internal domain-specific language (DSL) in C++.",
      "first_release": "2012",
      "types": "static",
      "paradigms": "functional, parallel",
      "website": "http://halide-lang.org/"
    },
    {
      "name": "hamilton c shell",
      "source": "https://en.wikipedia.org/wiki/Hamilton_C_shell",
      "about": "Hamilton C shell is a clone of the Unix C shell and utilities[1][2] for Microsoft Windows created by Nicole Hamilton[3] at Hamilton Laboratories as a completely original work, not based on any prior code. It was first released on OS/2 on December 12, 1988[4][5][6][7][8][9] and on Windows NT in July 1992.[10][11][12] The OS/2 version was discontinued in 2003 but the Windows version continues to be actively supported.",
      "first_release": "1988",
      "types": "",
      "paradigms": "",
      "website": "https://hamiltonlabs.com/Cshell.htm"
    },
    {
      "name": "harbour",
      "source": "https://en.wikipedia.org/wiki/Harbour_(software)",
      "about": "Harbour is a computer programming language, primarily used to create database/business programs. It is a modernized, open sourced and cross-platform version of the older Clipper system, which in turn developed from the dBase database market of the 1980s and 1990s.",
      "first_release": "1999",
      "types": "duck, dynamic, safe, strong",
      "paradigms": "multi-paradigm, imperative, functional, object-oriented, reflective",
      "website": "https://harbour.github.io/"
    },
    {
      "name": "hartmann pipelines",
      "source": "https://en.wikipedia.org/wiki/Hartmann_pipeline",
      "about": "CMS Pipelines implements the pipeline concept under the VM/CMS operating system. The programs in a pipeline operate on a sequential stream of records. A program writes records that are read by the next program in the pipeline. Any program can be combined with any other because reading and writing is done through a device independent interface.",
      "first_release": "1986",
      "types": "",
      "paradigms": "Dataflow programming",
      "website": "http://vm.marist.edu/~pipeline"
    },
    {
      "name": "haskell",
      "source": "https://en.wikipedia.org/wiki/Haskell_(programming_language)",
      "about": "Haskell /ˈhæskəl/[27] is a general-purpose, statically typed, purely functional programming language with type inference and lazy evaluation.[28][29] Developed to be suitable for teaching, research and industrial application, Haskell has pioneered a number of advanced programming language features such as type classes, which enable type-safe operator overloading. Haskell's main implementation is the Glasgow Haskell Compiler (GHC). It is named after logician Haskell Curry.[1]",
      "first_release": "1990",
      "types": "Inferred, static, strong",
      "paradigms": "Purely functional",
      "website": "https://www.haskell.org/"
    },
    {
      "name": "haxe",
      "source": "https://en.wikipedia.org/wiki/Haxe",
      "about": "Haxe is an open source[2] high-level cross-platform programming language and compiler that can produce applications and source code, for many different computing platforms from one code-base. It is free and open-source software, released under the MIT License. The compiler, written in OCaml, is released under the GNU General Public License (GPL) version 2.",
      "first_release": "2005",
      "types": "Static, dynamic, nominal",
      "paradigms": "Multi-paradigm",
      "website": "http://haxe.org/"
    },
    {
      "name": "hermes",
      "source": "https://en.wikipedia.org/wiki/Hermes_(programming_language)",
      "about": "Hermes[1] [2] is a language for distributed programming[3] that was developed at IBM's Thomas J. Watson Research Center from 1986 through 1992, with an open-source compiler and run-time system.[4] Hermes' primary features included:[5]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "high level assembly",
      "source": "https://en.wikipedia.org/wiki/High_Level_Assembly",
      "about": "High Level Assembly (HLA) is a high-level assembly language developed by Randall Hyde. It allows the use of higher-level language constructs to aid both beginners and advanced assembly developers. It fully supports advanced data types and object-oriented programming. It uses a syntax loosely based on several high-level programming languages (HLLs), such as Pascal, Ada, Modula-2, and C++, to allow creating readable assembly language programs, and to allow HLL programmers to learn HLA as fast as possible.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://plantation-productions.com/Webster"
    },
    {
      "name": "hlsl",
      "source": "https://en.wikipedia.org/wiki/High_Level_Shader_Language",
      "about": "The High-Level Shader Language[1] or High-Level Shading Language[2] (HLSL) is a proprietary shading language developed by Microsoft for the Direct3D 9 API to augment the shader assembly language, and went on to become the required shading language for the unified shader model of Direct3D 10 and higher.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "hollywood",
      "source": "https://en.wikipedia.org/wiki/Hollywood_(programming_language)",
      "about": "Hollywood is a commercially distributed programming language developed by Andreas Falkenhahn (Airsoft Softwair) which mainly focuses on the creation of multimedia-oriented applications. Hollywood is available for AmigaOS, MorphOS, WarpOS, AROS, Windows, macOS, Linux, Android, and iOS. Hollywood has an inbuilt cross compiler that can automatically save executables for all platforms supported by the software. The generated executables are completely stand-alone and do not have any external dependencies, so they can also be started from a USB flash drive. An optional add-on also allows users to compile projects into APK files.[1]",
      "first_release": "2002",
      "types": "",
      "paradigms": "",
      "website": "http://www.hollywood-mal.com/"
    },
    {
      "name": "holyc",
      "source": "https://en.wikipedia.org/wiki/TempleOS",
      "about": "TempleOS (formerly J Operating System, LoseThos, and SparrowOS) is a biblical-themed lightweight operating system designed to be the Third Temple prophesied in the Bible. It was created by American programmer Terry A. Davis, who developed it alone over the course of a decade after a series of manic episodes that he later described as a revelation from God.",
      "first_release": "2005",
      "types": "",
      "paradigms": "",
      "website": "http://templeos.org/"
    },
    {
      "name": "hop",
      "source": "https://en.wikipedia.org/wiki/Hop_(software)",
      "about": "Hop is a Lisp-like programming language by Manuel Serrano for web 2.0 and also the name of the web broker (server and proxy) that implements this language. It is written in Bigloo Scheme. It is a project funded by INRIA.",
      "first_release": "2006",
      "types": "",
      "paradigms": "multi-paradigm",
      "website": "http://hop.inria.fr/"
    },
    {
      "name": "hopscotch",
      "source": "https://en.wikipedia.org/wiki/Hopscotch_(programming_language)",
      "about": "Hopscotch is a visual programming language developed by Hopscotch Technologies, designed to allow young or beginner programmers to develop simple projects. Its simple UI allows its users to drag and drop blocks to create scripts that can be played when activated. Although the language is easy to use for simple programming, it lacks the power to be used for more complex programs. The use of the language is through an iPad or iPhone supporting Hopscotch.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "hope",
      "source": "https://en.wikipedia.org/wiki/Hope_(programming_language)",
      "about": "Hope is a small functional programming language developed in the 1970s at the University of Edinburgh.[1][2] It predates Miranda and Haskell and is contemporaneous with ML, also developed at the University. Hope was derived from NPL,[3] a simple functional language developed by Rod Burstall and John Darlington in their work on program transformation.[4] NPL and Hope are notable for being the first languages with call-by-pattern evaluation and algebraic data types.[5]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "hugo",
      "source": "https://en.wikipedia.org/wiki/Hugo_(programming_language)",
      "about": "Interactive fiction, often abbreviated IF, is software simulating environments in which players use text commands to control characters and influence the environment. Works in this form can be understood as literary narratives, either in the form of interactive narratives or interactive narrations. These works can also be understood as a form of video game,[1] either in the form of an adventure game or role-playing game. In common usage, the term refers to text adventures, a type of adventure game where the entire interface can be \"text-only\",[2] however, graphical text adventures still fall under the text adventure category if the main way to interact with the game is by typing text. Some users of the term distinguish between interactive fiction, known as \"Puzzle-free\", that focuses on narrative, and \"text adventures\" that focus on puzzles.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "hume",
      "source": "https://en.wikipedia.org/wiki/Hume_(language)",
      "about": "Hume is a functionally based programming language developed at the University of St Andrews and Heriot-Watt University in Scotland since the year 2000. The language name is both an acronym meaning 'Higher-order Unified Meta-Environment' and an honorific to the 18th Century philosopher David Hume. It targets real-time embedded systems, aiming to produce a design that is both highly abstract, yet which will still allow precise extraction of time and space execution costs. This allows programmers to guarantee the bounded time and space demands of executing programs.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "hypertalk",
      "source": "https://en.wikipedia.org/wiki/HyperTalk",
      "about": "HyperTalk is a discontinued high-level, procedural programming language created in 1987 by Dan Winkler and used in conjunction with Apple Computer's HyperCard hypermedia program by Bill Atkinson. Because the main target audience of HyperTalk was beginning programmers, HyperTalk programmers were usually called \"authors\" and the process of writing programs was known as \"scripting\". HyperTalk scripts resembled written English and used a logical structure similar to that of the Pascal programming language.",
      "first_release": "1987",
      "types": "",
      "paradigms": "procedural, event-driven",
      "website": ""
    },
    {
      "name": "io",
      "source": "https://en.wikipedia.org/wiki/Io_(programming_language)",
      "about": "Io is a pure object-oriented programming language inspired by Smalltalk, Self, Lua, Lisp, Act1, and NewtonScript.[2] Io has a prototype-based object model similar to the ones in Self and NewtonScript, eliminating the distinction between instance and class. Like Smalltalk, everything is an object and it uses dynamic typing. Like Lisp, programs are just data trees. Io uses actors for concurrency.",
      "first_release": "2002",
      "types": "dynamic, strong",
      "paradigms": "object-oriented, prototype-based",
      "website": "https://iolanguage.org/"
    },
    {
      "name": "icon",
      "source": "https://en.wikipedia.org/wiki/Icon_(programming_language)",
      "about": "Icon is a very high-level programming language featuring goal-directed execution and many facilities for managing strings and textual patterns. It is related to SNOBOL and SL5, string processing languages. Icon is not object-oriented, but an object-oriented extension called Idol was developed in 1996 which eventually became Unicon.",
      "first_release": "1977",
      "types": "dynamic",
      "paradigms": "multi-paradigm, structured",
      "website": "http://www.cs.arizona.edu/icon"
    },
    {
      "name": "ibm basic assembly language",
      "source": "https://en.wikipedia.org/wiki/IBM_Basic_assembly_language",
      "about": "Basic Assembly Language (BAL) is the commonly used term for a low-level programming language used on IBM System/360 and successor mainframes. Originally, \"Basic Assembly Language\" applied only to an extremely restricted dialect designed to run under control of IBM Basic Programming Support (BPS/360) on systems with only 8 KB of main memory, and only a card reader, a card punch, and a printer for input/output — thus the word \"Basic\". However, the full name and the initialism \"BAL\" almost immediately attached themselves in popular use to all assembly-language dialects on the System/360 and its descendants. BAL for BPS/360 was introduced with the System/360 in 1964.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "ibm hascript",
      "source": "https://en.wikipedia.org/wiki/IBM_HAScript",
      "about": "HAScript, or Host Access Script, is an IBM-developed macro language with an XML syntax designed for programmatic interaction with terminal-based applications. HAScript is based on a state machine principle. The first commercial implementation appeared in IBM's Host On-Demand in the late 1990s.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "ibm informix-4gl",
      "source": "https://en.wikipedia.org/wiki/IBM_Informix-4GL",
      "about": "Informix-4GL is a 4GL programming language developed by Informix during the mid-1980s.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "ibm rpg",
      "source": "https://en.wikipedia.org/wiki/IBM_RPG",
      "about": "RPG is a modern proprietary high-level programming language (HLL) for business applications, popular on the IBM i operating system on IBM Power Systems hardware. The current version, RPG IV, a.k.a. ILE RPG, provides a modern programming environment. IBM has evolved the language, providing new capabilities, to take advantage of technologies that have grown up in the marketplace.",
      "first_release": "1959",
      "types": "Strong, static",
      "paradigms": "Multi-paradigm",
      "website": ""
    },
    {
      "name": "idl",
      "source": "https://en.wikipedia.org/wiki/IDL_(programming_language)",
      "about": "IDL, short for Interactive Data Language, is a programming language used for data analysis. It is popular in particular areas of science, such as astronomy, atmospheric physics and medical imaging.[citation needed] IDL shares a common syntax with PV-Wave and originated from the same codebase, though the languages have subsequently diverged in detail. There are also free or costless implementations, such as GNU Data Language (GDL) and Fawlty Language (FL).",
      "first_release": "1977",
      "types": "Dynamic",
      "paradigms": "vector-oriented programming",
      "website": "https://www.harrisgeospatial.com/Software-Technology/IDL"
    },
    {
      "name": "idris",
      "source": "https://en.wikipedia.org/wiki/Idris_(programming_language)",
      "about": "Idris is a purely-functional programming language with dependent types, optional lazy evaluation, and features such as a totality checker. Idris may be used as a proof assistant, but it is designed to be a general-purpose programming language similar to Haskell.",
      "first_release": "2007",
      "types": "",
      "paradigms": "Functional",
      "website": "http://idris-lang.org/"
    },
    {
      "name": "inform",
      "source": "https://en.wikipedia.org/wiki/Inform_(programming_language)",
      "about": "Inform is a programming language and design system for interactive fiction originally created in 1993 by Graham Nelson. Inform can generate programs designed for the Z-code or Glulx virtual machines. Versions 1 through 5 were released between 1993 and 1996. Around 1996, Nelson rewrote Inform from first principles to create version 6 (or Inform 6).[2] Over the following decade, version 6 became reasonably stable and a popular language for writing interactive fiction. In 2006, Nelson released Inform 7 (briefly known as Natural Inform), a completely new language based on principles of natural language and a new set of tools based around a book-publishing metaphor.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://inform7.com/"
    },
    {
      "name": "j",
      "source": "https://en.wikipedia.org/wiki/J_(programming_language)",
      "about": "The J programming language, developed in the early 1990s by Kenneth E. Iverson and Roger Hui,[5][6] is an array programming language based primarily on APL (also by Iverson).",
      "first_release": "1990",
      "types": "dynamic",
      "paradigms": "",
      "website": "http://www.jsoftware.com/"
    },
    {
      "name": "j#",
      "source": "https://en.wikipedia.org/wiki/J_Sharp",
      "about": "Visual J# (pronounced \"jay-sharp\") was an implementation of the J# programming language that was a transitional language for programmers of Java and Visual J++ languages, so they could use their existing knowledge and applications with the .NET Framework.[1][2] It was introduced in 2002 and discontinued in 2007, with support for the final release of the product continuing until October 2017.",
      "first_release": "2002",
      "types": "",
      "paradigms": "",
      "website": "http://msdn2.microsoft.com/en-us/vjsharp/default.aspx"
    },
    {
      "name": "j++",
      "source": "https://en.wikipedia.org/wiki/Visual_J%2B%2B",
      "about": "Visual J++ (pronounced \"Jay Plus Plus\") is Microsoft's discontinued implementation of Java. Syntax, keywords, and grammatical conventions were the same as Java's. It was introduced in 1996[1] and discontinued in January 2004,[2] replacing it to a certain extent with J# and C#.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "jade",
      "source": "https://en.wikipedia.org/wiki/JADE_(programming_language)",
      "about": "JADE is a proprietary object-oriented software development and deployment platform product from the New Zealand-based Jade Software Corporation, first released in 1996.[1][2] It consists of the JADE programming language, Integrated development environment and debugger, integrated application server and object database management system.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "jai",
      "source": "https://en.wikipedia.org/wiki/Jai_(programming_language)",
      "about": "Jonathan David Blow (born November 3, 1971)[1] is an American video game designer, programmer and Twitch streamer, who is best known as the creator of the independent video games Braid (2008) and The Witness (2016), both of which were released to critical acclaim.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://number-none.com/blow"
    },
    {
      "name": "jal",
      "source": "https://en.wikipedia.org/wiki/JAL_(compiler)",
      "about": "JAL (Just Another Language) is a Pascal-like programming language and compiler that generates executable code for PIC microcontrollers. It is a free-format language with a compiler that runs on Linux, MS-Windows and MS-DOS (OSX support). It is configurable and extendable through the use of libraries and can even be combined with PIC assembly language.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "janus",
      "source": "https://en.wikipedia.org/wiki/Janus_(concurrent_constraint_programming_language)",
      "about": "Janus is a computer programming language partially described by K. Kahn and Vijay A. Saraswat in the paper \"Actors as a special case of concurrent constraint (logic) programming\" in 1990.[1] It is a concurrent constraint language without backtracking.",
      "first_release": "1990",
      "types": "",
      "paradigms": "concurrent constraint logic",
      "website": ""
    },
    {
      "name": "janus",
      "source": "https://en.wikipedia.org/wiki/Janus_(time-reversible_computing_programming_language)",
      "about": "Janus is a time-reversible programming language written at Caltech in 1982.[1] The operational semantics of the language were formally specified, together with a program inverter and an invertible self-interpreter, in 2007 by Tetsuo Yokoyama and Robert Glück.[2] A Janus inverter and interpreter is made freely available by the TOPPS research group at DIKU.[3] Another Janus interpreter was implemented in Prolog in 2009.[4] The below summarises the language presented in the 2007 paper.",
      "first_release": "2007",
      "types": "",
      "paradigms": "imperative, procedural, reversible",
      "website": "http://tetsuo.jp/ref/janus.html"
    },
    {
      "name": "jass",
      "source": "https://en.wikipedia.org/wiki/JASS_(scripting_language)",
      "about": "The Warcraft III World Editor is the built-in level editor for the real-time strategy game Warcraft III: Reign of Chaos and its expansion set Warcraft III: The Frozen Throne. Incorporating the core mechanics of the level editor of Blizzard Entertainment's previous strategy game StarCraft, it allows users to create and customize their own maps with a high level of detail and flexibility.[1][2] The editor has been used in creating several popular custom maps, including Defense of the Ancients.[3][4] The level editor was substantially improved for The Frozen Throne and allowed users to create cut scenes supporting voice-overs.[5] Advanced features of the editor allow for custom models, tilesets and icons. The editor also supports Blizzard's JASS scripting language for programming complex actions otherwise not supported by the graphical interface.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "java",
      "source": "https://en.wikipedia.org/wiki/Java_(programming_language)",
      "about": "Java is a class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible. It is a general-purpose programming language intended to let application developers write once, run anywhere (WORA),[17] meaning that compiled Java code can run on all platforms that support Java without the need for recompilation.[18] Java applications are typically compiled to bytecode that can run on any Java virtual machine (JVM) regardless of the underlying computer architecture. The syntax of Java is similar to C and C++, but has fewer low-level facilities than either of them. The Java runtime provides dynamic capabilities (such as reflection and runtime code modification) that are typically not available in traditional compiled languages. As of 2019, Java was one of the most popular programming languages in use according to GitHub,[19][20] particularly for client-server web applications, with a reported 9 million developers.[21]",
      "first_release": "1995",
      "types": "Static, strong, safe, nominative, manifest",
      "paradigms": "Multi-paradigm, generic, object-oriented, class-based, imperative, reflective",
      "website": "http://oracle.com/java/"
    },
    {
      "name": "javafx script",
      "source": "https://en.wikipedia.org/wiki/JavaFX_Script",
      "about": "JavaFX Script was a scripting language designed by Sun Microsystems, forming part of the JavaFX family of technologies on the Java Platform.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://javafx.com/"
    },
    {
      "name": "javascript",
      "source": "https://en.wikipedia.org/wiki/JavaScript",
      "about": "JavaScript (/ˈdʒɑːvəˌskrɪpt/),[8] often abbreviated as JS, is a programming language that conforms to the ECMAScript specification.[9] JavaScript is high-level, often just-in-time compiled, and multi-paradigm. It has curly-bracket syntax, dynamic typing, prototype-based object-orientation, and first-class functions.",
      "first_release": "1995",
      "types": "Dynamic, duck",
      "paradigms": "event-driven, functional, imperative",
      "website": ""
    },
    {
      "name": "jess",
      "source": "https://en.wikipedia.org/wiki/Jess_(programming_language)",
      "about": "Jess is a rule engine for the Java platform that was developed by Ernest Friedman-Hill of Sandia National Labs.[1] It is a superset of the CLIPS programming language.[1] It was first written in late 1995.[1] The language provides rule-based programming for the automation of an expert system, and is frequently termed as an expert system shell.[1] In recent years, intelligent agent systems have also developed, which depend on a similar capability.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.jessrules.com/"
    },
    {
      "name": "jcl",
      "source": "https://en.wikipedia.org/wiki/Job_Control_Language",
      "about": "Job Control Language (JCL) is a name for scripting languages used on IBM mainframe operating systems to instruct the system on how to run a batch job or start a subsystem.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "jean",
      "source": "https://en.wikipedia.org/wiki/JEAN",
      "about": "JEAN was a dialect of the JOSS programming language developed for and used on ICT 1900 series computers in the late 1960s and early 1970s; it was implemented under the MINIMOP operating system. It was used at the University of Southampton.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "join java",
      "source": "https://en.wikipedia.org/wiki/Join_Java",
      "about": "Join Java is a programming language based on the join-pattern that extends the standard Java programming language with the join semantics of the join-calculus. It was written at the University of South Australia within the Reconfigurable Computing Lab by Dr. Von Itzstein.",
      "first_release": "2000",
      "types": "",
      "paradigms": "Procedural, Reflective",
      "website": "http://joinjava.unisa.edu.au/"
    },
    {
      "name": "joss",
      "source": "https://en.wikipedia.org/wiki/JOSS",
      "about": "JOSS, an acronym for JOHNNIAC Open Shop System,[a] was one of the first interactive, time-sharing programming languages. It pioneered a number of features that would become common in languages from the 1960s into the 1980s, including line numbers as both editing instructions and targets for branches, statements predicated by boolean decisions, and a built-in editor that can perform instructions in \"direct\" or \"immediate\" mode, a conversational user interface.",
      "first_release": "1963",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "joule",
      "source": "https://en.wikipedia.org/wiki/Joule_(programming_language)",
      "about": "Joule is a concurrent dataflow programming language, designed for building distributed applications. It is so concurrent that the order of statements within a block is irrelevant to the operation of the block. Statements are executed whenever possible, based on their inputs. Everything in Joule happens by sending messages. There is no control flow. Instead, the programmer describes the flow of data, making it a dataflow programming language.",
      "first_release": "1996",
      "types": "",
      "paradigms": "multi-paradigm, object-oriented, distributed, Dataflow",
      "website": ""
    },
    {
      "name": "jovial",
      "source": "https://en.wikipedia.org/wiki/JOVIAL",
      "about": "JOVIAL is a high-level programming language similar to ALGOL, specialized for developing embedded systems (specialized computer systems designed to perform one or a few dedicated functions, usually embedded as part of a larger, more complete device, including mechanical parts). It was a major system programming language through the 1960s and 70s.[citation needed]",
      "first_release": "1960",
      "types": "static, strong, safe, structural",
      "paradigms": "Procedural, imperative, structured",
      "website": ""
    },
    {
      "name": "joy",
      "source": "https://en.wikipedia.org/wiki/Joy_(programming_language)",
      "about": "The Joy programming language in computer science is a purely functional programming language that was produced by Manfred von Thun of La Trobe University in Melbourne, Australia. Joy is based on composition of functions rather than lambda calculus. It has turned out to have many similarities to Forth, due not to design but to a sort of parallel evolution and convergence. It was also inspired by the function-level programming style of John Backus's FP.[1]",
      "first_release": "2001",
      "types": "strong, dynamic",
      "paradigms": "multi-paradigm, functional, concatenative, stack-oriented",
      "website": ""
    },
    {
      "name": "jscript",
      "source": "https://en.wikipedia.org/wiki/JScript",
      "about": "JScript is Microsoft's dialect of the ECMAScript standard[2] that is used in Microsoft's Internet Explorer.",
      "first_release": "1996",
      "types": "Dynamic, weak, duck",
      "paradigms": "",
      "website": "http://msdn.microsoft.com/library/hbxc2t98.aspx"
    },
    {
      "name": "jscript .net",
      "source": "https://en.wikipedia.org/wiki/JScript_.NET",
      "about": "JScript .NET is a .NET programming language developed by Microsoft.",
      "first_release": "",
      "types": "duck, weak, dynamic",
      "paradigms": "multi-paradigm",
      "website": ""
    },
    {
      "name": "julia",
      "source": "https://en.wikipedia.org/wiki/Julia_(programming_language)",
      "about": "Julia is a high-level, high-performance, dynamic programming language. While it is a general-purpose language and can be used to write any application, many of its features are well suited for numerical analysis and computational science.[19][20][21][22]",
      "first_release": "2012",
      "types": "Dynamic, [9], strong, [10], nominative, parametric, optional",
      "paradigms": "Multi-paradigm, multiple dispatch, procedural, functional, meta, multistaged, [1]",
      "website": "https://julialang.org/"
    },
    {
      "name": "jython",
      "source": "https://en.wikipedia.org/wiki/Jython",
      "about": "Jython is an implementation of the Python programming language designed to run on the Java platform. The implementation was formerly known as JPython until 1999.[3]",
      "first_release": "2001",
      "types": "",
      "paradigms": "",
      "website": "https://www.jython.org/"
    },
    {
      "name": "k",
      "source": "https://en.wikipedia.org/wiki/K_(programming_language)",
      "about": "K is a proprietary array processing programming language developed by Arthur Whitney and commercialized by Kx Systems. The language serves as the foundation for kdb+, an in-memory, column-based database, and other related financial products.[1] The language, originally developed in 1993, is a variant of APL and contains elements of Scheme. Advocates of the language emphasize its speed, facility in handling arrays, and expressive syntax.[2]",
      "first_release": "1993",
      "types": "dynamic, strong",
      "paradigms": "array, functional",
      "website": "http://kx.com/"
    },
    {
      "name": "kaleidoscope",
      "source": "https://en.wikipedia.org/wiki/Kaleidoscope_(programming_language)",
      "about": "The Kaleidoscope programming language is a constraint programming language embedding constraints into an imperative object-oriented language. It adds keywords always, once, and assert..during (formerly while..assert) to make statements about relational invariants. Objects have constraint constructors, which are not methods, to enforce the meanings of user-defined datatypes.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "karel",
      "source": "https://en.wikipedia.org/wiki/Karel_(programming_language)",
      "about": "Karel is an educational programming language for beginners, created by Richard E. Pattis in his book Karel The Robot: A Gentle Introduction to the Art of Programming. Pattis used the language in his courses at Stanford University, California. The language is named after Karel Čapek, a Czech writer who introduced the word robot in his play R.U.R.[1][2]",
      "first_release": "1981",
      "types": "",
      "paradigms": "procedural",
      "website": ""
    },
    {
      "name": "kee",
      "source": "https://en.wikipedia.org/wiki/IntelliCorp_(Software)",
      "about": "IntelliCorp (IC) sold its assets including LiveCompare, LiveModel and LiveInterface to Tricentis in May 2019.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "kixtart",
      "source": "https://en.wikipedia.org/wiki/KiXtart",
      "about": "KiXtart is a closed source free-format scripting language for Windows. It is described as a logon script processor and enhanced batch scripting language by the official website.[2] Its name is a portmanteau of \"kick start\".",
      "first_release": "1991",
      "types": "",
      "paradigms": "",
      "website": "http://www.kixtart.org/"
    },
    {
      "name": "klerer-may system",
      "source": "https://en.wikipedia.org/wiki/Klerer-May_System",
      "about": "The Klerer–May System is a programming language developed in the mid-1960s, oriented to numerical scientific programming, whose most notable feature is its two-dimensional syntax based on traditional mathematical notation.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "kif",
      "source": "https://en.wikipedia.org/wiki/Knowledge_Interchange_Format",
      "about": "Knowledge Interchange Format (KIF) is a computer language designed to enable systems to share and re-use information from knowledge-based systems. KIF is similar to frame languages such as KL-One and LOOM but unlike such language its primary role is not intended as a framework for the expression or use of knowledge but rather for the interchange of knowledge between systems. The designers of KIF likened it to PostScript. PostScript was not designed primarily as a language to store and manipulate documents but rather as an interchange format for systems and devices to share documents. In the same way KIF is meant to facilitate sharing of knowledge across different systems that use different languages, formalisms, platforms, etc.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "kojo",
      "source": "https://en.wikipedia.org/wiki/Kojo_(programming_language)",
      "about": "Kojo is a programming language and integrated development environment (IDE) for computer programming and learning. It has many different features that enable playing, exploring, creating, and learning in the areas of computer programming, mental skills, (interactive) math, graphics, art, music, science, animation, games, and electronics. Kojo draws ideas from the programming languages Logo and Processing.[1][2]",
      "first_release": "2010",
      "types": "strong",
      "paradigms": "object-oriented, functional",
      "website": "http://www.kogics.net/kojo"
    },
    {
      "name": "kotlin",
      "source": "https://en.wikipedia.org/wiki/Kotlin_(programming_language)",
      "about": "Kotlin (/ˈkɒtlɪn/)[2] is a cross-platform, statically typed, general-purpose programming language with type inference. Kotlin is designed to interoperate fully with Java, and the JVM version of Kotlin's standard library depends on the Java Class Library,[3] but type inference allows its syntax to be more concise. Kotlin mainly targets the JVM, but also compiles to JavaScript (e.g., for frontend web applications using React[4]) or native code (via LLVM); e.g., for native iOS apps sharing business logic with Android apps.[5] Language development costs are borne by JetBrains, while the Kotlin Foundation protects the Kotlin trademark.[6]",
      "first_release": "2011",
      "types": "Inferred, static, strong",
      "paradigms": "Multi-paradigm, object-oriented, functional, imperative, block structured, declarative, generic, reflective, concurrent",
      "website": "https://kotlinlang.org/"
    },
    {
      "name": "krc",
      "source": "https://en.wikipedia.org/wiki/Kent_Recursive_Calculator",
      "about": "KRC (Kent Recursive Calculator) is a lazy functional language developed by David Turner from November 1979 to October 1981[1] based on SASL, with pattern matching, guards and ZF expressions[2] (now more usually called list comprehensions). Two implementations of KRC were written: David Turner's original one in BCPL running on EMAS, and Simon J. Croft's later one in C under Unix, and KRC was the main language used for teaching functional programming at the University of Kent at Canterbury (UK) from 1982 to 1985.",
      "first_release": "1981",
      "types": "",
      "paradigms": "functional",
      "website": ""
    },
    {
      "name": "krl",
      "source": "https://en.wikipedia.org/wiki/KRL_(programming_language)",
      "about": "KRL is a knowledge representation language, developed by Daniel G. Bobrow and Terry Winograd while at Xerox PARC and Stanford University, respectively. It is a frame-based language.",
      "first_release": "1976",
      "types": "",
      "paradigms": "knowledge representation",
      "website": ""
    },
    {
      "name": "kuka robot language",
      "source": "https://en.wikipedia.org/wiki/KUKA_Robot_Language",
      "about": "The KUKA Robot Language, also known as KRL, is a proprietary programming language similar to Pascal and used to control KUKA robots.[1][2]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "krypton",
      "source": "https://en.wikipedia.org/wiki/KRYPTON",
      "about": "Krypton (styled KRYPTON) is a frame-based computer programming language.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "kornshell",
      "source": "https://en.wikipedia.org/wiki/KornShell",
      "about": "KornShell (ksh) is a Unix shell which was developed by David Korn at Bell Labs in the early 1980s and announced at USENIX on July 14, 1983.[1][2] The initial development was based on Bourne shell source code.[9] Other early contributors were Bell Labs developers Mike Veach and Pat Sullivan, who wrote the Emacs and vi-style line editing modes' code, respectively.[10] KornShell is backward-compatible with the Bourne shell and includes many features of the C shell, inspired by the requests of Bell Labs users.",
      "first_release": "1983",
      "types": "",
      "paradigms": "",
      "website": "http://www.kornshell.org/"
    },
    {
      "name": "kodu",
      "source": "https://en.wikipedia.org/wiki/Kodu_Game_Lab",
      "about": "Kodu, originally named Boku, is a programming integrated development environment (IDE) by Microsoft's FUSE Labs. It runs on Xbox 360 and Microsoft Windows XP, Windows Vista, Windows 7, Windows 8 and Windows 10. It was released on the Xbox Live Marketplace on June 30, 2009.[2] A Windows version is available to the general public for download from Microsoft's FUSE web portal.[3]",
      "first_release": "2009",
      "types": "",
      "paradigms": "",
      "website": "http://kodugamelab.com/"
    },
    {
      "name": "kv",
      "source": "https://en.wikipedia.org/wiki/Kivy_(framework)",
      "about": "Kivy is a free and open source Python framework for developing mobile apps and other multitouch application software with a natural user interface (NUI). It is distributed under the terms of the MIT License, and can run on Android, iOS, GNU/Linux, macOS, and Windows.",
      "first_release": "2011",
      "types": "",
      "paradigms": "",
      "website": "https://kivy.org/"
    },
    {
      "name": "labview",
      "source": "https://en.wikipedia.org/wiki/LabVIEW",
      "about": "Laboratory Virtual Instrument Engineering Workbench (LabVIEW)[1]:3 is a system-design platform and development environment for a visual programming language from National Instruments.",
      "first_release": "1986",
      "types": "",
      "paradigms": "",
      "website": "https://www.ni.com/labview"
    },
    {
      "name": "ladder",
      "source": "https://en.wikipedia.org/wiki/Ladder_logic",
      "about": "Ladder logic was originally a written method to document the design and construction of relay racks as used in manufacturing and process control.[1] Each device in the relay rack would be represented by a symbol on the ladder diagram with connections between those devices shown. In addition, other items external to the relay rack such as pumps, heaters, and so forth would also be shown on the ladder diagram.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "lansa",
      "source": "https://en.wikipedia.org/wiki/LANSA_(development_environment)",
      "about": "LANSA is an integrated development environment (IDE) for building desktop, web and mobile software applications that can be deployed to Cloud, Windows, Linux and IBM i server platforms.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "lasso",
      "source": "https://en.wikipedia.org/wiki/Lasso_(programming_language)",
      "about": "Lasso is an application server and server management interface used to develop internet applications and is a general-purpose, high-level programming language. Originally a web datasource connection tool,[1] for Filemaker and later included in Apple Computer's FileMaker 4.0 and Claris Homepage as CDML,[2][3] it has since evolved into a complex language used to develop and serve large-scale internet applications and web pages.",
      "first_release": "1995",
      "types": "Dynamic, nominative, duck",
      "paradigms": "Multi-paradigm, structured, object-oriented, multi-dis, imperative, procedural, concurrent, exp-oriented, Meta, reflective",
      "website": "http://www.lassosoft.com/"
    },
    {
      "name": "lava",
      "source": "https://en.wikipedia.org/wiki/Lava_(programming_language)",
      "about": "Lava is an experimental, visual object-oriented, interpreter-based programming language with an associated programming environment (Lava Programming Environment or LavaPE) that uses structure editors instead of text editors. Only comments, constants, and new identifiers may be entered as text.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "lc-3",
      "source": "https://en.wikipedia.org/wiki/Little_Computer_3",
      "about": "Little Computer 3, or LC-3, is a type of computer educational programming language, an assembly language, which is a type of low-level programming language.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "lean",
      "source": "https://en.wikipedia.org/wiki/Lean_(proof_assistant)",
      "about": "Lean is a theorem prover and programming language. It is based on the calculus of constructions with inductive types.",
      "first_release": "2013",
      "types": "",
      "paradigms": "",
      "website": "https://leanprover.github.io/"
    },
    {
      "name": "legoscript",
      "source": "https://en.wikipedia.org/wiki/Legoscript",
      "about": "Lego Mindstorms is a hardware and software structure which is produced by Lego for the development of programmable robots based on Lego building blocks. Each version of the system includes a computer Lego brick that controls the system, a set of modular sensors and motors, and Lego parts from the Technic line to create the mechanical systems.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "https://www.lego.com/mindstorms"
    },
    {
      "name": "lil",
      "source": "https://en.wikipedia.org/wiki/Little_Implementation_Language",
      "about": "LIL, the Little Implementation Language, was a system programming language during the early days of Unix history on PDP-11 machines. It was written by P. J. Plauger of Bell Labs.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "lilypond",
      "source": "https://en.wikipedia.org/wiki/LilyPond",
      "about": "LilyPond is a computer program and file format for music engraving. One of LilyPond's major goals is to produce scores that are engraved with traditional layout rules, reflecting the era when scores were engraved by hand.",
      "first_release": "1996",
      "types": "",
      "paradigms": "",
      "website": "http://lilypond.org/"
    },
    {
      "name": "limbo",
      "source": "https://en.wikipedia.org/wiki/Limbo_(programming_language)",
      "about": "Limbo is a programming language for writing distributed systems and is the language used to write applications for the Inferno operating system. It was designed at Bell Labs by Sean Dorward, Phil Winterbottom, and Rob Pike.[1]",
      "first_release": "1995",
      "types": "Strong",
      "paradigms": "Concurrent",
      "website": "http://www.vitanuova.com/inferno/limbo.html"
    },
    {
      "name": "limnor",
      "source": "https://en.wikipedia.org/wiki/Limnor",
      "about": "Limnor is a generic-purpose codeless and visual programming system. The aim is to enable users to create computer software without directly coding in a texture programming language. It can be extended by software developers. The general idea of Limnor codeless programming is to add \"Actions\" to classes.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "linc",
      "source": "https://en.wikipedia.org/wiki/LINC_4GL",
      "about": "LINC (\"Logic and Information Network Compiler\") is a fourth-generation programming language,[1] used mostly on Unisys computer systems.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "lingo",
      "source": "https://en.wikipedia.org/wiki/Lingo_(programming_language)",
      "about": "Lingo is a verbose object-oriented (OO) scripting language developed by John H. Thompson for use in Adobe Director (formerly Macromedia Director). Lingo is used to develop desktop application software, interactive kiosks, CD-ROMs and Adobe Shockwave content.[1][2]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "linq",
      "source": "https://en.wikipedia.org/wiki/LINQ",
      "about": "Language Integrated Query (LINQ, pronounced \"link\") is a Microsoft .NET Framework component that adds native data querying capabilities to .NET languages, originally released as a major part of .NET Framework 3.5 in 2007.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "https://docs.microsoft.com/en-us/dotnet/standard/using-linq"
    },
    {
      "name": "lis",
      "source": "https://en.wikipedia.org/wiki/LIS_(programming_language)",
      "about": "LIS (Language d'Implementation de Systèmes) was a system implementation programming language designed by Jean Ichbiah, who later designed Ada.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "lisa",
      "source": "https://en.wikipedia.org/wiki/Language_for_Instruction_Set_Architecture",
      "about": "LISA (Language for Instruction Set Architectures) is a language to describe the instruction set architecture of a processor. LISA captures the information required to generate software tools (compiler, assembler, instruction set simulator, ...) and implementation hardware (in VHDL or Verilog) of a given processor.",
      "first_release": "2007",
      "types": "",
      "paradigms": "",
      "website": "http://www.ice.rwth-aachen.de/research/tools-projects/lisa/lisa"
    },
    {
      "name": "language h",
      "source": "https://en.wikipedia.org/wiki/Language_H",
      "about": "Language H is a proprietary, procedural programming language created by NCR based on COBOL. The first compiler was developed in August 1962 to run on the National-Elliott 405M and produce object code for the National-Elliott 803B.[1] It is believed that the \"H\" stands for John C Harwell.[2]",
      "first_release": "1962",
      "types": "",
      "paradigms": "procedural",
      "website": ""
    },
    {
      "name": "lisp",
      "source": "https://en.wikipedia.org/wiki/Lisp_(programming_language)",
      "about": "Lisp (historically LISP) is a family of programming languages with a long history and a distinctive, fully parenthesized prefix notation.[3] Originally specified in 1958, Lisp is the second-oldest high-level programming language in widespread use today. Only Fortran is older, by one year.[4][5] Lisp has changed since its early days, and many dialects have existed over its history. Today, the best-known general-purpose Lisp dialects are Racket, Common Lisp, Scheme and Clojure.",
      "first_release": "1958",
      "types": "Dynamic, strong",
      "paradigms": "Multi-paradigm, functional, procedural, reflective, meta",
      "website": ""
    },
    {
      "name": "lite-c",
      "source": "https://en.wikipedia.org/wiki/Lite-C",
      "about": "Lite-C is a programming language for multimedia applications and personal computer games, using a syntax subset of the C language with some elements of the C++ language. Its main difference to C is the native implementation of multimedia and computer game related objects like sounds, images, movies, GUI elements, 2D and 3D models, collision detection and rigid body physics. Lite-C executables are compiled instead of interpreted. Lite-C runs on 32-bit and 64-bit Windows XP or Vista operating systems.",
      "first_release": "2007",
      "types": "",
      "paradigms": "",
      "website": "http://www.3dgamestudio.de/litec.php"
    },
    {
      "name": "lithe",
      "source": "https://en.wikipedia.org/wiki/Lithe_(programming_language)",
      "about": "Lithe is an experimental programming language created in 1982 by David Sandberg at the University of Washington which allows the programmer to freely choose their own syntax. Lithe combines the ideas of syntax-directed translation and classes in a novel manner that results in a remarkably simple yet powerful language.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "little b",
      "source": "https://en.wikipedia.org/wiki/Little_b_(programming_language)",
      "about": "Little b is a domain-specific programming language, more specifically, a modeling language, designed to build modular mathematical models of biological systems. It was designed and authored by Aneil Mallavarapu. Little b is being developed in the Virtual Cell Program at Harvard Medical School, headed by mathematician Jeremy Gunawardena.",
      "first_release": "2004",
      "types": "dynamic, strong",
      "paradigms": "functional",
      "website": "https://web.archive.org/web/20051102195348/http://www.littleb.org/"
    },
    {
      "name": "lll",
      "source": "https://en.wikipedia.org/wiki/Ethereum",
      "about": "Ethereum is a decentralized, open-source blockchain featuring smart contract functionality. Ether (ETH) is the native cryptocurrency of the platform. It is the second-largest cryptocurrency by market capitalization, after Bitcoin.[1] Ethereum is the most actively used blockchain.[2][3]",
      "first_release": "2015",
      "types": "",
      "paradigms": "",
      "website": "http://ethereum.org/"
    },
    {
      "name": "logo",
      "source": "https://en.wikipedia.org/wiki/Logo_(programming_language)",
      "about": "Logo is an educational programming language, designed in 1967 by Wally Feurzeig, Seymour Papert, and Cynthia Solomon.[1] Logo is not an acronym: the name was coined by Feurzeig while he was at Bolt, Beranek and Newman,[2] and derives from the Greek logos, meaning word or thought.",
      "first_release": "1967",
      "types": "dynamic",
      "paradigms": "Multi-paradigm, functional, educational, procedural, reflective",
      "website": ""
    },
    {
      "name": "logtalk",
      "source": "https://en.wikipedia.org/wiki/Logtalk",
      "about": "Logtalk is an object-oriented logic programming language that extends and leverages the Prolog language with a feature set suitable for programming in the large.[1] It provides support for encapsulation and data hiding, separation of concerns and enhanced code reuse.[1] Logtalk uses standard Prolog syntax with the addition of a few operators and directives.",
      "first_release": "1998",
      "types": "",
      "paradigms": "Logic programming, object-oriented programming, prototype-based programming",
      "website": "https://logtalk.org/"
    },
    {
      "name": "lotusscript",
      "source": "https://en.wikipedia.org/wiki/LotusScript",
      "about": "LotusScript is an object oriented programming language used by Lotus Notes (since version 4.0) and other IBM Lotus Software products.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "lpc",
      "source": "https://en.wikipedia.org/wiki/LPC_(programming_language)",
      "about": "LPMud, abbreviated LP, is a family of MUD server software. Its first instance, the original LPMud game driver, was developed in 1989 by Lars Pensjö (hence the LP in LPMud).[1][2][3] LPMud was innovative in its separation of the MUD infrastructure into a virtual machine (known as the driver) and a development framework written in the LPC programming language (known as the mudlib).[4]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "lse",
      "source": "https://en.wikipedia.org/wiki/LSE_(programming_language)",
      "about": "LSE (French: Langage symbolique d'enseignement) is a programming language developed at Supélec and Télémécanique from the late 1960s to the mid 1970s.[1][2][3][4]It is similar to BASIC, except with French-language instead of English-language keywords. It was derived from an earlier language called LSD, also developed at Supélec. It is most commonly said to be an acronym for Langage Symbolique d'Enseignement (Symbolic Teaching Language), but other expansions are also known (e.g. Langage de Sup-Élec, or the more cynical).",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "lsl",
      "source": "https://en.wikipedia.org/wiki/Linden_Scripting_Language",
      "about": "Second Life is an online virtual world, developed and owned by the San Francisco-based firm Linden Lab and launched on June 23, 2003. It saw rapid growth for some years and in 2013 it had approximately one million regular users;[1] growth stabilized and by the end of 2017 active user count had declined to \"between 800,000 and 900,000\".[2] In many ways, Second Life is similar to massively multiplayer online role-playing games; nevertheless, Linden Lab is emphatic that their creation is not a game: \"There is no manufactured conflict, no set objective\".[3]",
      "first_release": "2003",
      "types": "",
      "paradigms": "",
      "website": "http://www.secondlife.com/"
    },
    {
      "name": "livecode",
      "source": "https://en.wikipedia.org/wiki/LiveCode",
      "about": "LiveCode (formerly Revolution and MetaCard[3]) is a cross-platform[4] rapid application development runtime system inspired by HyperCard. It features the LiveCode Script (formerly MetaTalk) programming language which belongs to the family of xTalk scripting languages like HyperCard's HyperTalk.[5][6]",
      "first_release": "2001",
      "types": "",
      "paradigms": "",
      "website": "http://livecode.org/"
    },
    {
      "name": "livescript",
      "source": "https://en.wikipedia.org/wiki/LiveScript",
      "about": "LiveScript is a functional programming language that compiles to JavaScript. It was created by Jeremy Ashkenas—the creator of CoffeeScript—along with Satoshi Muramaki, George Zahariev, and many others.[2] Not to be confused with JavaScript (for a brief period in the 1990s, LiveScript was the name of JavaScript).[3]",
      "first_release": "2011",
      "types": "dynamic, weak",
      "paradigms": "multi-paradigm, functional, object-oriented",
      "website": "http://livescript.net/"
    },
    {
      "name": "lua",
      "source": "https://en.wikipedia.org/wiki/Lua_(programming_language)",
      "about": "Lua (/ˈluːə/ LOO-ə; from Portuguese: lua [ˈlu.(w)ɐ] meaning moon)[a] is a lightweight, high-level, multi-paradigm programming language designed primarily for embedded use in applications.[3] Lua is cross-platform, since the interpreter of compiled bytecode is written in ANSI C,[4] and Lua has a relatively simple C API to embed it into applications.[5]",
      "first_release": "1993",
      "types": "Dynamic, strong, duck",
      "paradigms": "Multi-paradigm, scripting, imperative, procedural, prototype-based, object-oriented, functional",
      "website": "https://www.lua.org/"
    },
    {
      "name": "lucid",
      "source": "https://en.wikipedia.org/wiki/Lucid_(programming_language)",
      "about": "Lucid is a dataflow programming language designed to experiment with non-von Neumann programming models. It was designed by Bill Wadge and Ed Ashcroft and described in the 1985 book Lucid, the Dataflow Programming Language.[1]",
      "first_release": "1976",
      "types": "",
      "paradigms": "Dataflow",
      "website": ""
    },
    {
      "name": "lustre",
      "source": "https://en.wikipedia.org/wiki/Lustre_(programming_language)",
      "about": "Lustre is a formally defined, declarative, and synchronous dataflow programming language for programming reactive systems. It began as a research project in the early 1980s. A formal presentation of the language can be found in the 1991 Proceedings of the IEEE.[1] In 1993 it progressed to practical, industrial use in a commercial product as the core language of the industrial environment SCADE, developed by Esterel Technologies. It is now used for critical control software in aircraft,[2] helicopters, and nuclear power plants.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "lyapas",
      "source": "https://en.wikipedia.org/wiki/LYaPAS",
      "about": "Logical Language for the Representation of Synthesis Algorithms (LYaPAS, Russian: ЛЯПАС) is a programming language created by Arkady Zakrevsky in the Soviet Union.",
      "first_release": "1964",
      "types": "Dynamic",
      "paradigms": "Array, functional, structured, modular",
      "website": ""
    },
    {
      "name": "lynx",
      "source": "https://en.wikipedia.org/wiki/Lynx_(programming_language)",
      "about": "Lynx is a programming language for large distributed networks, using remote procedure calls. It was developed by the University of Wisconsin–Madison in 1984 for the Charlotte multicomputer operating system.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "m2001",
      "source": "https://en.wikipedia.org/wiki/M2001",
      "about": "M2001 is a modular educational mathematical programming language for developing and presenting mathematical algorithms, from the modern discrete to the classical continuous mathematics. M2001 is built on a semantic framework that is based in category theory and has a syntax similar to that of Pascal or Modula-2.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "m4",
      "source": "https://en.wikipedia.org/wiki/M4_(computer_language)",
      "about": "m4 is a general-purpose macro processor included in most Unix-like operating systems, and is a component of the POSIX standard.",
      "first_release": "1977",
      "types": "",
      "paradigms": "macro",
      "website": ""
    },
    {
      "name": "m#",
      "source": "https://en.wikipedia.org/wiki/M_Sharp_(programming_language)",
      "about": "M# (pronounced em sharp) is a code generation tool and a domain-specific language that can be used to create websites and web applications.[1] It can translate entities and page definitions to ASP.NET Web Forms and MVC and C# code which in turn form the user interface and business logic layer of the application. Its main goals are to reduce time of development, increase code quality, and reduce human errors.[2]",
      "first_release": "2012",
      "types": "static, dynamic",
      "paradigms": "multi-paradigm, structured, object-oriented, event-driven, procedural, meta",
      "website": "http://www.msharp.co.uk/"
    },
    {
      "name": "machine code",
      "source": "https://en.wikipedia.org/wiki/Machine_code",
      "about": "In computer programming, machine code, consisting of machine language instructions, is a low-level programming language used to directly control a computer's central processing unit (CPU). Each instruction causes the CPU to perform a very specific task, such as a load, a store, a jump, or an arithmetic logic unit (ALU) operation on one or more units of data in the CPU's registers or memory.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "mad",
      "source": "https://en.wikipedia.org/wiki/MAD_(programming_language)",
      "about": "MAD (Michigan Algorithm Decoder) is a programming language and compiler for the IBM 704 and later the IBM 709, IBM 7090, IBM 7040, UNIVAC 1107, UNIVAC 1108, Philco 210-211, and eventually the IBM S/370 mainframe computers. Developed in 1959 at the University of Michigan by Bernard Galler, Bruce Arden and Robert M. Graham, MAD is a variant of the ALGOL language. It was widely used to teach programming at colleges and universities during the 1960s and played a minor role in the development of CTSS, Multics, and the Michigan Terminal System computer operating systems.[1]",
      "first_release": "1959",
      "types": "",
      "paradigms": "Imperative",
      "website": ""
    },
    {
      "name": "mad/i",
      "source": "https://en.wikipedia.org/wiki/MAD_(programming_language)",
      "about": "MAD (Michigan Algorithm Decoder) is a programming language and compiler for the IBM 704 and later the IBM 709, IBM 7090, IBM 7040, UNIVAC 1107, UNIVAC 1108, Philco 210-211, and eventually the IBM S/370 mainframe computers. Developed in 1959 at the University of Michigan by Bernard Galler, Bruce Arden and Robert M. Graham, MAD is a variant of the ALGOL language. It was widely used to teach programming at colleges and universities during the 1960s and played a minor role in the development of CTSS, Multics, and the Michigan Terminal System computer operating systems.[1]",
      "first_release": "1959",
      "types": "",
      "paradigms": "Imperative",
      "website": ""
    },
    {
      "name": "magik",
      "source": "https://en.wikipedia.org/wiki/Magik_(programming_language)",
      "about": "Magik is an object-oriented programming language that supports multiple inheritance and polymorphism, and it is dynamically typed. It was designed and implemented in 1989 by Arthur Chance of Smallworld Systems Ltd. as part of Smallworld Geographical Information System (GIS). Following Smallworld's acquisition in 2000, Magik is now provided by GE Energy, still as part of its Smallworld technology platform.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "magma",
      "source": "https://en.wikipedia.org/wiki/Magma_computer_algebra_system",
      "about": "Magma is a computer algebra system designed to solve problems in algebra, number theory, geometry and combinatorics. It is named after the algebraic structure magma. It runs on Unix-like operating systems, as well as Windows.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://magma.maths.usyd.edu.au/"
    },
    {
      "name": "máni",
      "source": "https://en.wikipedia.org/wiki/M%C3%A1ni",
      "about": "Máni (Old Norse \"Moon\"[1]) is the Moon personified in Germanic mythology. Máni, personified, is attested in the Poetic Edda, compiled in the 13th century from earlier traditional sources, and the Prose Edda, written in the 13th century by Snorri Sturluson. Both sources state that he is the brother of the personified sun, Sól, and the son of Mundilfari, while the Prose Edda adds that he is followed by the children Hjúki and Bil through the heavens. As a proper noun, Máni appears throughout Old Norse literature. Scholars have proposed theories about Máni's potential connection to the Northern European notion of the Man in the Moon, and a potentially otherwise unattested story regarding Máni through skaldic kennings.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "maple",
      "source": "https://en.wikipedia.org/wiki/Maple_(software)",
      "about": "Maple is a symbolic and numeric computing environment as well as a multi-paradigm programming language. It covers several areas of technical computing, such as symbolic mathematics, numerical analysis, data processing, visualization, and others. A toolbox, MapleSim, adds functionality for multidomain physical modeling and code generation.",
      "first_release": "1982",
      "types": "",
      "paradigms": "",
      "website": "https://www.maplesoft.com/products/Maple/"
    },
    {
      "name": "mapper",
      "source": "https://en.wikipedia.org/wiki/MAPPER",
      "about": "MAPPER, now known as BIS, is a fourth-generation programming language from Sperry Univac. Mapper originated in the 1970s[1] based on some work in the 1960s,[2] but has been kept current. It was renamed and also given an extension named ICE - Internet Commerce Enabler.[3][1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "mark-iv",
      "source": "https://en.wikipedia.org/wiki/MARK_IV_(software)",
      "about": "MARK IV is a fourth-generation programming language that was created by Informatics, Inc. in the 1960s. Informatics took advantage of IBM's decision to unbundle their software; MARK IV was the first \"software product to have cumulative sales of $10 million\".",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "mary",
      "source": "https://en.wikipedia.org/wiki/Mary_(programming_language)",
      "about": "Mary is a programming language designed and implemented by RUNIT at Trondheim, Norway in the 1970s. It borrowed many features from ALGOL 68 but was designed for systems programming (machine-oriented programming).",
      "first_release": "1971",
      "types": "static, strong",
      "paradigms": "imperative",
      "website": ""
    },
    {
      "name": "matlab",
      "source": "https://en.wikipedia.org/wiki/MATLAB",
      "about": "MATLAB (an abbreviation of \"matrix laboratory\") is a proprietary multi-paradigm programming language and numeric computing environment developed by MathWorks. MATLAB allows matrix manipulations, plotting of functions and data, implementation of algorithms, creation of user interfaces, and interfacing with programs written in other languages.",
      "first_release": "1970",
      "types": "dynamic, weak",
      "paradigms": "multi-paradigm, functional, imperative, procedural, object-oriented, array",
      "website": "https://www.mathworks.com/products/matlab.html"
    },
    {
      "name": "masm microsoft assembly x86",
      "source": "https://en.wikipedia.org/wiki/Microsoft_Macro_Assembler",
      "about": "The Microsoft Macro Assembler (MASM) is an x86 assembler that uses the Intel syntax for MS-DOS and Microsoft Windows. Beginning with MASM 8.0, there are two versions of the assembler: One for 16-bit & 32-bit assembly sources, and another (ML64) for 64-bit sources only.",
      "first_release": "1981",
      "types": "",
      "paradigms": "",
      "website": "https://docs.microsoft.com/en-us/cpp/assembler/masm/microsoft-macro-assembler-reference"
    },
    {
      "name": "math-matic",
      "source": "https://en.wikipedia.org/wiki/MATH-MATIC",
      "about": "MATH-MATIC is the marketing name for the AT-3 (Algebraic Translator 3) compiler, an early programming language for the UNIVAC I and UNIVAC II.",
      "first_release": "1957",
      "types": "",
      "paradigms": "imperative",
      "website": ""
    },
    {
      "name": "maude system",
      "source": "https://en.wikipedia.org/wiki/Maude_system",
      "about": "The Maude system is an implementation of rewriting logic developed at SRI International. It is similar in its general approach to Joseph Goguen's OBJ3 implementation of equational logic, but based on rewriting logic rather than order-sorted equational logic, and with a heavy emphasis on powerful metaprogramming based on reflection.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "maxima",
      "source": "https://en.wikipedia.org/wiki/Maxima_(software)",
      "about": "Maxima (/ˈmæksɪmə/) is a computer algebra system (CAS) based on a 1982 version of Macsyma. It is written in Common Lisp and runs on all POSIX platforms such as macOS, Unix, BSD, and Linux, as well as under Microsoft Windows and Android. It is free software released under the terms of the GNU General Public License (GPL).",
      "first_release": "1982",
      "types": "",
      "paradigms": "",
      "website": "https://maxima.sourceforge.io/"
    },
    {
      "name": "macsyma",
      "source": "https://en.wikipedia.org/wiki/Macsyma",
      "about": "Macsyma (/ˈmæksɪmə/; \"Project MAC's SYmbolic MAnipulator\")[1] is one of the oldest general-purpose computer algebra systems still in wide use. It was originally developed from 1968 to 1982 at MIT's Project MAC.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "max",
      "source": "https://en.wikipedia.org/wiki/Max_(software)",
      "about": "Max, also known as Max/MSP/Jitter, is a visual programming language for music and multimedia developed and maintained by San Francisco-based software company Cycling '74. Over its more than thirty-year history, it has been used by composers, performers, software designers, researchers, and artists to create recordings, performances, and installations.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "https://cycling74.com/products/max/"
    },
    {
      "name": "maxscript",
      "source": "https://en.wikipedia.org/wiki/Autodesk_3ds_Max",
      "about": "Autodesk 3ds Max, formerly 3D Studio and 3D Studio Max, is a professional 3D computer graphics program for making 3D animations, models, games and images. It is developed and produced by Autodesk Media and Entertainment.[2] It has modeling capabilities and a flexible plugin architecture and must be used on the Microsoft Windows platform. It is frequently used by video game developers, many TV commercial studios, and architectural visualization studios. It is also used for movie effects and movie pre-visualization. For its modeling and animation tools, the latest version[which?] of 3ds Max also features shaders (such as ambient occlusion and subsurface scattering), dynamic simulation, particle systems, radiosity, normal map creation and rendering, global illumination, a customizable user interface, new icons, and its own scripting language.[3]",
      "first_release": "1996",
      "types": "",
      "paradigms": "",
      "website": "https://www.autodesk.com/products/3ds-max/overview"
    },
    {
      "name": "maya",
      "source": "https://en.wikipedia.org/wiki/Maya_Embedded_Language",
      "about": "The Maya Embedded Language (MEL) is a scripting language used to simplify tasks in Autodesk's 3D Graphics Software Maya. Most tasks that can be achieved through Maya's GUI can be achieved with MEL, as well as certain tasks that are not available from the GUI. MEL offers a method of speeding up complicated or repetitive tasks, as well as allowing users to redistribute a specific set of commands to others that may find it useful.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "mdl",
      "source": "https://en.wikipedia.org/wiki/MDL_(programming_language)",
      "about": "MDL (Model Development Language,[1] or colloquially also referred to as More Datatypes than Lisp[2]:3 or MIT Design Language[citation needed]) is a programming language, a descendant of the language Lisp. Its initial purpose was to provide high level language support for the Dynamic Modeling Group at Massachusetts Institute of Technology's (MIT) Project MAC.[3] It was initially developed in 1971 on a PDP-10 computer on a time-sharing operating system named Incompatible Timesharing System (ITS). It later ran on TENEX, TOPS-20,[4][5] BSD,[2]:6 and AEGIS.[6]",
      "first_release": "1971",
      "types": "Dynamic, strong",
      "paradigms": "Multi-paradigm, functional, procedural, reflective, meta",
      "website": ""
    },
    {
      "name": "mercury",
      "source": "https://en.wikipedia.org/wiki/Mercury_(programming_language)",
      "about": "Mercury is a functional logic programming language made for real-world uses. The first version was developed at the University of Melbourne, Computer Science department, by Fergus Henderson, Thomas Conway, and Zoltan Somogyi, under Somogyi's supervision, and released on April 8, 1995.",
      "first_release": "1995",
      "types": "Strong, static, polymorphic",
      "paradigms": "Logic, functional, object-oriented",
      "website": "http://www.mercurylang.org/"
    },
    {
      "name": "mesa",
      "source": "https://en.wikipedia.org/wiki/Mesa_(programming_language)",
      "about": "Mesa[1] is a programming language developed in the late 1970s at the Xerox Palo Alto Research Center in Palo Alto, California, United States. The language name was a pun based upon the programming language catchphrases of the time, because Mesa is a \"high level\" programming language.",
      "first_release": "1976",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "mheg-5",
      "source": "https://en.wikipedia.org/wiki/MHEG-5",
      "about": "MHEG-5, or ISO/IEC 13522-5,[1] is part of a set of international standards relating to the presentation of multimedia information, standardised by the Multimedia and Hypermedia Experts Group (MHEG). It is most commonly used as a language to describe interactive television services.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "microcode",
      "source": "https://en.wikipedia.org/wiki/Microassembler",
      "about": "A microassembler is a computer program that helps prepare a microprogram, called firmware, to control the low level operation of a computer in much the same way an assembler helps prepare higher level code for a processor. The difference is that the microprogram is usually only developed by the processor manufacturer and works intimately with the computer hardware. On a microprogrammed computer the microprogram implements the operations of the instruction set in which any normal program (including both application programs and operating systems) is written. The use of a microprogram allows the manufacturer to fix certain mistakes, including working around hardware design errors, without modifying the hardware. Another means of employing microassembler-generated microprograms is in allowing the same hardware to run different instruction sets. After it is assembled, the microprogram is then loaded to a control store to become part of the logic of a CPU's control unit.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "microscript",
      "source": "https://en.wikipedia.org/wiki/MicroScript_(programming_language)",
      "about": "TRON (acronym for \"The Real-time Operating system Nucleus\") is an open architecture real-time operating system kernel design. The project was started by Prof. Dr. Ken Sakamura of the University of Tokyo in 1984. The project's goal is to create an ideal computer architecture and network, to provide for all of society's needs.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "miis",
      "source": "https://en.wikipedia.org/wiki/MIIS_(programming_language)",
      "about": "MIIS (Meditech Interpretive Information System) is a MUMPS-like programming language that was created by A.Neil Pappalardo and Curt W. Marble, on a DEC PDP at Mass General Hospital from 1964 to 1968. MUMPS evolution took two major directions: MUMPS proper and MIIS. MUMPS became an ANSI and ISO-standard language. When many MUMPS implementations standardized to be compatible, MIIS did not standardize, but became a proprietary system instead.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "milk",
      "source": "https://en.wikipedia.org/wiki/Milk_(programming_language)",
      "about": "Milk is a programming language \"that lets application developers manage memory more efficiently in programs that deal with scattered data points in large data sets.\"[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "mimic",
      "source": "https://en.wikipedia.org/wiki/MIMIC",
      "about": "MIMIC, known in capitalized form only, is a former simulation computer language developed 1964 by H. E. Petersen, F. J. Sansom and L. M. Warshawsky of Systems Engineering Group within the Air Force Materiel Command at the Wright-Patterson AFB in Dayton, Ohio, United States.[1] It is an expression-oriented continuous block simulation language, but capable of incorporating blocks of FORTRAN-like algebra.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "mirah",
      "source": "https://en.wikipedia.org/wiki/Mirah_(programming_language)",
      "about": "Mirah (formerly Duby) is a programming language based on Ruby language syntax, local type inference, hybrid static–dynamic type system, and a pluggable compiler toolchain. Mirah was created by Charles Oliver Nutter to be \"a 'Ruby-like' language, probably a subset of Ruby syntax, that [could] compile to solid, fast, idiomatic JVM bytecode.\"[1] The word mirah refers to the gemstone ruby in the Javanese language, a play on the concept of Ruby in Java.[2]",
      "first_release": "",
      "types": "static, with dynamic features, strong, inferred",
      "paradigms": "Object-oriented, imperative",
      "website": "http://www.mirah.org/"
    },
    {
      "name": "miranda",
      "source": "https://en.wikipedia.org/wiki/Miranda_(programming_language)",
      "about": "Miranda is a lazy, purely functional programming language designed by David Turner as a successor to his earlier programming languages SASL and KRC, using some concepts from ML and Hope. It was produced by Research Software Ltd. of England (which holds a trademark on the name Miranda) and was the first purely functional language to be commercially supported.[citation needed]",
      "first_release": "1985",
      "types": "strong, static",
      "paradigms": "lazy, functional, declarative",
      "website": "http://miranda.org.uk/"
    },
    {
      "name": "miva script",
      "source": "https://en.wikipedia.org/wiki/MIVA_Script",
      "about": "Miva Script is a proprietary computer scripting language mainly used for internet applications such as e-commerce. As of 2015, it is developed, maintained and owned by Miva Merchant, Inc., based in San Diego, California. Many web hosting companies support Miva Script on their servers, but it is significantly less widespread than other popular web languages.",
      "first_release": "1996",
      "types": "",
      "paradigms": "imperative",
      "website": "http://www.mivascript.com/"
    },
    {
      "name": "ml",
      "source": "https://en.wikipedia.org/wiki/ML_(programming_language)",
      "about": "ML (\"Meta Language\") is a general-purpose functional programming language. ML is statically-scoped. It is known for its use of the polymorphic Hindley–Milner type system, which automatically assigns the types of most expressions without requiring explicit type annotations, and ensures type safety – there is a formal proof that a well-typed ML program does not cause runtime type errors.[1] ML provides pattern matching for function arguments, garbage collection, imperative programming, call-by-value and currying. It is used heavily in programming language research and is one of the few languages to be completely specified and verified using formal semantics. Its types and pattern matching make it well-suited and commonly used to operate on other formal languages, such as in compiler writing, automated theorem proving, and formal verification.",
      "first_release": "1973",
      "types": "Inferred, static, strong",
      "paradigms": "Multi-paradigm, functional, imperative",
      "website": ""
    },
    {
      "name": "model 204",
      "source": "https://en.wikipedia.org/wiki/Model_204",
      "about": "Model 204 (M204) is a database management system for IBM and compatible mainframe computers developed and commercialized by Computer Corporation of America. It was announced in 1965,[1]:66[2] and first deployed in 1972. It incorporates a programming language and an environment for application development. Implemented in assembly language[2] for IBM System/360 and its successors, M204 can deal with very large databases[3] and transaction loads of 1000 TPS.[1]:4",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "modelica",
      "source": "https://en.wikipedia.org/wiki/Modelica",
      "about": "Modelica is an object-oriented, declarative, multi-domain modeling language for component-oriented modeling of complex systems, e.g., systems containing mechanical, electrical, electronic, hydraulic, thermal, control, electric power or process-oriented subcomponents. The free Modelica language[1] is developed by the non-profit Modelica Association.[2] The Modelica Association also develops the free Modelica Standard Library[3] that contains about 1400 generic model components and 1200 functions in various domains, as of version 4.0.0.",
      "first_release": "1997",
      "types": "",
      "paradigms": "Declarative language",
      "website": "https://www.modelica.org/"
    },
    {
      "name": "modula",
      "source": "https://en.wikipedia.org/wiki/Modula",
      "about": "The Modula programming language is a descendant of the Pascal language. It was developed in Switzerland, at ETH Zurich, in the mid-1970s by Niklaus Wirth, the same person who designed Pascal. The main innovation of Modula over Pascal is a module system, used for grouping sets of related declarations into program units; hence the name Modula. The language is defined in a report by Wirth called Modula. A language for modular multiprogramming published 1976.[1]",
      "first_release": "1975",
      "types": "Static, strong, safe",
      "paradigms": "Imperative, structured, modular",
      "website": ""
    },
    {
      "name": "modula-2",
      "source": "https://en.wikipedia.org/wiki/Modula-2",
      "about": "Modula-2 is a structured, procedural programming language developed between 1977 and 1985 by Niklaus Wirth at ETH Zurich. It was created as the language for the operating system (OS) and application software of the Lilith personal workstation.[1] It was later used for programming outside the context of the Lilith.",
      "first_release": "1978",
      "types": "Static, strong, safe",
      "paradigms": "imperative, structured, modular, data and procedure hiding, concurrent",
      "website": "http://www.modula2.org/"
    },
    {
      "name": "modula-3",
      "source": "https://en.wikipedia.org/wiki/Modula-3",
      "about": "Modula-3 is a programming language conceived as a successor to an upgraded version of Modula-2 known as Modula-2+. While it has been influential in research circles (influencing the designs of languages such as Java, C#, and Python[7]) it has not been adopted widely in industry. It was designed by Luca Cardelli, James Donahue, Lucille Glassman, Mick Jordan (before at the Olivetti Software Technology Laboratory), Bill Kalsow and Greg Nelson at the Digital Equipment Corporation (DEC) Systems Research Center (SRC) and the Olivetti Research Center (ORC) in the late 1980s.",
      "first_release": "1988",
      "types": "strong, static, safe, unsafe",
      "paradigms": "imperative, structured, procedural, modular, concurrent",
      "website": "http://www.modula3.org/"
    },
    {
      "name": "mohol",
      "source": "https://en.wikipedia.org/wiki/Mohol_programming_languages",
      "about": "A system programming language is a programming language used for system programming; such languages are designed for writing system software, which usually requires different development approaches when compared with application software. Edsger Dijkstra refers to these language as Machine Oriented High Order Languages, or mohol.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "moo",
      "source": "https://en.wikipedia.org/wiki/MOO_(programming_language)",
      "about": "A MOO (MUD, object-oriented[1][2]) is a text-based online virtual reality system to which multiple users (players) are connected at the same time.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "mortran",
      "source": "https://en.wikipedia.org/wiki/Mortran",
      "about": "Mortran (More Fortran) is an extension of the Fortran programming language used for scientific computation. It introduces syntax changes, including the use of semicolons to end statements, in order to improve readability and flexibility. Mortran code is macro-processed into Fortran code for compilation.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "mouse",
      "source": "https://en.wikipedia.org/wiki/Mouse_(programming_language)",
      "about": "The Mouse programming language is a small computer programming language developed by Dr. Peter Grogono in the late 1970s and early 1980s.[1][2][3] It was developed as an extension of an earlier language called MUSYS, which was used to control digital and analog devices in an electronic music studio.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "mpd",
      "source": "https://en.wikipedia.org/wiki/MPD_(programming_language)",
      "about": "Multithreaded, Parallel, and Distributed Programming (MPD) is a concurrent programming language whose syntax is derived from the one used in the book Foundations of Multithreaded, Parallel, and Distributed Programming. The name lists the distinguishing features of the language, namely that it supports all three of these concurrent programming techniques.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "msl",
      "source": "https://en.wikipedia.org/wiki/MIRC_scripting_language",
      "about": "The mIRC scripting language (often unofficially abbreviated to \"mSL\"[3][4]) is the scripting language embedded in mIRC, an IRC client for Windows.",
      "first_release": "1995",
      "types": "Dynamic typing",
      "paradigms": "Event-driven programming, Procedural programming",
      "website": "http://mirc.com/"
    },
    {
      "name": "mumps",
      "source": "https://en.wikipedia.org/wiki/MUMPS",
      "about": "MUMPS (\"Massachusetts General Hospital Utility Multi-Programming System\"), or M, is an integrated programming language and key–value database originally developed at Massachusetts General Hospital for managing hospital laboratory information systems.",
      "first_release": "1966",
      "types": "",
      "paradigms": "Imperative, Procedural",
      "website": ""
    },
    {
      "name": "mupad",
      "source": "https://en.wikipedia.org/wiki/MuPAD",
      "about": "MuPAD is a computer algebra system (CAS). Originally developed by the MuPAD research group at the University of Paderborn, Germany, development was taken over by the company SciFace Software GmbH & Co. KG in cooperation with the MuPAD research group and partners from some other universities starting in 1997. MuPAD's graphics package was particularly successful, especially considering the era when it was developed.[citation needed]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://mathworks.com/discovery/mupad.html"
    },
    {
      "name": "mutan",
      "source": "https://en.wikipedia.org/wiki/Ethereum",
      "about": "Ethereum is a decentralized, open-source blockchain featuring smart contract functionality. Ether (ETH) is the native cryptocurrency of the platform. It is the second-largest cryptocurrency by market capitalization, after Bitcoin.[1] Ethereum is the most actively used blockchain.[2][3]",
      "first_release": "2015",
      "types": "",
      "paradigms": "",
      "website": "http://ethereum.org/"
    },
    {
      "name": "mystic programming language",
      "source": "https://en.wikipedia.org/wiki/Mystic_BBS",
      "about": "Mystic BBS is a bulletin board system software program that began in 1995 and was first released to the public in December 1997 under the MS-DOS platform. It has since been ported to Microsoft Windows, OS/2, OS X, and Linux (Intel and ARM based systems such as the Raspberry Pi). Mystic was designed to be a spiritual successor to the Telegard and Renegade bulletin board systems.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.mysticbbs.com/"
    },
    {
      "name": "nasm",
      "source": "https://en.wikipedia.org/wiki/Netwide_Assembler",
      "about": "The Netwide Assembler (NASM) is an assembler and disassembler for the Intel x86 architecture. It can be used to write 16-bit, 32-bit (IA-32) and 64-bit (x86-64) programs. NASM is considered to be one of the most popular assemblers for Linux.[1]",
      "first_release": "1996",
      "types": "",
      "paradigms": "",
      "website": "https://www.nasm.us/"
    },
    {
      "name": "napier88",
      "source": "https://en.wikipedia.org/wiki/Napier88",
      "about": "Napier88 is an orthogonally persistent programming language that was designed and implemented at the University of St Andrews, Scotland. The primary designer was Ron Morrison, whose initial designs were extended and implemented by Fred Brown, Richard Connor, and Al Dearle. Napier88 was ahead of its time in many ways, and was the first robustly implemented language to combine a polymorphic type system with orthogonal persistence. The language was robustly implemented and released to users from both industry and academia; up to 1,000 registered users were recorded in due course. The language, however, was only intended to provide a proof of concept for an experiment in persistent programming; some time after 1989 (the year the first implementation was in fact released) the group's interests moved on and the language was no longer maintained.",
      "first_release": "1988",
      "types": "",
      "paradigms": "Multi-paradigm, Procedural, imperative, structured",
      "website": ""
    },
    {
      "name": "neko",
      "source": "https://en.wikipedia.org/wiki/Neko_(programming_language)",
      "about": "NekoVM is a virtual machine developed by Nicolas Cannasse as part of research and development (R&D) efforts at two indie video game firms in Bordeaux, France: first at Motion Twin and then at Shiro Games. NekoVM's native language is the bytecode for a high-level dynamically typed programming language called Neko. This pairing allows Neko to be used directly as an embedded scripting language or to target NekoVM by compiling some other language (such as Haxe) to NekoVM bytecode.",
      "first_release": "2005",
      "types": "Dynamic",
      "paradigms": "Object-oriented, structured, prototype-based, scripting",
      "website": "http://nekovm.org/"
    },
    {
      "name": "nemerle",
      "source": "https://en.wikipedia.org/wiki/Nemerle",
      "about": "Nemerle is a general-purpose, high-level, statically typed programming language designed for platforms using the Common Language Infrastructure (.NET/Mono). It offers functional, object-oriented and imperative features. It has a simple C#-like syntax and a powerful metaprogramming system. In June 2012, the core developers of Nemerle were hired by the Czech software development company JetBrains. The team is focusing on developing Nitra, a framework to implement extant and new programming languages. This framework will likely be used to create future versions of Nemerle.[2][3][4]",
      "first_release": "2003",
      "types": "Inferred, nominal, static, strong",
      "paradigms": "Multi-paradigm, functional, imperative, meta, object-oriented",
      "website": "http://nemerle.org/"
    },
    {
      "name": "nesl",
      "source": "https://en.wikipedia.org/wiki/NESL",
      "about": "NESL is a parallel programming language developed at Carnegie Mellon by the SCandAL project and released in 1993. It integrates various ideas from parallel algorithms, and functional programming and array programming languages.",
      "first_release": "1993",
      "types": "",
      "paradigms": "functional, array",
      "website": ""
    },
    {
      "name": "net.data",
      "source": "https://en.wikipedia.org/wiki/Net.Data",
      "about": "Net.Data is a programming language by IBM used largely for database-backed web applications.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www-306.ibm.com/software/data/net.data/"
    },
    {
      "name": "netlogo",
      "source": "https://en.wikipedia.org/wiki/NetLogo",
      "about": "NetLogo is a programming language and integrated development environment (IDE) for agent-based modeling.",
      "first_release": "1999",
      "types": "Dynamic, strong",
      "paradigms": "multi-paradigm, educational, procedural, agent-based, simulation",
      "website": "http://ccl.northwestern.edu/netlogo"
    },
    {
      "name": "netrexx",
      "source": "https://en.wikipedia.org/wiki/NetRexx",
      "about": "NetRexx is an open source, originally IBM's, variant of the REXX programming language to run on the Java virtual machine.[3] It supports a classic REXX syntax, with no reserved keywords, along with considerable additions to support object-oriented programming in a manner compatible with Java's object model, yet can be used as both a compiled and an interpreted language, with an option of using only data types native to the JVM or the NetRexx runtime package. The latter offers the standard Rexx data type that combines string processing with unlimited precision decimal arithmetic.",
      "first_release": "1996",
      "types": "Static, strong, safe, dynamic, string",
      "paradigms": "multiparadigm, object-oriented, procedural, structured",
      "website": ""
    },
    {
      "name": "newlisp",
      "source": "https://en.wikipedia.org/wiki/NewLISP",
      "about": "newLISP is a scripting language which is a dialect of the Lisp family of programming languages. It was designed and developed by Lutz Mueller.[2] newLISP is free and open-source software released under the GNU General Public License, version 3 or later.",
      "first_release": "1991",
      "types": "",
      "paradigms": "",
      "website": "http://www.newlisp.org/"
    },
    {
      "name": "newp",
      "source": "https://en.wikipedia.org/wiki/NEWP",
      "about": "NEWP, short for New Executive Programming Language, is a high-level programming language used on the Unisys MCP systems. The language is used to write the operating system and other system utilities, although it can also be used to write user software as well. Several constructs separate it from extended ALGOL on which it is based. Language operators such as MEMORY which allows direct memory access are strictly used by programs running as the MCP.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "newspeak",
      "source": "https://en.wikipedia.org/wiki/Newspeak_(programming_language)",
      "about": "Newspeak is a programming language and platform in the tradition of Smalltalk and Self being developed by a team led by Gilad Bracha. The platform includes an IDE, a GUI library, and standard libraries.[1] Starting in 2006, Cadence Design Systems funded its development and employed the main contributors, but ceased funding in January 2009.[2]",
      "first_release": "2006",
      "types": "dynamic, optional",
      "paradigms": "object-oriented, functional",
      "website": "http://newspeaklanguage.org/"
    },
    {
      "name": "newtonscript",
      "source": "https://en.wikipedia.org/wiki/NewtonScript",
      "about": "NewtonScript is a prototype-based programming language created to write programs for the Newton platform.[1] It is heavily influenced by the Self programming language, but modified to be more suited to needs of mobile and embedded devices.[2]",
      "first_release": "1993",
      "types": "Dynamic",
      "paradigms": "Prototype, Object-oriented",
      "website": ""
    },
    {
      "name": "nial",
      "source": "https://en.wikipedia.org/wiki/Nial",
      "about": "Nial (from \"Nested Interactive Array Language\") is a high-level array programming language developed from about 1981 by Mike Jenkins (named after Nial Dixon) of Queen's University, Kingston, Ontario, Canada. Jenkins co-created the Jenkins–Traub algorithm.",
      "first_release": "1981",
      "types": "dynamic",
      "paradigms": "array",
      "website": "https://github.com/danlm/qnial7"
    },
    {
      "name": "nickle",
      "source": "https://en.wikipedia.org/wiki/Nickle_(programming_language)",
      "about": "Nickle is a numeric oriented programming language by Keith Packard and Bart Massey. Originally used for desktop calculation, it has since expanded for prototyping of complicated algorithms.",
      "first_release": "2001",
      "types": "",
      "paradigms": "multi-paradigm",
      "website": "http://www.nickle.org/"
    },
    {
      "name": "nitin",
      "source": "https://en.wikipedia.org/wiki/Nickle_(programming_language)",
      "about": "Nickle is a numeric oriented programming language by Keith Packard and Bart Massey. Originally used for desktop calculation, it has since expanded for prototyping of complicated algorithms.",
      "first_release": "2001",
      "types": "",
      "paradigms": "multi-paradigm",
      "website": "http://www.nickle.org/"
    },
    {
      "name": "nim",
      "source": "https://en.wikipedia.org/wiki/Nim_(programming_language)",
      "about": "Nim is an imperative, general-purpose, multi-paradigm, statically typed, systems, compiled programming language[7] designed and developed by Andreas Rumpf. It is designed to be \"efficient, expressive, and elegant\",[8] supporting metaprogramming, functional, message passing,[5] procedural, and object-oriented programming styles by providing several features such as compile time code generation, algebraic data types, a foreign function interface (FFI) with C, C++, Objective-C, and JavaScript, and supporting compiling to those same languages.",
      "first_release": "2008",
      "types": "Static, [2], strong, [3], inferred, structural",
      "paradigms": "Multi-paradigm, compiled, concurrent, Procedural, Imperative, Functional, Object-oriented",
      "website": "http://nim-lang.org/"
    },
    {
      "name": "nix",
      "source": "https://en.wikipedia.org/wiki/Nix_package_manager",
      "about": "Nix is a cross-platform package manager that utilizes a purely functional deployment model where software is installed into unique directories generated through cryptographic hashes, it is also the name of the programming language. A package's hash takes into account the dependencies, which is claimed to eliminate dependency hell.[2] This package management model advertises more reliable, reproducible, and portable packages.[3][4]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "https://nixos.org/nix"
    },
    {
      "name": "npl",
      "source": "https://en.wikipedia.org/wiki/NORD_Programming_Language",
      "about": "Nord Programming Language, commonly abbreviated NPL, was a programming language by the Norwegian minicomputer manufacturer Norsk Data. It shipped as a standard component of the operating system SINTRAN III.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "not exactly c",
      "source": "https://en.wikipedia.org/wiki/Not_eXactly_C",
      "about": "Not eXactly C, or NXC, is a high-level programming language for the Lego Mindstorms NXT designed by John Hansen in 2006. NXC, which is short for Not eXactly C, is based on Next Byte Codes, an assembly language. NXC has a syntax like C. The IDE for NXC is the Bricx Command Center.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "not quite c",
      "source": "https://en.wikipedia.org/wiki/Not_Quite_C",
      "about": "Not Quite C (NQC) is a programming language, application programming interface (API), and native bytecode compiler toolkit for the Lego Mindstorms, Cybermaster and LEGO Spybotics systems. It is based primarily on the C language but has specific limitations, such as the maximum number of subroutines and variables allowed, which differ depending on the version of firmware the RCX has. The language was invented by David Baum. He has released two books on the subject.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "nsis",
      "source": "https://en.wikipedia.org/wiki/Nullsoft_Scriptable_Install_System",
      "about": "Nullsoft Scriptable Install System (NSIS) is a script-driven installer authoring tool for Microsoft Windows backed by Nullsoft, the creators of Winamp. NSIS is released under a combination of free software licenses, primarily the zlib license.[2] It has become a widely used alternative to commercial proprietary products like InstallShield, with users including Amazon.com, Dropbox, Google, Ubisoft, FL Studio, BitTorrent, and McAfee.[3]",
      "first_release": "2000",
      "types": "",
      "paradigms": "",
      "website": "http://nsis.sourceforge.io/"
    },
    {
      "name": "nu",
      "source": "https://en.wikipedia.org/wiki/Nu_(programming_language)",
      "about": "Nu is an interpreted object-oriented programming language, with a Lisp-like syntax, created by Tim Burks as an alternative scripting language to program OS X through its Cocoa application programming interface (API). Implementations also exist for iPhone and Linux.",
      "first_release": "2007",
      "types": "",
      "paradigms": "structured, imperative, functional, object-oriented",
      "website": "http://programming-nu.github.io/"
    },
    {
      "name": "nwscript",
      "source": "https://en.wikipedia.org/wiki/NWScript",
      "about": "NWScript is the scripting language developed by BioWare for the role-playing video game Neverwinter Nights. It is based on the C programming language and is implemented in the Aurora toolset. Neverscript, an open source 3rd party editor, has been created for the Mac OS X and Linux versions of Neverwinter Nights because the Aurora toolset has not been ported to those platforms.",
      "first_release": "2002",
      "types": "",
      "paradigms": "",
      "website": "http://nwn.bioware.com/developers/"
    },
    {
      "name": "nxt-g",
      "source": "https://en.wikipedia.org/wiki/NXT-G",
      "about": "LEGO Mindstorms NXT is a programmable robotics kit released by Lego in late July 2006.[1] It replaced the first-generation Lego Mindstorms kit, which was called the Robotics Invention System. The base kit ships in two versions: the Retail Version (set #8527)[2] and the Education Base Set (set #9797).[3] It comes with the NXT-G programming software, or optionally LabVIEW for Lego Mindstorms.[4] A variety of unofficial languages exist, such as NXC, NBC, leJOS NXJ, and RobotC. The second generation of the set, the Lego Mindstorms NXT 2.0, was released on August 1, 2009, featuring a color sensor and other upgraded capabilities. The third generation, the EV3, was released in September 2013.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://mindstorms.lego.com/"
    },
    {
      "name": "o:xml",
      "source": "https://en.wikipedia.org/wiki/O:XML",
      "about": "o:XML is an open source, dynamically typed, general-purpose object-oriented programming language based on XML-syntax. It has threads, exception handling, regular expressions and namespaces. Additionally o:XML has an expression language very similar to XPath that allows functions to be invoked on nodes and node sets.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "oak",
      "source": "https://en.wikipedia.org/wiki/Oak_(programming_language)",
      "about": "Oak is a discontinued programming language created by James Gosling in 1989, initially for Sun Microsystems' set-top box project. The language later evolved to become Java.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "oberon",
      "source": "https://en.wikipedia.org/wiki/Oberon_(programming_language)",
      "about": "Oberon is a general-purpose programming language first published in 1987 by Niklaus Wirth and the latest member of the Wirthian family of ALGOL-like languages (Euler, ALGOL W, Pascal, Modula, and Modula-2).[1][2][3][4] Oberon was the result of a concentrated effort to increase the power of Modula-2, the direct successor of Pascal, and simultaneously to reduce its complexity. Its principal new feature is the concept of type extension of record types.[5] It permits constructing new data types on the basis of existing ones and to relate them, deviating from the dogma of strictly static typing of data. Type extension is Wirth's way of inheritance reflecting the viewpoint of the parent site. Oberon was developed as part of the implementation of an operating system, also named Oberon at ETH Zurich in Switzerland. The name is from the moon of the planet Uranus, named Oberon.",
      "first_release": "1987",
      "types": "Strong, static, dynamic",
      "paradigms": "Imperative, structured, modular, object-oriented",
      "website": "http://www.projectoberon.com/"
    },
    {
      "name": "obj2",
      "source": "https://en.wikipedia.org/wiki/OBJ2",
      "about": "OBJ2 is a programming language with Clear-like parametrised modules and a functional system based on equations. It is a member of the OBJ family of languages.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "object lisp",
      "source": "https://en.wikipedia.org/wiki/Object_Lisp",
      "about": "Object Lisp was a computer programming language, a dialect of the Lisp language. It was an object-oriented extension for the Lisp dialect Lisp Machine Lisp, designed by Lisp Machines, Inc. Object Lisp was also an early example of prototype-based programming.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "objectlogo",
      "source": "https://en.wikipedia.org/wiki/ObjectLOGO",
      "about": "Logo is an educational programming language, designed in 1967 by Wally Feurzeig, Seymour Papert, and Cynthia Solomon.[1] Logo is not an acronym: the name was coined by Feurzeig while he was at Bolt, Beranek and Newman,[2] and derives from the Greek logos, meaning word or thought.",
      "first_release": "1967",
      "types": "dynamic",
      "paradigms": "Multi-paradigm, functional, educational, procedural, reflective",
      "website": ""
    },
    {
      "name": "object rexx",
      "source": "https://en.wikipedia.org/wiki/Object_REXX",
      "about": "The Object REXX programming language is an object-oriented scripting language initially produced by IBM for the operating system OS/2 and later[3] for Microsoft Windows. It is a follow-on to and a significant extension[a] of the \"Classic Rexx\" language originally created for the Conversational Monitor System (CMS) component of the operating system VM/SP and later ported to Multiple Virtual Storage (MVS),[b] OS/2 and PC DOS.",
      "first_release": "1988",
      "types": "",
      "paradigms": "Object-oriented, class-based",
      "website": "http://www.oorexx.org/"
    },
    {
      "name": "object pascal",
      "source": "https://en.wikipedia.org/wiki/Object_Pascal",
      "about": "Object Pascal is an extension to the programming language Pascal that provides object-oriented programming (OOP) features such as classes and methods.",
      "first_release": "1986",
      "types": "Static and dynamic, RTTI, strong, safe",
      "paradigms": "Imperative, structured, object-oriented, functional, component-based, event-driven, generic",
      "website": ""
    },
    {
      "name": "objective-c",
      "source": "https://en.wikipedia.org/wiki/Objective-C",
      "about": "Objective-C is a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. It was the main programming language supported by Apple for macOS, iOS, and their respective application programming interfaces (APIs), Cocoa and Cocoa Touch, until the introduction of Swift in 2014.[3]",
      "first_release": "1984",
      "types": "static, dynamic, weak",
      "paradigms": "",
      "website": "https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html"
    },
    {
      "name": "objective-j",
      "source": "https://en.wikipedia.org/wiki/Objective-J",
      "about": "Objective-J is a programming language developed as part of the Cappuccino web development framework. Its syntax is nearly identical to the Objective-C syntax and it shares with JavaScript the same relationship that Objective-C has with the C programming language: that of being a strict, but small, superset; adding traditional inheritance and Smalltalk/Objective-C style dynamic dispatch. Pure JavaScript, being a prototype-based language, already has a notion of object orientation and inheritance, but Objective-J adds the use of class-based programming to JavaScript.",
      "first_release": "2008",
      "types": "dynamic, weak, duck",
      "paradigms": "Multi-paradigm, reflective, object-oriented, functional, imperative, scripting",
      "website": "http://www.cappuccino-project.org/"
    },
    {
      "name": "obliq",
      "source": "https://en.wikipedia.org/wiki/Obliq",
      "about": "Obliq is an interpreted, object-oriented programming language designed to make distributed, and locally multithreaded, computing simpler and easier to program, while providing program safety and an implicit type system. The interpreter is written in Modula-3, and provides Obliq with full access to Modula-3's network objects abilities. A type inference algorithm for record concatenation, subtyping, and recursive types has been developed for Obliq. Further, it has been proved to be NP-complete[1] and its lowest complexity to be Ο(n3) or if under other modeling up to certain conditions down to Ο(n2)[2] and its best known implementation runs in Ο(n5).[3][contradictory] Obliq's syntax is very similar to Modula-3, the biggest difference being that Obliq has no need of explicit typed variables (i.e., a variable can hold any data type allowed by the type checker and if does not accepts one, i.e., a given expression execution error will display) although explicit type declarations are allowed and ignored by the interpreter. The basic data types in the language include booleans, integers, reals, characters, strings, and arrays. Obliq supports the usual set of sequential control structures (conditional, iteration, and exception handling forms), and special control forms for concurrency (mutexes and guarded statements). Further, Obliq's objects can be cloned and safely copied remotely by any machine in a distributed network object and it can be done safely and transparently.[4]",
      "first_release": "1993",
      "types": "Strong, dynamic",
      "paradigms": "Multi-paradigm, imperative, structured, modular, object-oriented, prototype-based, parallel",
      "website": "http://www.cc.gatech.edu/gvu/people/Phd/Krishna/VO/VOHome.html"
    },
    {
      "name": "ocaml",
      "source": "https://en.wikipedia.org/wiki/OCaml",
      "about": "OCaml (/oʊˈkæməl/ oh-KAM-əl, formerly Objective Caml) is a general-purpose, multi-paradigm programming language which extends the Caml dialect of ML with object-oriented features. OCaml was created in 1996 by Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez, and others.",
      "first_release": "1996",
      "types": "Inferred, static, strong, structural",
      "paradigms": "Multi-paradigm, functional, imperative, modular, [1], object-oriented",
      "website": "https://ocaml.org/"
    },
    {
      "name": "occam",
      "source": "https://en.wikipedia.org/wiki/Occam_(programming_language)",
      "about": "occam is a programming language which is concurrent and builds on the communicating sequential processes (CSP) process algebra,[1] and shares many of its features. It is named after philosopher William of Ockham after whom Occam's razor is named.",
      "first_release": "1983",
      "types": "",
      "paradigms": "Imperative, procedural, concurrent",
      "website": ""
    },
    {
      "name": "occam-π",
      "source": "https://en.wikipedia.org/wiki/Occam-%CF%80",
      "about": "In computer science, occam-π (or occam-pi) is the name of a variant of the programming language occam developed by the Kent Retargetable occam Compiler (KRoC) team at the University of Kent.[1] The name reflects the introduction of elements of π-calculus (pi-calculus) into occam, especially concepts involving mobile agents (processes) and data. The language contains several extensions to occam 2.1, including:",
      "first_release": "",
      "types": "",
      "paradigms": "Imperative, procedural, concurrent",
      "website": ""
    },
    {
      "name": "octave",
      "source": "https://en.wikipedia.org/wiki/GNU_Octave",
      "about": "GNU Octave is software featuring a high-level programming language, primarily intended for numerical computations. Octave helps in solving linear and nonlinear problems numerically, and for performing other numerical experiments using a language that is mostly compatible with MATLAB. It may also be used as a batch-oriented language. Since it is part of the GNU Project, it is free software under the terms of the GNU General Public License.",
      "first_release": "1988",
      "types": "",
      "paradigms": "",
      "website": "https://gnu.org/software/octave/"
    },
    {
      "name": "omnimark",
      "source": "https://en.wikipedia.org/wiki/OmniMark",
      "about": "OmniMark is a fourth-generation programming language used mostly in the publishing industry. It is currently a proprietary software product of Stilo International. As of September 2018 the most recent release[1] of OmniMark was 10.1.2, dated April 2016.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "opa",
      "source": "https://en.wikipedia.org/wiki/Opa_(programming_language)",
      "about": "Opa is an open-source programming language for developing scalable web applications.",
      "first_release": "2011",
      "types": "static, strong, inferred",
      "paradigms": "multi-paradigm, functional, imperative",
      "website": "http://opalang.org/"
    },
    {
      "name": "opal",
      "source": "https://en.wikipedia.org/wiki/Opal_(programming_language)",
      "about": "OPAL (OPtimized Applicative Language) is a functional programming language first developed at the Technical University of Berlin.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "opencl",
      "source": "https://en.wikipedia.org/wiki/OpenCL",
      "about": "OpenCL (Open Computing Language) is a framework for writing programs that execute across heterogeneous platforms consisting of central processing units (CPUs), graphics processing units (GPUs), digital signal processors (DSPs), field-programmable gate arrays (FPGAs) and other processors or hardware accelerators. OpenCL specifies programming languages (based on C99 and C++11) for programming these devices and application programming interfaces (APIs) to control the platform and execute programs on the compute devices. OpenCL provides a standard interface for parallel computing using task- and data-based parallelism.",
      "first_release": "2009",
      "types": "",
      "paradigms": "",
      "website": "https://www.khronos.org/opencl/"
    },
    {
      "name": "openedge abl",
      "source": "https://en.wikipedia.org/wiki/OpenEdge_Advanced_Business_Language",
      "about": "OpenEdge Advanced Business Language, or OpenEdge ABL for short, is a business application development language created and maintained by Progress Software Corporation (PSC). The language, typically classified as a fourth-generation programming language, uses an English-like syntax to simplify software development.[1] The language was called PROGRESS or Progress 4GL up until version 9, but in 2006 PSC changed the name to OpenEdge Advanced Business Language (OpenEdge ABL) in order to overcome a presumed industry perception that 4GLs were less capable than other languages.[2] A subset of the language, called SpeedScript, is used in the development of web applications.[3]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "https://www.progress.com/openedge"
    },
    {
      "name": "opl",
      "source": "https://en.wikipedia.org/wiki/Open_Programming_Language",
      "about": "Open Programming Language (OPL) is an embedded programming language for portable devices that run the Symbian Operating System.",
      "first_release": "1984",
      "types": "",
      "paradigms": "imperative, structured, embedded",
      "website": "http://opl-dev.sourceforge.net/"
    },
    {
      "name": "openvera",
      "source": "https://en.wikipedia.org/wiki/OpenVera",
      "about": "OpenVera was a hardware verification language developed by System Science and acquired by Synopsys.[1] OpenVera was an interoperable, open hardware verification language for testbench creation. The OpenVera language was used as the basis for the advanced verification features in the IEEE Std. 1800 SystemVerilog standard, for the benefit of the entire verification community including companies in the semiconductor, systems, IP and EDA industries along with verification services.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "ops5",
      "source": "https://en.wikipedia.org/wiki/OPS5",
      "about": "OPS5 is a rule-based or production system computer language, notable as the first such language to be used in a successful expert system, the R1/XCON system used to configure VAX computers.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "optimj",
      "source": "https://en.wikipedia.org/wiki/OptimJ",
      "about": "OptimJ is an extension for Java with language support for writing optimization models and abstractions for bulk data processing. The extensions and the proprietary product implementing the extensions were developed by Ateji which went out of business in September 2011.[1] OptimJ aims at providing a clear and concise algebraic notation for optimization modeling, removing compatibility barriers between optimization modeling and application programming tools, and bringing software engineering techniques such as object-orientation and modern IDE support to optimization experts.",
      "first_release": "2006",
      "types": "",
      "paradigms": "object-oriented",
      "website": "http://www.ateji.com/"
    },
    {
      "name": "orc",
      "source": "https://en.wikipedia.org/wiki/Orc_(programming_language)",
      "about": "Orc is a concurrent, nondeterministic computer programming language created by Jayadev Misra at the University of Texas at Austin.",
      "first_release": "2004",
      "types": "",
      "paradigms": "concurrent, nondeterministic",
      "website": "https://orc.csres.utexas.edu/"
    },
    {
      "name": "orca/modula-2",
      "source": "https://en.wikipedia.org/wiki/ORCA/Modula-2",
      "about": "ORCA/Modula-2 is a Modula-2 compiler written in the Modula-2 programming language for the Apple IIGS computer.",
      "first_release": "1994",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "oriel",
      "source": "https://en.wikipedia.org/wiki/Oriel_(scripting_language)",
      "about": "Oriel is a scripting language released with the Power Tools series of instructional books written by the LeBlond Group. Described in its documentation as a \"graphics-based batch language\", it was originally designed for Microsoft Windows 3.0 and released with the book Windows 3 Power Tools in 1991.[1] However, versions of the language were also bundled with Windows 3.1 Power Tools in 1992 and Windows NT Power Tools in 1994.",
      "first_release": "1991",
      "types": "",
      "paradigms": "Imperative, Procedural",
      "website": ""
    },
    {
      "name": "orwell",
      "source": "https://en.wikipedia.org/wiki/Orwell_(programming_language)",
      "about": "Orwell is a small, lazy-evaluation functional programming language implemented principally by Martin Raskovsky and first released in 1984 by Philip Wadler during his time as a Research Fellow in the Programming Research Group, part of the Oxford University Computing Laboratory. Developed as a free alternative to Miranda, it was a forerunner of Haskell and was one of the first programming languages to support list comprehensions and pattern matching.",
      "first_release": "1984",
      "types": "",
      "paradigms": "Lazy, functional",
      "website": ""
    },
    {
      "name": "oxygene",
      "source": "https://en.wikipedia.org/wiki/Oxygene_(programming_language)",
      "about": "Oxygene (formerly known as Chrome) is a programming language developed by RemObjects Software for Microsoft's Common Language Infrastructure, the Java Platform and Cocoa. Oxygene based on Delphi's Object Pascal, but also has influences from C#, Eiffel, Java, F# and other languages.",
      "first_release": "2005",
      "types": "",
      "paradigms": "",
      "website": "http://elementscompiler.com/elements/oxygene/"
    },
    {
      "name": "oz",
      "source": "https://en.wikipedia.org/wiki/Oz_(programming_language)",
      "about": "Oz is a multiparadigm programming language, developed in the Programming Systems Lab at Université catholique de Louvain, for programming language education. It has a canonical textbook: Concepts, Techniques, and Models of Computer Programming.",
      "first_release": "1991",
      "types": "dynamic",
      "paradigms": "multi-paradigm, logic, functional, imperative, object-oriented, constraint, distributed, concurrent",
      "website": "http://mozart.github.io/"
    },
    {
      "name": "p",
      "source": "https://en.wikipedia.org/wiki/P_(programming_language)",
      "about": "P is a programming language for asynchronous event-driven programming and the IoT that was developed by Microsoft and University of California, Berkeley.[1]",
      "first_release": "2012",
      "types": "",
      "paradigms": "",
      "website": "https://github.com/p-org/P"
    },
    {
      "name": "p4",
      "source": "https://en.wikipedia.org/wiki/P4_(programming_language)",
      "about": "P4 is a programming language for controlling packet forwarding planes in networking devices, such as routers and switches. In contrast to a general purpose language such as C or Python, P4 is a domain-specific language with a number of constructs optimized for network data forwarding. P4 is distributed as open-source, permissively licensed code, and is maintained by the P4 Language Consortium, a not-for-profit organization hosted by the Open Networking Foundation.",
      "first_release": "2013",
      "types": "",
      "paradigms": "compiled, domain-specific, imperative",
      "website": "http://p4.org/"
    },
    {
      "name": "p′′",
      "source": "https://en.wikipedia.org/wiki/P%E2%80%B2%E2%80%B2",
      "about": "P′′ (P double prime[1]) is a primitive computer programming language created by Corrado Böhm[2][3] in 1964 to describe a family of Turing machines.",
      "first_release": "1964",
      "types": "",
      "paradigms": "Imperative, structured",
      "website": ""
    },
    {
      "name": "parasail",
      "source": "https://en.wikipedia.org/wiki/ParaSail_(programming_language)",
      "about": "Parallel Specification and Implementation Language (ParaSail) is an object-oriented parallel programming language. Its design and ongoing implementation is described in a blog[2] and on its official website.[3]",
      "first_release": "2009",
      "types": "strong, static",
      "paradigms": "compiled, concurrent, imperative, structured, object-oriented",
      "website": "http://parasail-lang.org/"
    },
    {
      "name": "pari/gp",
      "source": "https://en.wikipedia.org/wiki/PARI/GP",
      "about": "PARI/GP is a computer algebra system with the main aim of facilitating number theory computations. Versions 2.1.0 and higher are distributed under the GNU General Public License. It runs on most common operating systems.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://pari.math.u-bordeaux.fr/"
    },
    {
      "name": "pascal",
      "source": "https://en.wikipedia.org/wiki/Pascal_(programming_language)",
      "about": "Pascal is an imperative and procedural programming language, designed by Niklaus Wirth as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named in honour of the French mathematician, philosopher and physicist Blaise Pascal.",
      "first_release": "1970",
      "types": "Static, strong, safe",
      "paradigms": "Imperative, structured",
      "website": ""
    },
    {
      "name": "pascal script",
      "source": "https://en.wikipedia.org/wiki/Pascal_Script",
      "about": "Pascal Script is a scripting language based on the programming language Pascal that facilitates automated runtime control over scriptable applications and server software. It is implemented by a free scripting engine that includes a compiler and an interpreter for byte code.",
      "first_release": "2000",
      "types": "Strong",
      "paradigms": "Procedural, object-oriented, scripting",
      "website": ""
    },
    {
      "name": "pcastl",
      "source": "https://en.wikipedia.org/wiki/PCASTL",
      "about": "The PCASTL (an acronym for by Parent and Childset Accessible Syntax Tree Language) is an interpreted high-level programming language. It was created in 2008 by Philippe Choquette.[1] The PCASTL is designed to ease the writing of self-modifying code. The language has reserved words parent and childset to access the nodes of the syntax tree of the currently written code.[2]",
      "first_release": "2008",
      "types": "",
      "paradigms": "imperative, reflective",
      "website": "http://www.pcosmos.ca/pcastl/"
    },
    {
      "name": "pcf",
      "source": "https://en.wikipedia.org/wiki/Programming_language_for_Computable_Functions",
      "about": "In computer science, Programming Computable Functions' (PCF) is a typed functional language introduced by Gordon Plotkin in 1977, based on previous unpublished material by Dana Scott.[note 1] It can be considered to be an extended version of the typed lambda calculus or a simplified version of modern typed functional languages such as ML or Haskell.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "pearl",
      "source": "https://en.wikipedia.org/wiki/PEARL_(programming_language)",
      "about": "PEARL, or Process and experiment automation realtime language, is a computer programming language designed for multitasking and real-time programming. Being a high-level language, it is fairly cross-platform. Since 1977, the language has been going under several standardization steps by the Deutsches Institut für Normung. The current version is PEARL-90, which was standardized in 1998 as DIN 66253-2.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "peoplecode",
      "source": "https://en.wikipedia.org/wiki/PeopleCode",
      "about": "PeopleCode is a proprietary object-oriented programming language used to express business logic for PeopleSoft applications. Syntactically, PeopleCode is similar to other programming languages, and can be found in both loosely-typed and strongly-typed forms. PeopleCode and its run-time environment is part of the larger PeopleTools framework. PeopleCode has evolved over time and its implementation through the PeopleSoft applications lack consistency. PeopleCode offers some interoperability with the Java programming language. Definition name references, for example, enable you to refer to PeopleTools definitions, such as record definitions or pages, without using hard-coded string literals.[1] Other language features, such as PeopleCode data types and metastrings, reflect the close interaction of PeopleTools and Structured Query Language (SQL). Dot notation, classes and methods in PeopleCode are similar to other object oriented languages, like Java. Object syntax was an important feature of PeopleTools 8.[2]",
      "first_release": "",
      "types": "",
      "paradigms": "multi-paradigm, object-oriented, imperative",
      "website": ""
    },
    {
      "name": "perl",
      "source": "https://en.wikipedia.org/wiki/Perl",
      "about": "Perl is a family of two high-level, general-purpose, interpreted, dynamic programming languages. \"Perl\" refers to Perl 5, but from 2000 to 2019 it also referred to its redesigned \"sister language\", Perl 6, before the latter's name was officially changed to Raku in October 2019.[10][11] Perl 7, continuing from Perl 5, not Perl 6, is also due in 2021.",
      "first_release": "1987",
      "types": "",
      "paradigms": "Multi-paradigm, functional, imperative, object-oriented, class-based, reflective",
      "website": "https://www.perl.org/"
    },
    {
      "name": "pdl",
      "source": "https://en.wikipedia.org/wiki/Perl_Data_Language",
      "about": "Perl Data Language (abbreviated PDL) is a set of free software array programming extensions to the Perl programming language. PDL extends the data structures built into Perl, to include large multidimensional arrays, and adds functionality to manipulate those arrays as vector objects. It also provides tools for image processing, machine learning, computer modeling of physical systems, and graphical plotting and presentation. Simple operations are automatically vectorized across complete arrays, and higher-dimensional operations (such as matrix multiplication) are supported.",
      "first_release": "1996",
      "types": "",
      "paradigms": "Array",
      "website": "http://pdl.perl.org/"
    },
    {
      "name": "pharo",
      "source": "https://en.wikipedia.org/wiki/Pharo",
      "about": "Pharo is an open source dynamic and reflective language which is inspired by the programming language Smalltalk. Pharo offers several live programming features such as immediate object manipulation, live update and hot recompiling.",
      "first_release": "2008",
      "types": "",
      "paradigms": "",
      "website": "https://pharo.org/"
    },
    {
      "name": "php",
      "source": "https://en.wikipedia.org/wiki/PHP",
      "about": "PHP is a general-purpose scripting language especially suited to web development.[5] It was originally created by Danish-Canadian programmer Rasmus Lerdorf in 1994.[6] The PHP reference implementation is now produced by The PHP Group.[7] PHP originally stood for Personal Home Page,[6] but it now stands for the recursive initialism PHP: Hypertext Preprocessor.[8]",
      "first_release": "1995",
      "types": "Dynamic, weak, Gradual, [3]",
      "paradigms": "Imperative, functional, object-oriented, procedural, reflective",
      "website": "https://www.php.net/"
    },
    {
      "name": "pico",
      "source": "https://en.wikipedia.org/wiki/Pico_(programming_language)",
      "about": "Pico is a programming language developed at the Software Languages Lab at Vrije Universiteit Brussel. The language was created to introduce the essentials of programming to non-computer science students.",
      "first_release": "1997",
      "types": "",
      "paradigms": "Reflective, procedural",
      "website": "http://pico.vub.ac.be/"
    },
    {
      "name": "picolisp",
      "source": "https://en.wikipedia.org/wiki/Picolisp",
      "about": "PicoLisp is a programming language, a dialect of the language Lisp. It runs on operating systems including Linux and others that are Portable Operating System Interface (POSIX) compliant. Its most prominent features are simplicity and minimalism. It is built on one internal data type: a cell. On the language level, a programmer can use three different data types (numbers, symbols, and lists) being represented by cells and differentiated by bits at the end of the cell.[2] It is free and open-source software released under an MIT License (X11).",
      "first_release": "1988",
      "types": "duck, dynamic, strong",
      "paradigms": "Functional, procedural, object-oriented, declarative, reflective, meta",
      "website": "http://picolisp.com/"
    },
    {
      "name": "pict",
      "source": "https://en.wikipedia.org/wiki/Pict_(programming_language)",
      "about": "Pict is a statically typed programming language, one of the very few based on the π-calculus. Work on the language began at the University of Edinburgh in 1992, and development has been more or less dormant since 1998. The language is still at an experimental stage.",
      "first_release": "",
      "types": "Static",
      "paradigms": "Concurrent",
      "website": "https://www.cis.upenn.edu/~bcpierce/papers/pict/Html/Pict.html"
    },
    {
      "name": "pike",
      "source": "https://en.wikipedia.org/wiki/Pike_(programming_language)",
      "about": "A MUD (/mʌd/; originally multi-user dungeon, with later variants multi-user dimension and multi-user domain)[1][2] is a multiplayer real-time virtual world, usually text-based. MUDs combine elements of role-playing games, hack and slash, player versus player, interactive fiction, and online chat. Players can read or view descriptions of rooms, objects, other players, non-player characters, and actions performed in the virtual world. Players typically interact with each other and the world by typing commands that resemble a natural language.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "pilot",
      "source": "https://en.wikipedia.org/wiki/PILOT",
      "about": "Programmed Inquiry, Learning, or Teaching (PILOT) is a simple high-level programming language developed in the 1960s.[1] Like its younger sibling LOGO, it was an early foray into the technology of computer-assisted instruction.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "pipelines",
      "source": "https://en.wikipedia.org/wiki/Hartmann_pipeline",
      "about": "CMS Pipelines implements the pipeline concept under the VM/CMS operating system. The programs in a pipeline operate on a sequential stream of records. A program writes records that are read by the next program in the pipeline. Any program can be combined with any other because reading and writing is done through a device independent interface.",
      "first_release": "1986",
      "types": "",
      "paradigms": "Dataflow programming",
      "website": "http://vm.marist.edu/~pipeline"
    },
    {
      "name": "pizza",
      "source": "https://en.wikipedia.org/wiki/Pizza_(programming_language)",
      "about": "Pizza is an open-source superset of Java 1.4, prior to the introduction of generics for the Java programming language. In addition to its own solution for adding generics to the language, Pizza also added function pointers and algebraic types with case classes and pattern matching.",
      "first_release": "",
      "types": "",
      "paradigms": "generics, algebraic types",
      "website": "http://pizzacompiler.sourceforge.net/"
    },
    {
      "name": "pl-11",
      "source": "https://en.wikipedia.org/wiki/PL-11",
      "about": "PL-11 is a high-level machine-oriented programming language for the PDP-11, developed by R.D. Russell of CERN in 1971. Written in Fortran IV, it is similar to PL360 and is cross-compiled on other machines.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "pl/0",
      "source": "https://en.wikipedia.org/wiki/PL/0",
      "about": "PL/0 is a programming language, intended as an educational programming language, that is similar to but much simpler than Pascal, a general-purpose programming language. It serves as an example of how to construct a compiler. It was originally introduced in the book, Algorithms + Data Structures = Programs, by Niklaus Wirth in 1976. It features quite limited language constructs: there are no real numbers, very few basic arithmetic operations and no control-flow constructs other than \"if\" and \"while\" blocks. While these limitations make writing real applications in this language impractical, it helps the compiler remain compact and simple.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "pl/b",
      "source": "https://en.wikipedia.org/wiki/Programming_Language_for_Business",
      "about": "Programming Language for Business or PL/B is a business-oriented programming language originally called DATABUS and designed by Datapoint in 1972[2] as an alternative to COBOL because Datapoint's 8-bit computers could not fit COBOL into their limited memory, and because COBOL did not at the time have facilities to deal with Datapoint's built-in keyboard and screen.",
      "first_release": "1972",
      "types": "Strong, [1], static",
      "paradigms": "Procedural, imperative",
      "website": ""
    },
    {
      "name": "pl/c",
      "source": "https://en.wikipedia.org/wiki/PL/C",
      "about": "PL/C is an instructional dialect of the PL/I computer programming language, developed at Cornell University in the 1970s.",
      "first_release": "1973",
      "types": "strong",
      "paradigms": "procedural, imperative, structured",
      "website": ""
    },
    {
      "name": "pl/i",
      "source": "https://en.wikipedia.org/wiki/PL/I",
      "about": "PL/I (Programming Language One, pronounced /piː ɛl wʌn/ and sometimes written PL/1)[2] is a procedural, imperative computer programming language developed and published by IBM. It is designed for scientific, engineering, business and system programming. It has been used by academic, commercial and industrial organizations since it was introduced in the 1960s, and is still used.[3]",
      "first_release": "1964",
      "types": "",
      "paradigms": "Procedural, imperative, structured",
      "website": "http://bitsavers.trailing-edge.com/pdf/ibm/360/pli/"
    },
    {
      "name": "pl/m",
      "source": "https://en.wikipedia.org/wiki/PL/M",
      "about": "The PL/M programming language (an acronym of Programming Language for Microcomputers[2][3]) is a high-level language conceived and developed by Gary Kildall[2][3][4][1] in 1973[2][3] for Hank Smith[2][3] at Intel for its microprocessors.",
      "first_release": "1973",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "pl/p",
      "source": "https://en.wikipedia.org/wiki/PL/P",
      "about": "The PL/P programming language (an acronym of Programming Language for Prime (computers)) is a mid-level programming language developed by Prime Computer to serve as their second primary system programming language after Fortran IV. PL/P was a subset of PL/I.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "pl/sql",
      "source": "https://en.wikipedia.org/wiki/PL/SQL",
      "about": "PL/SQL (Procedural Language for SQL) is Oracle Corporation's procedural extension for SQL and the Oracle relational database. PL/SQL is available in Oracle Database (since version 6 - stored PL/SQL procedures/functions/packages/triggers since version 7), Times Ten in-memory database (since version 11.2.1), and IBM DB 2 (since version 9.7).[1] Oracle Corporation usually extends PL/SQL functionality with each successive release of the Oracle Database.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "pl360",
      "source": "https://en.wikipedia.org/wiki/PL360",
      "about": "PL360 (or PL/360) is a system programming language designed by Niklaus Wirth and written by Niklaus Wirth, Joseph W. Wells, Jr., and Edwin Satterthwaite, Jr. for the IBM System/360 computer at Stanford University. A description of PL360 was published in early 1968, although the implementation was probably completed before Wirth left Stanford in 1967.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "planc",
      "source": "https://en.wikipedia.org/wiki/PLANC",
      "about": "PLANC (pronounced as \"plank\") is a high level computer programming language. The acronym stands for Programming LAnguage for Nd Computers.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "plankalkül",
      "source": "https://en.wikipedia.org/wiki/Plankalk%C3%BCl",
      "about": "Plankalkül (German pronunciation: [ˈplaːnkalkyːl]) is a programming language designed for engineering purposes by Konrad Zuse between 1942 and 1945. It was the first high-level programming language to be designed for a computer.",
      "first_release": "1948",
      "types": "",
      "paradigms": "Procedural",
      "website": ""
    },
    {
      "name": "planner",
      "source": "https://en.wikipedia.org/wiki/Planner_(programming_language)",
      "about": "Planner (often seen in publications as \"PLANNER\" although it is not an acronym) is a programming language designed by Carl Hewitt at MIT, and first published in 1969. First, subsets such as Micro-Planner and Pico-Planner were implemented, and then essentially the whole language was implemented as Popler by Julian Davies at the University of Edinburgh in the POP-2 programming language.[1] Derivations such as QA4, Conniver, QLISP and Ether (see scientific community metaphor) were important tools in artificial intelligence research in the 1970s, which influenced commercial developments such as Knowledge Engineering Environment (KEE) and Automated Reasoning Tool (ART).",
      "first_release": "1969",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "plex",
      "source": "https://en.wikipedia.org/wiki/PLEX_(programming_language)",
      "about": "PLEX (Programming Language for EXchanges) is a special-purpose, concurrent, real-time programming language. The proprietary PLEX language is closely tied to the architecture of Ericsson's AXE telephone exchanges which it was designed to control. PLEX was developed by Göran Hemdahl at Ericsson in the 1970s,[1] and it has been continuously evolving since then.[2] PLEX was described in 2008 as \"a cross between Fortran and a macro assembler.\"[3]",
      "first_release": "1970",
      "types": "",
      "paradigms": "procedural, imperative",
      "website": ""
    },
    {
      "name": "plexil",
      "source": "https://en.wikipedia.org/wiki/PLEXIL",
      "about": "PLEXIL (Plan Execution Interchange Language) is an open source technology for automation, created and currently in development by NASA.",
      "first_release": "2005",
      "types": "Static, unsafe, nominative",
      "paradigms": "Multi-paradigm",
      "website": "http://plexil.sourceforge.net/"
    },
    {
      "name": "plus",
      "source": "https://en.wikipedia.org/wiki/Plus_(programming_language)",
      "about": "Plus is a \"Pascal-like\" system implementation language from the University of British Columbia (UBC), Canada, based on the SUE[1] system language developed at the University of Toronto, c. 1971.[2]",
      "first_release": "1976",
      "types": "static, strong, safe",
      "paradigms": "imperative, structured",
      "website": ""
    },
    {
      "name": "pop-11",
      "source": "https://en.wikipedia.org/wiki/POP-11",
      "about": "POP-11 is a reflective, incrementally compiled programming language with many of the features of an interpreted language. It is the core language of the Poplog programming environment developed originally by the University of Sussex, and recently in the School of Computer Science at the University of Birmingham, which hosts the main Poplog website. Core source files are also available on GitHub.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "pop-2",
      "source": "https://en.wikipedia.org/wiki/POP-2",
      "about": "POP-2 (also referred to as POP2) is a programming language developed around 1970 from the earlier language POP-1 (developed by Robin Popplestone in 1968, originally named COWSEL) by Robin Popplestone and Rod Burstall at the University of Edinburgh. It drew roots from many sources: the languages LISP and ALGOL 60, and theoretical ideas from Peter J. Landin. It used an incremental compiler, which gave it some of the flexibility of an interpreted language, including allowing new function definitions at run time and modification of function definitions while a program was running (both of which are features of dynamic compilation), without the overhead of an interpreted language.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "postscript",
      "source": "https://en.wikipedia.org/wiki/PostScript",
      "about": "PostScript (PS) is a page description language in the electronic publishing and desktop publishing business. It is a dynamically typed, concatenative programming language. It was created at Adobe Systems by John Warnock, Charles Geschke, Doug Brotz, Ed Taft and Bill Paxton from 1982 to 1984.",
      "first_release": "1982",
      "types": "",
      "paradigms": "Multi-paradigm, stack-based, procedural",
      "website": ""
    },
    {
      "name": "portable",
      "source": "https://en.wikipedia.org/wiki/Amiga_E",
      "about": "Amiga E, or very often simply E, is a programming language created by Wouter van Oortmerssen on the Amiga. He has since moved on to develop the SHEEP programming language for the new AmigaDE platform and the CryScript language (also known as DOG) used during the development of the video game Far Cry.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "pov-ray sdl",
      "source": "https://en.wikipedia.org/wiki/POV-Ray",
      "about": "The Persistence of Vision Ray Tracer, most commonly acronymed as POV-Ray, is a cross-platform ray-tracing program that generates images from a text-based scene description. It was originally based on DKBTrace, written by David Kirk Buck and Aaron A. Collins for Amiga computers. There are also influences from the earlier Polyray[6] raytracer because of contributions from its author, Alexander Enzmann. POV-Ray is free and open-source software, with the source code available under the AGPLv3.",
      "first_release": "1991",
      "types": "",
      "paradigms": "",
      "website": "http://www.povray.org/"
    },
    {
      "name": "powerhouse",
      "source": "https://en.wikipedia.org/wiki/Powerhouse_(programming_language)",
      "about": "PowerHouse is a trademarked name for a byte-compiled fourth-generation programming language (or 4GL) originally produced by Quasar Corporation (later renamed Cognos Incorporated) for the Hewlett-Packard HP3000 mini-computer, as well as Data General and DEC VAX VMS computing products. It was initially composed of five components:",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "https://teamblue.unicomsi.com/products/powerhouse-4gl/"
    },
    {
      "name": "powerbuilder",
      "source": "https://en.wikipedia.org/wiki/PowerBuilder",
      "about": "PowerBuilder is an integrated development environment owned by SAP since the acquisition of Sybase in 2010. On July 5, 2016, SAP and Appeon entered into an agreement whereby Appeon would be responsible for developing, selling, and supporting PowerBuilder.[1]",
      "first_release": "1992",
      "types": "",
      "paradigms": "",
      "website": "http://www.appeon.com/"
    },
    {
      "name": "powershell",
      "source": "https://en.wikipedia.org/wiki/PowerShell",
      "about": "PowerShell is a task automation and configuration management framework from Microsoft, consisting of a command-line shell and the associated scripting language. Initially a Windows component only, known as Windows PowerShell, it was made open-source and cross-platform on 18 August 2016 with the introduction of PowerShell Core.[5] The former is built on the .NET Framework, the latter on .NET Core.",
      "first_release": "2006",
      "types": "Strong, safe, implicit, dynamic",
      "paradigms": "Imperative, pipeline, object-oriented, functional, reflective",
      "website": "https://microsoft.com/powershell"
    },
    {
      "name": "ppl",
      "source": "https://en.wikipedia.org/wiki/Polymorphic_Programming_Language",
      "about": "The Polymorphic Programming Language (PPL) was developed in 1969 at Harvard University by Thomas A. Standish. It is an interactive, extensible language with a base language similar to the language APL.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "processing",
      "source": "https://en.wikipedia.org/wiki/Processing_(programming_language)",
      "about": "Processing is a free graphical library and integrated development environment (IDE) built for the electronic arts, new media art, and visual design communities with the purpose of teaching non-programmers the fundamentals of computer programming in a visual context.",
      "first_release": "2001",
      "types": "",
      "paradigms": "Object-oriented",
      "website": "http://processing.org/"
    },
    {
      "name": "processing.js",
      "source": "https://en.wikipedia.org/wiki/Processing.js",
      "about": "Processing.js is a JavaScript port of Processing, a programming language designed to write visualisations, images, and interactive content. It allows web browsers to display animations, visual applications, games and other graphical rich content without the need for a Java applet or Flash plugin.",
      "first_release": "2008",
      "types": "",
      "paradigms": "",
      "website": "http://processingjs.org/"
    },
    {
      "name": "prograph",
      "source": "https://en.wikipedia.org/wiki/Prograph",
      "about": "Prograph is a visual, object-oriented, dataflow, multiparadigm programming language that uses iconic symbols to represent actions to be taken on data. Commercial Prograph software development environments such as Prograph Classic and Prograph CPX were available for the Apple Macintosh and Windows platforms for many years but were eventually withdrawn from the market in the late 1990s. Support for the Prograph language on macOS has recently reappeared with the release of the Marten software development environment.[1]",
      "first_release": "1983",
      "types": "",
      "paradigms": "multi-paradigm, object-oriented, visual, dataflow",
      "website": ""
    },
    {
      "name": "proiv",
      "source": "https://en.wikipedia.org/wiki/PROIV",
      "about": "PROIV (/proʊ,fʊər/) is a low code development platform, developed and sold by NorthgateArinso, part of the Northgate Information Solutions Group. It has an active community of around 2500 developers and end-users worldwide, ranging from consultants to large multinationals, finance institutions, tax authorities, retailers, engineering companies, media operators and software houses.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "project verona",
      "source": "https://en.wikipedia.org/wiki/Project_Verona",
      "about": "Project Verona is an experimental research programming language developed by Microsoft and aimed at dealing with memory situations to make other programming languages safer.[2][1]",
      "first_release": "2019",
      "types": "",
      "paradigms": "",
      "website": "https://www.microsoft.com/en-us/research/project/project-verona"
    },
    {
      "name": "prolog",
      "source": "https://en.wikipedia.org/wiki/Prolog",
      "about": "Prolog is a logic programming language associated with artificial intelligence and computational linguistics.[1][2][3]",
      "first_release": "1972",
      "types": "",
      "paradigms": "Logic programming",
      "website": "https://www.iso.org/standard/21413.html"
    },
    {
      "name": "promal",
      "source": "https://en.wikipedia.org/wiki/PROMAL",
      "about": "PROMAL (PROgrammer's Microapplication Language) is a structured programming language from Systems Management Associates for MS-DOS, Commodore 64, and Apple II. PROMAL features simple syntax, no line numbers, long variable names, functions and procedures with argument passing, real number type, arrays, strings, pointer, and a built-in I/O library. Like ABC and Python, indentation is part of the language syntax.",
      "first_release": "1984",
      "types": "",
      "paradigms": "Imperative, procedural, structured",
      "website": ""
    },
    {
      "name": "promela",
      "source": "https://en.wikipedia.org/wiki/Promela",
      "about": "PROMELA (Process or Protocol Meta Language) is a verification modeling language introduced by Gerard J. Holzmann. The language allows for the dynamic creation of concurrent processes to model, for example, distributed systems. In PROMELA models, communication via message channels can be defined to be synchronous (i.e., rendezvous), or asynchronous (i.e., buffered). PROMELA models can be analyzed with the SPIN model checker, to verify that the modeled system produces the desired behavior. An implementation verified with Isabelle/HOL is also available, as part of the Computer Aided Verification of Automata project.[1] Files written in Promela traditionally have a .pml file extension.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "prose modeling language",
      "source": "https://en.wikipedia.org/wiki/PROSE_modeling_language",
      "about": "Author Joseph Thames, now deceased (2019), has left us with his latest version of PROSE, called FortranCalculus. It is freeware that can be downloaded from https://goal-driven.net/apps/fc-compiler.html . Joe's www.metacalculus.com website is no longer up. I worked with Joe since ~1975, he will be missed! Thanks, Phil B Brubaker. [1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "protel",
      "source": "https://en.wikipedia.org/wiki/Protel",
      "about": "Protel stands for \"Procedure Oriented Type Enforcing Language\". It is a programming language created by Nortel Networks and used on telecommunications switching systems such as the DMS-100.[1][2] Protel-2 is the object-oriented version of Protel.[3][4]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "providex",
      "source": "https://en.wikipedia.org/wiki/ProvideX",
      "about": "ProvideX is a computer language and development environment derived from Business Basic (a business oriented derivative of BASIC) in the mid-1980s.",
      "first_release": "1992",
      "types": "",
      "paradigms": "",
      "website": "http://www.pvxplus.com/"
    },
    {
      "name": "pro*c",
      "source": "https://en.wikipedia.org/wiki/Pro*C",
      "about": "Pro*C (also known as Pro*C/C++) is an embedded SQL programming language used by Oracle Database DBMSes. Pro*C uses either C or C++ as its host language. During compilation, the embedded SQL statements are interpreted by a precompiler and replaced by C or C++ function calls to their respective SQL library. The output from the Pro*C precompiler is standard C or C++ code that is then compiled by any one of several C or C++ compilers into an executable.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "pure",
      "source": "https://en.wikipedia.org/wiki/Pure_(programming_language)",
      "about": "Pure, successor to the equational language Q, is a dynamically typed, functional programming language based on term rewriting. It has facilities for user-defined operator syntax, macros, arbitrary-precision arithmetic (multiple-precision numbers), and compiling to native code through the LLVM. Pure is free and open-source software distributed (mostly) under the GNU Lesser General Public License version 3 or later.",
      "first_release": "2008",
      "types": "Strong, dynamic",
      "paradigms": "Functional, declarative, term rewriting",
      "website": "https://agraef.github.io/pure-lang/"
    },
    {
      "name": "pure data",
      "source": "https://en.wikipedia.org/wiki/Pure_Data",
      "about": "Pure Data (Pd) is a visual programming language developed by Miller Puckette in the 1990s for creating interactive computer music and multimedia works. While Puckette is the main author of the program, Pd is an open-source project with a large developer base working on new extensions. It is released under a license similar to the BSD license. It runs on Linux, Mac OS X, iOS, Android and Windows. Ports exist for FreeBSD and IRIX.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://puredata.info/"
    },
    {
      "name": "purescript",
      "source": "https://en.wikipedia.org/wiki/PureScript",
      "about": "PureScript is a strongly-typed, purely-functional programming language that compiles to JavaScript. It can be used to develop web applications, server side apps, and also desktop applications with use of Electron. Its syntax is mostly comparable to that of Haskell. In addition, it introduces row polymorphism and extensible records.[2] Also, contrary to Haskell, PureScript adheres to a strict evaluation strategy.",
      "first_release": "2013",
      "types": "Inferred, static, strong",
      "paradigms": "Functional",
      "website": "http://www.purescript.org/"
    },
    {
      "name": "python",
      "source": "https://en.wikipedia.org/wiki/Python_(programming_language)",
      "about": "Python is an interpreted, high-level and general-purpose programming language. Python's design philosophy emphasizes code readability with its notable use of significant indentation. Its language constructs and object-oriented approach aim to help programmers write clear, logical code for small and large-scale projects.[29]",
      "first_release": "1991",
      "types": "Duck, dynamic, strong typing, [4], gradual, CPython, [5]",
      "paradigms": "Multi-paradigm, functional, imperative, object-oriented, structured, reflective",
      "website": "https://www.python.org/"
    },
    {
      "name": "q",
      "source": "https://en.wikipedia.org/wiki/Q_(programming_language_from_Kx_Systems)",
      "about": "Q is a programming language for array processing, developed by Arthur Whitney. It is proprietary software, commercialized by Kx Systems. Q serves as the query language for kdb+, a disk based and in-memory, column-based database. Kdb+ is based on the language k, a terse variant of the language APL. Q is a thin wrapper around k, providing a more readable, English-like interface.[3]",
      "first_release": "2003",
      "types": "Dynamic, strong",
      "paradigms": "Array, functional",
      "website": "http://code.kx.com/"
    },
    {
      "name": "q#",
      "source": "https://en.wikipedia.org/wiki/Q_Sharp",
      "about": "Q# (pronounced as Q sharp) is a domain-specific programming language used for expressing quantum algorithms.[1] It was initially released to the public by Microsoft as part of the Quantum Development Kit.[2]",
      "first_release": "2017",
      "types": "static, strong",
      "paradigms": "multi-paradigm, quantum, functional, imperative",
      "website": "https://docs.microsoft.com/en-us/quantum"
    },
    {
      "name": "qalb",
      "source": "https://en.wikipedia.org/wiki/Qalb_(programming_language)",
      "about": "قلب (Levantine Arabic: [ʔalb]), transliterated Qalb, Qlb and Alb, is a functional programming language allowing a programmer to write programs completely in Arabic.[1] Its name means heart and is a recursive acronym in Arabic meaning Qlb: a programming language (قلب: لغة برمجة, Qlb: Lughat Barmajah). It was developed in 2012 by Ramsey Nasser, a computer scientist at the Eyebeam Art + Technology Center in New York City, as both an artistic endeavor and as a response to the Anglophone bias in the vast majority of programming languages, which express their fundamental concepts using English words.",
      "first_release": "2012",
      "types": "",
      "paradigms": "Functional",
      "website": "http://qlb-repl.herokuapp.com/"
    },
    {
      "name": "quantum computation language",
      "source": "https://en.wikipedia.org/wiki/Quantum_Computation_Language",
      "about": "Quantum Computation Language (QCL) is one of the first implemented quantum programming languages.[1] The most important feature of QCL is the support for user-defined operators and functions. Its syntax resembles the syntax of the C programming language and its classical data types are similar to primitive data types in C. One can combine classical code and quantum code in the same program.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "qtscript",
      "source": "https://en.wikipedia.org/wiki/QtScript",
      "about": "QtScript is a scripting engine that has been part of the Qt cross-platform application framework since version 4.3.0.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "quakec",
      "source": "https://en.wikipedia.org/wiki/QuakeC",
      "about": "QuakeC is a compiled language developed in 1996 by John Carmack of id Software to program parts of the video game Quake. Using QuakeC, a programmer is able to customize Quake to great extents by adding weapons, changing game logic and physics, and programming complex scenarios. It can be used to control many aspects of the game itself, such as parts of the AI, triggers, or changes in the level. The Quake engine was the only game engine to use QuakeC. Following engines used DLL game modules for customization written in C, and C++ from id Tech 4 on.",
      "first_release": "1996",
      "types": "static, strong",
      "paradigms": "imperative, procedural, structured",
      "website": ""
    },
    {
      "name": "qpl",
      "source": "https://en.wikipedia.org/wiki/Quantum_programming",
      "about": "Quantum programming is the process of assembling sequences of instructions, called quantum programs, that are capable of running on a quantum computer. Quantum programming languages help express quantum algorithms using high-level constructs.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": ".ql",
      "source": "https://en.wikipedia.org/wiki/.QL",
      "about": ".QL (pronounced \"dot-cue-el\") is an object-oriented query language used to retrieve data from relational database management systems. It is reminiscent of the standard query language SQL and the object-oriented programming language Java. .QL is an object-oriented variant of a logical query language called Datalog. Hierarchical data can therefore be naturally queried in .QL in a recursive manner.",
      "first_release": "2007",
      "types": "static, strong",
      "paradigms": "multi-paradigm, logic-paradigm, object-oriented-paradigm",
      "website": ""
    },
    {
      "name": "r",
      "source": "https://en.wikipedia.org/wiki/R_(programming_language)",
      "about": "R is a programming language and free software environment for statistical computing and graphics supported by the R Foundation for Statistical Computing.[6] The R language is widely used among statisticians and data miners for developing statistical software[7] and data analysis.[8] Polls, data mining surveys, and studies of scholarly literature databases show substantial increases in popularity;[9] as of January 2021, R ranks 9th in the TIOBE index, a measure of popularity of programming languages.[10]",
      "first_release": "1993",
      "types": "Dynamic",
      "paradigms": "Multi-paradigm, Array, object-oriented, imperative, functional, procedural, reflective",
      "website": "https://www.r-project.org/"
    },
    {
      "name": "r++",
      "source": "https://en.wikipedia.org/wiki/R%2B%2B",
      "about": "R++ is a rule-based programming language based on C++. The United States patent describes R++ as follows:",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "racket",
      "source": "https://en.wikipedia.org/wiki/Racket_(programming_language)",
      "about": "Racket is a general-purpose, multi-paradigm programming language based on the Scheme dialect of Lisp. It is designed to be a platform for programming language design and implementation.[9] In addition to the core Racket language, Racket is also used to refer to the family of programming languages[10] and set of tools supporting development on and with Racket.[11] Racket is also used for scripting, computer science education, and research.",
      "first_release": "1995",
      "types": "Dynamic, static, strong",
      "paradigms": "Multi-paradigm, functional, imperative, logic, meta, modular, object-oriented, reflective",
      "website": "https://racket-lang.org/"
    },
    {
      "name": "raku",
      "source": "https://en.wikipedia.org/wiki/Raku_(programming_language)",
      "about": "Raku is a member of the Perl family of programming languages.[6] Formerly known as Perl 6, it was renamed in October 2019.[7][8] Raku introduces elements of many modern and historical languages. Compatibility with Perl was not a goal, though a compatibility mode is part of the specification. The design process for Raku began in 2000.",
      "first_release": "2015",
      "types": "Dynamic, gradual",
      "paradigms": "Multi-paradigm",
      "website": "http://raku.org/"
    },
    {
      "name": "rapid",
      "source": "https://en.wikipedia.org/wiki/RAPID",
      "about": "RAPID is a high-level programming language used to control ABB industrial robots. RAPID was introduced along with S4 Control System in 1994 by ABB, superseding the ARLA programming language.",
      "first_release": "1994",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "rapira",
      "source": "https://en.wikipedia.org/wiki/Rapira",
      "about": "Rapira (Russian: Рапира, rapier) is an educational procedural programming language developed in the Soviet Union and implemented on Agat computer, PDP-11 clones (Electronika, DVK, BK series) and Intel-8080/Z80 clones (Korvet). It was an interpreted language with dynamic type system and high level constructions. The language originally had a Russian-based set of keywords, but English and Romanian were added later. Also, it was more elegant and easier to use than existing Pascal implementations of the time[according to whom?].",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "ratfiv",
      "source": "https://en.wikipedia.org/wiki/Ratfiv",
      "about": "Ratfiv is an enhanced version of the Ratfor programming language, a preprocessor for Fortran designed to give it C-like capabilities. Fortran was widely used for scientific programming but had very basic control-flow primitives (\"do\" and \"goto\") and no \"macro\" facility which limited its expressiveness.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "ratfor",
      "source": "https://en.wikipedia.org/wiki/Ratfor",
      "about": "Ratfor (short for Rational Fortran) is a programming language implemented as a preprocessor for Fortran 66. It provides modern control structures, unavailable in Fortran 66, to replace GOTOs and statement numbers.",
      "first_release": "1976",
      "types": "",
      "paradigms": "",
      "website": "http://sepwww.stanford.edu/doku.php?id=sep:software:ratfor"
    },
    {
      "name": "rc",
      "source": "https://en.wikipedia.org/wiki/Rc",
      "about": "rc (for \"run commands\") is the command line interpreter for Version 10 Unix and Plan 9 from Bell Labs operating systems. It resembles the Bourne shell, but its syntax is somewhat simpler. It was created by Tom Duff, who is better known for an unusual C programming language construct (\"Duff's device\").[1]",
      "first_release": "1989",
      "types": "weak",
      "paradigms": "imperative, pipeline",
      "website": "http://doc.cat-v.org/plan_9/4th_edition/papers/rc"
    },
    {
      "name": "reason",
      "source": "https://en.wikipedia.org/wiki/Reason_(programming_language)",
      "about": "Reason, also known as ReasonML, is a syntax extension and toolchain for OCaml created by Jordan Walke, who also created React, at Facebook.[2] Reason offers a syntax familiar to JavaScript programmers, and transpiles to OCaml.[3] Statically typed Reason (or OCaml) code may be compiled to dynamically typed JavaScript using the ReScript compiler.[4]",
      "first_release": "2016",
      "types": "",
      "paradigms": "",
      "website": "https://reasonml.github.io/"
    },
    {
      "name": "rebol",
      "source": "https://en.wikipedia.org/wiki/REBOL",
      "about": "Rebol (/ˈrɛbəl/ REB-əl; historically REBOL) is a cross-platform[6] data exchange language and a multi-paradigm dynamic programming language designed by Carl Sassenrath for network communications and distributed computing. It introduces the concept of dialecting: small, optimized, domain-specific languages for code and data,[6][7] which is also the most notable property of the language according to its designer Carl Sassenrath:",
      "first_release": "1997",
      "types": "dynamic, strong",
      "paradigms": "language oriented programming, data exchange, functional, prototype-based, imperative",
      "website": "http://www.rebol.com/"
    },
    {
      "name": "red",
      "source": "https://en.wikipedia.org/wiki/Red_(programming_language)",
      "about": "Red is a programming language designed to overcome the limitations of the programming language Rebol. Red was introduced in 2011 by Nenad Rakočević, and is both an imperative and functional programming language. Its syntax and general usage overlaps that of the interpreted Rebol language.",
      "first_release": "2011",
      "types": "",
      "paradigms": "imperative, functional, symbolic",
      "website": "https://www.red-lang.org/"
    },
    {
      "name": "redcode",
      "source": "https://en.wikipedia.org/wiki/Core_War",
      "about": "Core War is a 1984 programming game created by D. G. Jones and A. K. Dewdney in which two or more battle programs (called \"warriors\") compete for control of a virtual computer. These battle programs are written in an abstract assembly language called Redcode.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "refal",
      "source": "https://en.wikipedia.org/wiki/REFAL",
      "about": "Refal (\"Recursive functions algorithmic language\"; Russian: РЕФАЛ) \"is a functional programming language oriented toward symbolic computations\", including \"string processing, language translation, [and] artificial intelligence\".[1] It is one of the oldest members of this family, first conceived of in 1966 as a theoretical tool, with the first implementation appearing in 1968. Refal was intended to combine mathematical simplicity with practicality for writing large and sophisticated programs.",
      "first_release": "1968",
      "types": "strong, dynamic",
      "paradigms": "Pattern-matching, term-rewriting",
      "website": "http://www.refal.net/"
    },
    {
      "name": "rexx",
      "source": "https://en.wikipedia.org/wiki/REXX",
      "about": "Rexx (Restructured Extended Executor) is an interpreted programming language developed at IBM by Mike Cowlishaw.[2][3] It is a structured, high-level programming language designed for ease of learning and reading. Proprietary and open source Rexx interpreters exist for a wide range of computing platforms; compilers exist for IBM mainframe computers.[4]",
      "first_release": "1979",
      "types": "",
      "paradigms": "multiparadigm, procedural, structured",
      "website": ""
    },
    {
      "name": "rlab",
      "source": "https://en.wikipedia.org/wiki/Rlab",
      "about": "Rlab is an interactive, interpreted numerical computation program and its core programming language, written by Ian Searle. Rlab (the language) is very high level and is intended to provide fast prototyping and program development, as well as easy data-visualization, and processing.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "rockstar",
      "source": "https://codewithrockstar.com/",
      "about": "",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "roop",
      "source": "https://en.wikipedia.org/wiki/ROOP_(programming_language)",
      "about": "ROOP is a multiparadigm programming language targeted at AI applications created at the Chengdu University of China. It combines rule-based, procedural, logical and object-oriented programming techniques.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "rpg",
      "source": "https://en.wikipedia.org/wiki/IBM_RPG",
      "about": "RPG is a modern proprietary high-level programming language (HLL) for business applications, popular on the IBM i operating system on IBM Power Systems hardware. The current version, RPG IV, a.k.a. ILE RPG, provides a modern programming environment. IBM has evolved the language, providing new capabilities, to take advantage of technologies that have grown up in the marketplace.",
      "first_release": "1959",
      "types": "Strong, static",
      "paradigms": "Multi-paradigm",
      "website": ""
    },
    {
      "name": "rpl",
      "source": "https://en.wikipedia.org/wiki/RPL_(programming_language)",
      "about": "RPL[1] is a handheld calculator operating system and application programming language used on Hewlett-Packard's scientific graphing RPN (Reverse Polish Notation) calculators of the HP 28, 48, 49 and 50 series, but it is also usable on non-RPN calculators, such as the 38, 39 and 40 series.",
      "first_release": "1986",
      "types": "",
      "paradigms": "stack, structured, object-oriented",
      "website": ""
    },
    {
      "name": "rsl",
      "source": "https://en.wikipedia.org/wiki/Robot_Battle",
      "about": "Robot Battle is a programming game for Microsoft Windows where players design and code adaptable battling robots. Robot Battle takes strategy rather than reflexes, accuracy, or timing to succeed. What differentiates one robot from the next is its programming, for which the player is responsible. The game is inspired by the similar game RobotWar.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "rtl/2",
      "source": "https://en.wikipedia.org/wiki/RTL/2",
      "about": "RTL/2 (Real-Time Language) is a discontinued high-level programming language for use in real-time computing, developed at Imperial Chemical Industries, Ltd. (ICI), by J.G.P. Barnes. It was originally used internally in ICI but was distributed by SPL International in 1974.[1] It was based on concepts from ALGOL 68, and intended to be small and simple.[2][3][4] RTL/2 was standardised in 1980 by the British Standards Institution.[5]",
      "first_release": "1972",
      "types": "static, strong, safe, structural",
      "paradigms": "Multi-paradigm, imperative, structured, real-time",
      "website": ""
    },
    {
      "name": "ruby",
      "source": "https://en.wikipedia.org/wiki/Ruby_(programming_language)",
      "about": "Ruby is an interpreted, high-level, general-purpose programming language. It was designed and developed in the mid-1990s by Yukihiro \"Matz\" Matsumoto in Japan.",
      "first_release": "1995",
      "types": "Duck, dynamic, strong",
      "paradigms": "Multi-paradigm, functional, imperative, object-oriented, reflective",
      "website": "https://www.ruby-lang.org/"
    },
    {
      "name": "rust",
      "source": "https://en.wikipedia.org/wiki/Rust_(programming_language)",
      "about": "Rust is a multi-paradigm programming language designed for performance and safety, especially safe concurrency.[15][16] Rust is syntactically similar to C++,[17] but can guarantee memory safety by using a borrow checker to validate references.[18] Rust achieves memory safety without garbage collection, and reference counting is optional.[19][20]",
      "first_release": "2010",
      "types": "Affine, inferred, nominal, static, strong",
      "paradigms": "Multi-paradigm, concurrent, functional, generic, imperative, structured",
      "website": "http://www.rust-lang.org/"
    },
    {
      "name": "s",
      "source": "https://en.wikipedia.org/wiki/S_(programming_language)",
      "about": "S is a statistical programming language developed primarily by John Chambers and (in earlier versions) Rick Becker and Allan Wilks of Bell Laboratories. The aim of the language, as expressed by John Chambers, is \"to turn ideas into software, quickly and faithfully\".[1]",
      "first_release": "1976",
      "types": "dynamic, strong",
      "paradigms": "multi-paradigm, imperative, object oriented",
      "website": "https://web.archive.org/web/20181014111802/http://ect.bell-labs.com/sl/S/"
    },
    {
      "name": "s2",
      "source": "https://en.wikipedia.org/wiki/S2_(programming_language)",
      "about": "S2 (Style System 2) is an object-oriented programming language developed in the late 1990s by Brad Fitzpatrick, Martin \"Mart\" Atkins, and others for the online journaling service LiveJournal in order to allow users full control over the appearance of their pages. S2 source code is compiled into Perl, which the webserver can then execute directly for individual web page requests.",
      "first_release": "1999",
      "types": "",
      "paradigms": "Object-oriented",
      "website": "http://www.livejournal.com/doc/s2"
    },
    {
      "name": "s3",
      "source": "https://en.wikipedia.org/wiki/S3_(programming_language)",
      "about": "S3 is a structured, imperative high-level computer programming language.[1] It was developed by the UK company International Computers Limited (ICL) for its 2900 Series mainframes. It is a system programming language with syntax influenced by ALGOL 68 but with data types and operators aligned to those offered by the 2900 Series. It was the implementation language of the operating system VME.",
      "first_release": "",
      "types": "",
      "paradigms": "Structured, imperative",
      "website": ""
    },
    {
      "name": "s-lang",
      "source": "https://en.wikipedia.org/wiki/S-Lang_(programming_language)",
      "about": "The S-Lang programming library is a software library for Unix, Windows, VMS, OS/2, and Mac OS X. It provides routines for embedding an interpreter for the S-Lang scripting language, and components to facilitate the creation of text-based applications.[3] The latter class of functions include routines for constructing and manipulating keymaps, an interactive line-editing facility, and both low and high-level screen/terminal management functions. It is distributed under the terms of the GNU General Public License.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.jedsoft.org/slang/"
    },
    {
      "name": "s-plus",
      "source": "https://en.wikipedia.org/wiki/S-PLUS",
      "about": "S-PLUS is a commercial implementation of the S programming language sold by TIBCO Software Inc.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "sa-c",
      "source": "https://en.wikipedia.org/wiki/SA-C_(programming_language)",
      "about": "Single Assignment C (SA-C) (pronounced \"sassy\") is a member of the C programming language family designed to be directly and intuitively translatable into circuits, including FPGAs. To ease translation, SA-C does not include pointers and arithmetics thereon. To retain most of the expressiveness of C, SA-C instead features true n-dimensional arrays as first-class objects of the language.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "sabretalk",
      "source": "https://en.wikipedia.org/wiki/SabreTalk",
      "about": "SabreTalk is a discontinued dialect of PL/I for the S/360 IBM mainframes running the TPF platform. SabreTalk was developed jointly by American Airlines, Eastern Air Lines and IBM. SabreTalk is known as PL/TPF (Programming Language for TPF).[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "sail",
      "source": "https://en.wikipedia.org/wiki/SAIL_(programming_language)",
      "about": "SAIL, the Stanford Artificial Intelligence Language, was developed by Dan Swinehart and Bob Sproull of the Stanford AI Lab in 1970. It was originally a large ALGOL 60-like language for the PDP-10 and DECSYSTEM-20.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "sas",
      "source": "https://en.wikipedia.org/wiki/SAS_System",
      "about": "SAS (previously \"Statistical Analysis System\")[1] is a statistical software suite developed by SAS Institute for data management, advanced analytics, multivariate analysis, business intelligence, criminal investigation,[2] and predictive analytics.",
      "first_release": "1976",
      "types": "",
      "paradigms": "",
      "website": "https://www.sas.com/en_us/home.html"
    },
    {
      "name": "sasl",
      "source": "https://en.wikipedia.org/wiki/SASL_(programming_language)",
      "about": "SASL (from St Andrews Static Language, alternatively St Andrews Standard Language) is a purely functional programming language developed by David Turner at the University of St Andrews in 1972, based on the applicative subset of ISWIM.[1] In 1976 Turner redesigned and reimplemented it as a non-strict (lazy) language.[2] In this form it was the foundation of Turner's later languages KRC and Miranda, but SASL appears to be untyped whereas Miranda has polymorphic types.",
      "first_release": "1972",
      "types": "",
      "paradigms": "functional",
      "website": ""
    },
    {
      "name": "sather",
      "source": "https://en.wikipedia.org/wiki/Sather",
      "about": "For people with the surname, see Sather (surname).",
      "first_release": "1990",
      "types": "static, strong",
      "paradigms": "object-oriented, functional",
      "website": "https://www.gnu.org/software/sather/"
    },
    {
      "name": "sawzall",
      "source": "https://en.wikipedia.org/wiki/Sawzall_(programming_language)",
      "about": "Sawzall is a procedural domain-specific programming language, used by Google to process large numbers of individual log records. Sawzall was first described in 2003,[1] and the szl runtime was open-sourced in August 2010.[2] However, since the MapReduce table aggregators have not been released,[3] the open-sourced runtime is not useful for large-scale data analysis of multiple log files off the shelf. Sawzall has been replaced by Lingo (logs in Go) for most purposes within Google.[4]",
      "first_release": "2003",
      "types": "",
      "paradigms": "",
      "website": "https://code.google.com/archive/p/szl/"
    },
    {
      "name": "scala",
      "source": "https://en.wikipedia.org/wiki/Scala_(programming_language)",
      "about": "Scala (/ˈskɑːlɑː/ SKAH-lah)[7] is a general-purpose programming language providing support for both object-oriented programming and functional programming. The language has a strong static type system. Designed to be concise,[8] many of Scala's design decisions are aimed to address criticisms of Java.[6]",
      "first_release": "2004",
      "types": "Inferred, static, strong, structural",
      "paradigms": "Multi-paradigm, concurrent, functional, imperative, object-oriented",
      "website": "https://www.scala-lang.org/"
    },
    {
      "name": "scheme",
      "source": "https://en.wikipedia.org/wiki/Scheme_(programming_language)",
      "about": "Scheme is a minimalist dialect of the Lisp family of programming languages. Scheme consists of a small standard core with several tools for language extension.[1]",
      "first_release": "1975",
      "types": "Dynamic, latent, strong",
      "paradigms": "Multi-paradigm, functional, imperative, meta",
      "website": "http://www.scheme-reports.org/"
    },
    {
      "name": "scilab",
      "source": "https://en.wikipedia.org/wiki/Scilab",
      "about": "Scilab is a free and open-source, cross-platform numerical computational package and a high-level, numerically oriented programming language. It can be used for signal processing, statistical analysis, image enhancement, fluid dynamics simulations, numerical optimization, and modeling, simulation of explicit and implicit dynamical systems and (if the corresponding toolbox is installed) symbolic manipulations.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "https://www.scilab.org/"
    },
    {
      "name": "scratch",
      "source": "https://en.wikipedia.org/wiki/Scratch_(programming_language)",
      "about": "Scratch is a block-based visual programming language and website targeted primarily at children 8-16 as an educational tool for coding.[5][6] Users of the site can create projects on the web using a block-like interface. The service is developed by the MIT Media Lab, has been translated into 70+ languages, and is used in most parts of the world.[7] Scratch is taught and used in after-school centers, schools, and colleges, as well as other public knowledge institutions. As of January 2021, community statistics on the language's official website show more than 67 million projects shared by over 64 million users, and almost 38 million monthly website visits.[7]",
      "first_release": "2003",
      "types": "",
      "paradigms": "Event-driven, visual, block-based",
      "website": "https://scratch.mit.edu/"
    },
    {
      "name": "script.net",
      "source": "https://en.wikipedia.org/wiki/Script.NET",
      "about": "Script.NET or S# is a metaprogramming language that provides scripting functionality in Microsoft .NET applications, allowing runtime execution of custom functionality, similar to VBA in Microsoft Office applications. The syntax of Script.NET is similar to JavaScript. It is designed to be simple and efficient scripting language allowing to customize .NET applications. The language has a true runtime interpreter, and it is executed without generating additional in-memory assemblies.",
      "first_release": "",
      "types": "dynamic",
      "paradigms": "imperative, meta, scripting",
      "website": "http://www.protsyk.com/scriptdotnet"
    },
    {
      "name": "sed",
      "source": "https://en.wikipedia.org/wiki/Sed",
      "about": "sed (\"stream editor\") is a Unix utility that parses and transforms text, using a simple, compact programming language. sed was developed from 1973 to 1974 by Lee E. McMahon of Bell Labs,[1] and is available today for most operating systems.[2] sed was based on the scripting features of the interactive editor ed (\"editor\", 1971) and the earlier qed (\"quick editor\", 1965–66). sed was one of the earliest tools to support regular expressions, and remains in use for text processing, most notably with the substitution command. Popular alternative tools for plaintext string manipulation and \"stream editing\" include AWK and Perl.",
      "first_release": "1974",
      "types": "",
      "paradigms": "scripting",
      "website": "https://www.gnu.org/software/sed/"
    },
    {
      "name": "seed7",
      "source": "https://en.wikipedia.org/wiki/Seed7",
      "about": "Seed7 is an extensible general-purpose programming language designed by Thomas Mertes. It is syntactically similar to Pascal and Ada. Along with many other features, it provides an extension mechanism.[2] Seed7 supports introducing new syntax elements and their semantics into the language, and allows new language constructs to be defined and written in Seed7.[3] For example, programmers can introduce syntax and semantics of new statements and user defined operator symbols. The implementation of Seed7 differs significantly from that of languages with hard-coded syntax and semantics.",
      "first_release": "2005",
      "types": "static, strong, safe, nominative, manifest",
      "paradigms": "multi-paradigm, extensible, object-oriented, imperative, structured, generic, reflective",
      "website": "http://seed7.sourceforge.net/"
    },
    {
      "name": "self",
      "source": "https://en.wikipedia.org/wiki/Self_(programming_language)",
      "about": "Self is an object-oriented programming language based on the concept of prototypes. Self began as a dialect of Smalltalk, being dynamically typed and using just-in-time compilation (JIT) as well as the prototype-based approach to objects: it was first used as an experimental test system for language design in the 1980s and 1990s. In 2006, Self was still being developed as part of the Klein project, which was a Self virtual machine written fully in Self. The latest version is 2017.1 released in May 2017.[1]",
      "first_release": "1987",
      "types": "dynamic, strong",
      "paradigms": "object-oriented, prototype-based",
      "website": "http://www.selflanguage.org/"
    },
    {
      "name": "sensetalk",
      "source": "https://en.wikipedia.org/wiki/SenseTalk",
      "about": "SenseTalk is a high-level English-like scripting language in the XTalk family, that supports both procedural and object-oriented paradigms. SenseTalk scripts are intended to be largely readable by ordinary people, including those with little to no training in programming.",
      "first_release": "1992",
      "types": "Duck",
      "paradigms": "People Oriented Programming, Multi-paradigm, Object-oriented",
      "website": "http://www.sensetalk.com/"
    },
    {
      "name": "sequencel",
      "source": "https://en.wikipedia.org/wiki/SequenceL",
      "about": "SequenceL is a general purpose functional programming language and auto-parallelizing (Parallel computing) compiler and tool set, whose primary design objectives are performance on multi-core processor hardware, ease of programming, platform portability/optimization, and code clarity and readability. Its main advantage is that it can be used to write straightforward code that automatically takes full advantage of all the processing power available, without programmers needing to be concerned with identifying parallelisms, specifying vectorization, avoiding race conditions, and other challenges of manual directive-based programming approaches such as OpenMP.",
      "first_release": "1989",
      "types": "Static, type inference",
      "paradigms": "Parallel computing, Functional, Purely functional, Declarative programming",
      "website": "http://texasmulticore.com/"
    },
    {
      "name": "serpent",
      "source": "https://en.wikipedia.org/wiki/Ethereum",
      "about": "Ethereum is a decentralized, open-source blockchain featuring smart contract functionality. Ether (ETH) is the native cryptocurrency of the platform. It is the second-largest cryptocurrency by market capitalization, after Bitcoin.[1] Ethereum is the most actively used blockchain.[2][3]",
      "first_release": "2015",
      "types": "",
      "paradigms": "",
      "website": "http://ethereum.org/"
    },
    {
      "name": "setl",
      "source": "https://en.wikipedia.org/wiki/SETL",
      "about": "SETL (SET Language) is a very high-level programming language based on the mathematical theory of sets. It was originally developed by (Jack) Jacob T. Schwartz at the New York University (NYU) Courant Institute of Mathematical Sciences in the late 1960s.",
      "first_release": "1969",
      "types": "Dynamic",
      "paradigms": "multi-paradigm, imperative, procedural, structured, object-oriented",
      "website": "http://setl.org/"
    },
    {
      "name": "simpol",
      "source": "https://en.wikipedia.org/wiki/Superbase_database",
      "about": "Superbase is an end-user desktop database program that started on the Commodore 64 and was ported from that to various operating systems over the course of more than 20 years. It also has generally included a programming language to automate database-oriented tasks, and with later versions included WYSIWYG form and report designers as well as more sophisticated programming capabilities.",
      "first_release": "1983",
      "types": "",
      "paradigms": "",
      "website": "http://www.superbase.com/"
    },
    {
      "name": "signal",
      "source": "https://en.wikipedia.org/wiki/SIGNAL_(programming_language)",
      "about": "SIGNAL is a programming language based on synchronized data-flow (flows + synchronization): a process is a set of equations on elementary flows describing both data and control.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "simple",
      "source": "https://en.wikipedia.org/wiki/SiMPLE",
      "about": "SiMPLE (a recursive acronym for SiMPLE Modular Programming Language & Environment) is a programming development system that was created to provide easy programming capabilities for everybody, especially non-professionals.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "simscript",
      "source": "https://en.wikipedia.org/wiki/SIMSCRIPT",
      "about": "SIMSCRIPT is a free-form, English-like general-purpose simulation language conceived by Harry Markowitz and Bernard Hausner at the RAND Corporation in 1962. It was implemented as a Fortran preprocessor on the IBM 7090[1] and was designed for large discrete event simulations. It influenced Simula.[2]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "simula",
      "source": "https://en.wikipedia.org/wiki/Simula",
      "about": "Simula is the name of two simulation programming languages, Simula I and Simula 67, developed in the 1960s at the Norwegian Computing Center in Oslo, by Ole-Johan Dahl and Kristen Nygaard. Syntactically, it is a fairly faithful superset of ALGOL 60,[1]:1.3.1 also influenced by the design of Simscript.[2]",
      "first_release": "1962",
      "types": "Static, nominative",
      "paradigms": "Multi-paradigm, procedural, imperative, structured, object-oriented",
      "website": "http://www.simula67.info/"
    },
    {
      "name": "simulink",
      "source": "https://en.wikipedia.org/wiki/Simulink",
      "about": "Simulink is a MATLAB-based graphical programming environment for modeling, simulating and analyzing multidomain dynamical systems. Its primary interface is a graphical block diagramming tool and a customizable set of block libraries. It offers tight integration with the rest of the MATLAB environment and can either drive MATLAB or be scripted from it. Simulink is widely used in automatic control and digital signal processing for multidomain simulation and model-based design.[2][3]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "https://www.mathworks.com/products/simulink.html"
    },
    {
      "name": "singularity",
      "source": "https://en.wikipedia.org/wiki/Singularity_(operating_system)",
      "about": "Singularity is an experimental operating system (OS) which was built by Microsoft Research between 2003 and 2010.[1] It was designed as a high dependability OS in which the kernel, device drivers, and application software were all written in managed code. Internal security uses type safety instead of hardware memory protection.",
      "first_release": "2007",
      "types": "",
      "paradigms": "",
      "website": "http://research.microsoft.com/en-us/projects/singularity"
    },
    {
      "name": "sisal",
      "source": "https://en.wikipedia.org/wiki/SISAL",
      "about": "SISAL (\"Streams and Iteration in a Single Assignment Language\") is a general-purpose single assignment functional programming language with strict semantics, implicit parallelism, and efficient array handling. SISAL outputs a dataflow graph in Intermediary Form 1 (IF1). It was derived from VAL (Value-oriented Algorithmic Language, designed by Jack Dennis), and adds recursion and finite streams. It has a Pascal-like syntax and was designed to be a common high-level language for numerical programs on a variety of multiprocessors.",
      "first_release": "1983",
      "types": "static, strong",
      "paradigms": "functional, dataflow",
      "website": ""
    },
    {
      "name": "slip",
      "source": "https://en.wikipedia.org/wiki/SLIP_(programming_language)",
      "about": "SLIP is a list processing computer programming language, invented by Joseph Weizenbaum in the 1960s. The name SLIP stands for Symmetric LIst Processor. It was first implemented as an extension to the Fortran programming language, and later embedded into MAD and ALGOL.[1] The best known program written in the language is ELIZA, an early natural language processing computer program created by Weizenbaum [2] at the MIT Artificial Intelligence Laboratory.[3]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "small",
      "source": "https://en.wikipedia.org/wiki/SMALL",
      "about": "Small Machine Algol Like Language (SMALL), is a computer programming language developed by Dr. Nevil Brownlee of the University of Auckland.",
      "first_release": "1980",
      "types": "",
      "paradigms": "Procedural, imperative, structured, object-oriented",
      "website": ""
    },
    {
      "name": "smalltalk",
      "source": "https://en.wikipedia.org/wiki/Smalltalk",
      "about": "Smalltalk is an object-oriented, dynamically typed reflective programming language. Smalltalk was created as the language underpinning the \"new world\" of computing exemplified by \"human–computer symbiosis\".[2] It was designed and created in part for educational use, specifically for constructionist learning, at the Learning Research Group (LRG) of Xerox PARC by Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Diana Merry, Scott Wallace, and others during the 1970s.",
      "first_release": "1969",
      "types": "Strong, dynamic",
      "paradigms": "Object-oriented",
      "website": ""
    },
    {
      "name": "sml",
      "source": "https://en.wikipedia.org/wiki/Standard_ML",
      "about": "Standard ML (SML) is a general-purpose, modular, functional programming language with compile-time type checking and type inference. It is popular among compiler writers and programming language researchers, as well as in the development of theorem provers.",
      "first_release": "1983",
      "types": "Inferred, static, strong",
      "paradigms": "Multi-paradigm, functional, imperative, modular, [1]",
      "website": "http://sml-family.org/"
    },
    {
      "name": "strongtalk",
      "source": "https://en.wikipedia.org/wiki/Strongtalk",
      "about": "Strongtalk is a Smalltalk environment with optional static typing support. Strongtalk can make some compile time checks, and offer stronger type safety guarantees; this is the source of its name. It is non-commercial, though it was originally a commercial project developed by a small startup company named LongView Technologies (trading as Animorphic Systems).",
      "first_release": "2002",
      "types": "Dynamic, static",
      "paradigms": "Object-oriented",
      "website": "http://www.strongtalk.org/"
    },
    {
      "name": "snap!",
      "source": "https://en.wikipedia.org/wiki/Snap!_(programming_language)",
      "about": "Snap! (formerly Build Your Own Blocks or BYOB) is a free, block-based educational graphical programming language and online community aimed at students to explore, create and re-mix interactive animations, games, stories, and more, while learning about mathematical and computational ideas. While inspired by Scratch, Snap! has many advanced features. The Snap! editor, and programs created in it, are web applications that run in the browser (like Scratch 2 and 3) without requiring installation. [Note 2]",
      "first_release": "2011",
      "types": "dynamic",
      "paradigms": "object-oriented, educational, event-driven",
      "website": "http://snap.berkeley.edu/"
    },
    {
      "name": "snobol",
      "source": "https://en.wikipedia.org/wiki/SNOBOL",
      "about": "SNOBOL (\"StriNg Oriented and symBOlic Language\") is a series of programming languages developed between 1962 and 1967 at AT&T Bell Laboratories by David J. Farber, Ralph E. Griswold and Ivan P. Polonsky, culminating in SNOBOL4. It was one of a number of text-string-oriented languages developed during the 1950s and 1960s; others included COMIT and TRAC.",
      "first_release": "1962",
      "types": "",
      "paradigms": "Imperative, unstructured",
      "website": "http://www.snobol4.org/"
    },
    {
      "name": "spitbol",
      "source": "https://en.wikipedia.org/wiki/SPITBOL_compiler",
      "about": "SPITBOL (Speedy Implementation of SNOBOL) is a compiled implementation of the SNOBOL4 programming language. Originally targeted for the IBM System/360 and System/370 family of computers, it has now been ported to most major microprocessors including the SPARC. It was created by Robert Dewar and Ken Belcher, who were then at the Illinois Institute of Technology.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "snowball",
      "source": "https://en.wikipedia.org/wiki/Snowball_programming_language",
      "about": "Snowball is a small string processing programming language designed for creating stemming algorithms for use in information retrieval.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "sol",
      "source": "https://en.wikipedia.org/wiki/Secure_Operations_Language",
      "about": "The Secure Operations Language (SOL) was developed jointly by the United States Naval Research Laboratory and Utah State University in the United States. SOL is a domain-specific synchronous programming language for developing distributed applications and is based on software engineering principles developed in the Software Cost Reduction project at the Naval Research Laboratory in the late 1970s and early 1980s. SOL is intended to be a domain-specific language for developing service-based systems. Concurrently, a domain-specific extension of Java (SOLj) is being developed (FTDCS 2007) Application domains include sensor networks, defense and space systems, healthcare delivery, power control, etc.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "solidity",
      "source": "https://en.wikipedia.org/wiki/Solidity",
      "about": "Solidity is an object-oriented programming language for writing smart contracts.[1] It is used for implementing smart contracts[2] on various blockchain platforms, most notably, Ethereum.[3] It was developed by Christian Reitwiessner, Alex Beregszaszi, and several former Ethereum core contributors to enable writing smart contracts on blockchain platforms such as Ethereum.[4]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "https://github.com/ethereum/solidity"
    },
    {
      "name": "sophaeros",
      "source": "https://en.wikipedia.org/wiki/SOPHAEROS",
      "about": "SOPHAEROS is a computer code, used by the AECL and French Nuclear program to simulate the transfer of fission products in the reactor chamber. It models fission product behaviour using a set of aerosol dynamic rules, and is used by AECL in fuel channel safety analyses.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "source",
      "source": "https://en.wikipedia.org/wiki/Source_(programming_language)",
      "about": "Source is a family of sublanguages of JavaScript, developed for the textbook Structure and Interpretation of Computer Programs, JavaScript Adaptation (SICP JS). The JavaScript sublanguages Source §1, Source §2, Source §3 and Source §4 are designed to be just powerful enough to support all examples of the respective chapter of the textbook.",
      "first_release": "2017",
      "types": "Dynamic, duck",
      "paradigms": "Multi-paradigm, scripting, imperative, procedural, functional",
      "website": "https://source-academy.github.io/source/"
    },
    {
      "name": "spark",
      "source": "https://en.wikipedia.org/wiki/SPARK_(programming_language)",
      "about": "SPARK is a formally defined computer programming language based on the Ada programming language, intended for the development of high integrity software used in systems where predictable and highly reliable operation is essential. It facilitates the development of applications that demand safety, security, or business integrity.",
      "first_release": "",
      "types": "static, strong, safe, nominative",
      "paradigms": "Multi-paradigm",
      "website": "http://www.adacore.com/sparkpro/"
    },
    {
      "name": "speakeasy",
      "source": "https://en.wikipedia.org/wiki/Speakeasy_(computational_environment)",
      "about": "Speakeasy is a numerical computing interactive environment also featuring an interpreted programming language. It was initially developed for internal use at the Physics Division of Argonne National Laboratory by the theoretical physicist Stanley Cohen.[4] He eventually founded Speakeasy Computing Corporation to make the program available commercially.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://speakeasy.com/"
    },
    {
      "name": "speedcode",
      "source": "https://en.wikipedia.org/wiki/Speedcoding",
      "about": "Speedcoding or Speedcode was the first high-level programming language created for an IBM computer.[1] The language was developed by John Backus in 1953 for the IBM 701 to support computation with floating point numbers.[2] Here high level means symbolic and aiming for natural language expressivity as a goal as opposed to machine or hardware instruction oriented coding.",
      "first_release": "1953",
      "types": "strong, static, manifest",
      "paradigms": "structured, object-oriented, generic",
      "website": ""
    },
    {
      "name": "spin",
      "source": "https://en.wikipedia.org/wiki/Parallax_Propeller",
      "about": "The Parallax P8X32A Propeller is a multi-core processor parallel computer architecture microcontroller chip with eight 32-bit reduced instruction set computer (RISC) central processing unit (CPU) cores.[1][2] Introduced in 2006, it is designed and sold by Parallax, Inc.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "sp/k",
      "source": "https://en.wikipedia.org/wiki/SP/k",
      "about": "SP/k is a programming language developed circa 1974[1] by R.C. Holt, D.B. Wortman, D.T. Barnard and J.R. Cordy as a subset of the PL/I programming language designed for teaching programming. It was used for about a decade at over 40 universities, schools, and research laboratories in Canada and the United States.",
      "first_release": "1974",
      "types": "static, strong",
      "paradigms": "structured, imperative",
      "website": ""
    },
    {
      "name": "sps",
      "source": "https://en.wikipedia.org/wiki/IBM_1401_Symbolic_Programming_System",
      "about": "The IBM 1401 Symbolic Programming System (SPS) was an assembler that was developed by Gary Mokotoff, IBM Applied Programming Department, for the IBM 1401 computer, the first of the IBM 1400 series. One source indicates that \"This programming system was announced by IBM with the machine.\"[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "sql",
      "source": "https://en.wikipedia.org/wiki/SQL",
      "about": "SQL (/ˌɛsˌkjuːˈɛl/ (listen) S-Q-L,[4] /ˈsiːkwəl/ \"sequel\"; Structured Query Language)[5] is a domain-specific language used in programming and designed for managing data held in a relational database management system (RDBMS), or for stream processing in a relational data stream management system (RDSMS). It is particularly useful in handling structured data, i.e. data incorporating relations among entities and variables.",
      "first_release": "1974",
      "types": "Static, strong",
      "paradigms": "Declarative",
      "website": "https://www.iso.org/standard/63555.html"
    },
    {
      "name": "sqr",
      "source": "https://en.wikipedia.org/wiki/SQR",
      "about": "SQR (Hyperion SQR Production Reporting, Part of OBIEE) is a programming language designed for generating reports from database management system management systems. The name is an abbreviation of Structured Query Reporter, which suggests its relationship to SQL (Structured Query Language). Any SQL statement can be embedded in an SQR program.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "squeak",
      "source": "https://en.wikipedia.org/wiki/Squeak",
      "about": "The Squeak programming language is a dialect of Smalltalk. It is object-oriented, class-based, and reflective.",
      "first_release": "1996",
      "types": "Dynamic",
      "paradigms": "object-oriented",
      "website": "http://www.squeak.org/"
    },
    {
      "name": "squirrel",
      "source": "https://en.wikipedia.org/wiki/Squirrel_(programming_language)",
      "about": "Squirrel is a high level imperative, object-oriented programming language, designed to be a lightweight scripting language that fits in the size, memory bandwidth, and real-time requirements of applications like video games and embedded systems.",
      "first_release": "2003",
      "types": "Dynamic",
      "paradigms": "Multi-paradigm, scripting, imperative, functional, object-oriented",
      "website": "http://squirrel-lang.org/"
    },
    {
      "name": "sr",
      "source": "https://en.wikipedia.org/wiki/SR_(programming_language)",
      "about": "SR (short for Synchronizing Resources) is a programming language designed for concurrent programming.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "s/sl",
      "source": "https://en.wikipedia.org/wiki/S/SL_programming_language",
      "about": "The Syntax/Semantic Language (S/SL) is an executable high level specification language for recursive descent parsers, semantic analyzers and code generators developed by James Cordy, Ric Holt and David Wortman at the University of Toronto in 1980.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "starlogo",
      "source": "https://en.wikipedia.org/wiki/Starlogo",
      "about": "StarLogo is an agent-based simulation language developed by Mitchel Resnick, Eric Klopfer, and others at the Massachusetts Institute of Technology (MIT) Media Lab and Scheller Teacher Education Program in Massachusetts. It is an extension of the Logo programming language, a dialect of Lisp. Designed for education, StarLogo can be used by students to model or simulate the behavior of decentralized systems.",
      "first_release": "2001",
      "types": "duck, dynamic, strong",
      "paradigms": "Multi-paradigm, educational, procedural, agent-based, simulation",
      "website": "http://www.slnova.org/"
    },
    {
      "name": "strand",
      "source": "https://en.wikipedia.org/wiki/Strand_(programming_language)",
      "about": "Strand is a high-level symbolic language for parallel computing, similar in syntax to Prolog.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "stata",
      "source": "https://en.wikipedia.org/wiki/Stata",
      "about": "Stata is a general-purpose statistical software package created in 1985 by StataCorp. Most of its users work in research, especially in the fields of economics, sociology, political science, biomedicine, and epidemiology.[2]",
      "first_release": "1985",
      "types": "",
      "paradigms": "",
      "website": "https://www.stata.com/"
    },
    {
      "name": "stateflow",
      "source": "https://en.wikipedia.org/wiki/Stateflow",
      "about": "Stateflow (developed by MathWorks) is a control logic tool used to model reactive systems via state machines and flow charts within a Simulink model. Stateflow uses a variant of the finite-state machine notation established by David Harel, enabling the representation of hierarchy, parallelism and history within a state chart.[2][3] Stateflow also provides state transition tables and truth tables.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.mathworks.com/products/stateflow?s_cid=wiki_stateflow_2"
    },
    {
      "name": "subtext",
      "source": "https://en.wikipedia.org/wiki/Subtext_(programming_language)",
      "about": "Subtext is a moderately visual programming language and environment, for writing application software. It is an experimental, research attempt to develop a new programming model, called Example Centric Programming, by treating copied blocks as first class prototypes, for program structure. It uses live text, similar to what occurs in spreadsheets as users update cells, for frequent feedback. It is intended to eventually be developed enough to become a practical language for daily use. It is planned to be open software; the license is not yet determined.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "sbl",
      "source": "https://en.wikipedia.org/wiki/Superbase_database",
      "about": "Superbase is an end-user desktop database program that started on the Commodore 64 and was ported from that to various operating systems over the course of more than 20 years. It also has generally included a programming language to automate database-oriented tasks, and with later versions included WYSIWYG form and report designers as well as more sophisticated programming capabilities.",
      "first_release": "1983",
      "types": "",
      "paradigms": "",
      "website": "http://www.superbase.com/"
    },
    {
      "name": "supercollider",
      "source": "https://en.wikipedia.org/wiki/SuperCollider",
      "about": "SuperCollider is an environment and programming language originally released in 1996 by James McCartney for real-time audio synthesis and algorithmic composition.[4][5]",
      "first_release": "1996",
      "types": "",
      "paradigms": "",
      "website": "http://supercollider.github.io/"
    },
    {
      "name": "supertalk",
      "source": "https://en.wikipedia.org/wiki/SuperTalk",
      "about": "SuperTalk is the scripting language used in SuperCard. SuperTalk is a descendant of HyperTalk.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "swift",
      "source": "https://en.wikipedia.org/wiki/Swift_(programming_language)",
      "about": "Swift is a general-purpose, multi-paradigm, compiled programming language developed by Apple Inc. and the open-source community, first released in 2014. Swift was developed as a replacement for Apple's earlier programming language Objective-C, as Objective-C had been largely unchanged since the early 1980s and lacked modern language features. Swift works with Apple's Cocoa and Cocoa Touch frameworks, and a key aspect of Swift's design was the ability to interoperate with the huge body of existing Objective-C code developed for Apple products over the previous decades. It is built with the open source LLVM compiler framework and has been included in Xcode since version 6, released in 2014. On Apple platforms,[11] it uses the Objective-C runtime library which allows C, Objective-C, C++ and Swift code to run within one program.[12]",
      "first_release": "2014",
      "types": "Static, strong, inferred",
      "paradigms": "Multi-paradigm, protocol-oriented, object-oriented, functional, imperative, block structured, Declarative programming",
      "website": "https://swift.org/"
    },
    {
      "name": "swift",
      "source": "https://en.wikipedia.org/wiki/Swift_(parallel_scripting_language)",
      "about": "Swift[1] is an implicitly parallel programming language that allows writing scripts that distribute program execution across distributed computing resources,[2] including clusters, clouds, grids, and supercomputers. Swift implementations are open-source software under the Apache License, version 2.0.",
      "first_release": "2007",
      "types": "Strong",
      "paradigms": "Dataflow, distributed, grid, concurrent, scientific workflow, scripting",
      "website": "http://swift-lang.org/"
    },
    {
      "name": "sympl",
      "source": "https://en.wikipedia.org/wiki/SYMPL",
      "about": "SYMPL is an obsolete programming language developed by the Control Data Corporation (CDC) for use on the CDC 6000 series computer systems in the 1970s and 1980s. It was based on a subset of CDCs version of JOVIAL, as an alternative to assembly language. A number of important CDC software products were implemented in SYMPL, including compilers, libraries, a full-screen editor, and major subsystems.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "systemverilog",
      "source": "https://en.wikipedia.org/wiki/SystemVerilog",
      "about": "SystemVerilog, standardized as IEEE 1800, is a hardware description and hardware verification language used to model, design, simulate, test and implement electronic systems. SystemVerilog is based on Verilog and some extensions, and since 2008 Verilog is now part of the same IEEE standard. It is commonly used in the semiconductor and electronic design industry as an evolution of Verilog.",
      "first_release": "2002",
      "types": "Static, weak",
      "paradigms": "Structured, Object-oriented",
      "website": ""
    },
    {
      "name": "t",
      "source": "https://en.wikipedia.org/wiki/T_(programming_language)",
      "about": "The programming language T is a dialect of the language Scheme developed in the early 1980s by Jonathan A. Rees, Kent M. Pitman, and Norman I. Adams of Yale University as an experiment in language design and implementation.[1]",
      "first_release": "1982",
      "types": "dynamic, strong",
      "paradigms": "Multi-paradigm, object-oriented, imperative, functional, meta",
      "website": "http://mumble.net/~jar/tproject"
    },
    {
      "name": "tacl",
      "source": "https://en.wikipedia.org/wiki/TACL",
      "about": "TACL (the Tandem Advanced Command Language) is the scripting programming language used in Tandem Computers. TACL is the shell.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "tacpol",
      "source": "https://en.wikipedia.org/wiki/TACPOL_(programming_language)",
      "about": "TACPOL (Tactical Procedure Oriented Language) is a block structured programming language developed by the United States Army for the TACFIRE Tactical Fire Direction command and control application. TACPOL is similar to PL/I.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "tads",
      "source": "https://en.wikipedia.org/wiki/TADS",
      "about": "Text Adventure Development System (TADS) is a prototype-based domain-specific programming language and set of standard libraries for creating interactive fiction (IF) games.",
      "first_release": "1988",
      "types": "Strong typing, type inference",
      "paradigms": "prototype-based, domain-specific",
      "website": "http://www.tads.org/"
    },
    {
      "name": "tal",
      "source": "https://en.wikipedia.org/wiki/Transaction_Application_Language",
      "about": "Transaction Application Language or TAL (originally \"Tandem Application Language\") is a block-structured, procedural language optimized for use on Tandem hardware. TAL resembles a cross between C and Pascal. It was the original system programming language for the Tandem CISC machines, which had no assembler.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "tcl",
      "source": "https://en.wikipedia.org/wiki/Tcl",
      "about": "Tcl (pronounced \"tickle\" or as an initialism[6]) is a high-level, general-purpose, interpreted, dynamic programming language. It was designed with the goal of being very simple but powerful.[7] Tcl casts everything into the mold of a command, even programming constructs like variable assignment and procedure definition.[8] Tcl supports multiple programming paradigms, including object-oriented, imperative and functional programming or procedural styles.",
      "first_release": "1988",
      "types": "Dynamic typing, string",
      "paradigms": "Multi-paradigm, event-driven, functional, imperative, object-oriented",
      "website": "https://www.tcl-lang.org/"
    },
    {
      "name": "tea",
      "source": "https://en.wikipedia.org/wiki/Tea_(programming_language)",
      "about": "Tea is a high-level scripting language for the Java environment. It combines features of Scheme, Tcl, and Java.[1][2]",
      "first_release": "1997",
      "types": "",
      "paradigms": "Multi-paradigm, Functional, Object-oriented, class-based",
      "website": "http://www2.pdmfc.com/tea"
    },
    {
      "name": "teco",
      "source": "https://en.wikipedia.org/wiki/Text_Editor_and_Corrector",
      "about": "TECO (Tee'koh[1] / /ˈtiːkoʊ/), Text Editor & Corrector[2][3][4] is both a character-oriented text editor and a programming language,[5][6] that was developed in 1962 for use on Digital Equipment Corporation computers, and has since become available on PCs and Unix. Dan Murphy developed TECO while a student at the Massachusetts Institute of Technology (MIT).[5]",
      "first_release": "1962",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "telcomp",
      "source": "https://en.wikipedia.org/wiki/TELCOMP",
      "about": "TELCOMP was a programming language developed at Bolt, Beranek and Newman (BBN) in about 1964 and in use until at least 1974. BBN offered TELCOMP as a paid service, with first revenue in October 1965.[1] The service was sold to a company called On-Line Systems in 1972. In the United Kingdom, TELCOMP was offered by Time Sharing, Ltd, a partnership between BBN and an entrepreneur named Richard Evans.",
      "first_release": "1965",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "tex",
      "source": "https://en.wikipedia.org/wiki/TeX",
      "about": "TeX (/tɛx, tɛk/, see below), stylized within the system as TEX, is a typesetting system (or a \"formatting system\") which was designed and mostly written by Donald Knuth[1] and released in 1978. TeX is a popular means of typesetting complex mathematical formulae; it has been noted as one of the most sophisticated digital typographical systems.[2]",
      "first_release": "1978",
      "types": "",
      "paradigms": "",
      "website": "http://tug.org/"
    },
    {
      "name": "tex",
      "source": "https://en.wikipedia.org/wiki/Text_Executive_Programming_Language",
      "about": "In 1979, Honeywell Information Systems announced a new programming language for their time-sharing service named TEX, an acronym for the Text Executive text processing system. TEX was a first generation scripting language, developed around the time of AWK and used by Honeywell initially as an in-house system test automation tool.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "tie",
      "source": "https://en.wikipedia.org/wiki/Tensilica_Instruction_Extension",
      "about": "Tensilica Instruction Extension refers to the proprietary language that is used to customize Tensilica's Xtensa processor core architecture.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "tmg",
      "source": "https://en.wikipedia.org/wiki/TMG_(language)",
      "about": "TMG (TransMoGrifier) is a recursive descent compiler-compiler[5] created by Robert M. McClure and presented in 1965.[6][7][8] TMG ran on systems like OS/360 and early Unix.[9] It was used to build EPL, an early version of PL/I.[9]",
      "first_release": "1963",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "tom",
      "source": "https://en.wikipedia.org/wiki/Tom_(pattern_matching_language)",
      "about": "Tom is a programming language[2] particularly well-suited for programming various transformations on tree structures and XML based documents. Tom is a language extension which adds new matching primitives to C and Java[3] as well as support for rewrite rules systems.[4] The rules can be controlled using a strategy[5] language.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://tom.loria.fr/"
    },
    {
      "name": "toi",
      "source": "https://en.wikipedia.org/wiki/Toi_(programming_language)",
      "about": "Toi is an imperative, type-sensitive language that provides the basic functionality of a programming language. The language was designed and developed from the ground-up by Paul Longtine.[1] Written in C, Toi was created with the intent to be an educational experience and serves as a learning tool (or toy, hence the name) for those looking to familiarize themselves with the inner-workings of a programming language.[2][dead link]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "topspeed",
      "source": "https://en.wikipedia.org/wiki/Clarion_(programming_language)",
      "about": "Clarion is a commercial, proprietary, fourth-generation programming language (4GL), multi-paradigm, programming language and integrated development environment (IDE) from SoftVelocity used to program database applications. It is compatible with indexed sequential access method (ISAM), Structured Query Language (SQL), and ActiveX Data Objects (ADO) data access methods, reads and writes several flat file desktop database formats including ASCII, comma-separated values (CSV), DOS (binary), FoxPro, Clipper, dBase, and some relational databases via ODBC, Microsoft SQL Server, Sybase SQL Anywhere, and Oracle Database through the use of accelerated native database drivers, and XML, Clarion can be used to output to HTML, XML, plain text, and Portable Document Format (PDF), among others.",
      "first_release": "1986",
      "types": "",
      "paradigms": "Imperative, structured, object-oriented",
      "website": "http://www.softvelocity.com/"
    },
    {
      "name": "tpu",
      "source": "https://en.wikipedia.org/wiki/Text_Processing_Utility",
      "about": "DEC Text Processing Utility (or DECTPU)[1][2] was a language developed by Digital Equipment Corporation (DEC) for developing text editors.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "trac",
      "source": "https://en.wikipedia.org/wiki/TRAC_(programming_language)",
      "about": "TRAC (for Text Reckoning And Compiling) Language is a programming language developed between 1959-1964 by Calvin Mooers and first implemented on the PDP-1 in 1964 by L. Peter Deutsch.[2] It was one of three \"first languages\" recommended by Ted Nelson in Computer Lib. TRAC T64 was used until at least 1984, when Mooers updated it to TRAC T84.[2]",
      "first_release": "1964",
      "types": "",
      "paradigms": "general-purpose macro processor",
      "website": ""
    },
    {
      "name": "ttm",
      "source": "https://en.wikipedia.org/wiki/TTM_(programming_language)",
      "about": "TTM is a string oriented, general purpose macro processing programming language developed in 1968 by Steven Caine and E. Kent Gordon at the California Institute of Technology.",
      "first_release": "1968",
      "types": "",
      "paradigms": "general-purpose macro processor",
      "website": ""
    },
    {
      "name": "t-sql",
      "source": "https://en.wikipedia.org/wiki/Transact-SQL",
      "about": "Transact-SQL (T-SQL) is Microsoft's and Sybase's proprietary extension to the SQL (Structured Query Language) used to interact with relational databases. T-SQL expands on the SQL standard to include procedural programming, local variables, various support functions for string processing, date processing, mathematics, etc. and changes to the DELETE and UPDATE statements.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "transcript",
      "source": "https://en.wikipedia.org/wiki/Transcript_(programming_language)",
      "about": "LiveCode (formerly Revolution and MetaCard[3]) is a cross-platform[4] rapid application development runtime system inspired by HyperCard. It features the LiveCode Script (formerly MetaTalk) programming language which belongs to the family of xTalk scripting languages like HyperCard's HyperTalk.[5][6]",
      "first_release": "2001",
      "types": "",
      "paradigms": "",
      "website": "http://livecode.org/"
    },
    {
      "name": "ttcn",
      "source": "https://en.wikipedia.org/wiki/TTCN",
      "about": "TTCN is a programming language used for testing of communication protocols and web services. A TTCN test suite consists of many test cases written in the TTCN programming language. Until version 2 the language was written in tables and called Tree and Tabular Combined Notation. Reading and editing this language required special TTCN editors. Beginning with version 3 TTCN was renamed to Testing and Test Control Notation. It is now closer to current programming languages and can be edited with traditional editors. TTCN-3 is more flexible than TTCN-2 in that it can be used for protocol testing as well as testing traditional software.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "turing",
      "source": "https://en.wikipedia.org/wiki/Turing_(programming_language)",
      "about": "Turing is a Pascal-like programming language developed in 1982 by Ric Holt and James Cordy, then of University of Toronto, in Toronto, Ontario, Canada. Turing is a descendant of Euclid, Pascal and SP/k that features a clean syntax and precise machine-independent semantics.",
      "first_release": "1982",
      "types": "static, manifest",
      "paradigms": "multi-paradigm, object-oriented, procedural",
      "website": ""
    },
    {
      "name": "tutor",
      "source": "https://en.wikipedia.org/wiki/TUTOR_(programming_language)",
      "about": "TUTOR, also known as PLATO Author Language, is a programming language developed for use on the PLATO system at the University of Illinois at Urbana-Champaign beginning in roughly 1965. TUTOR was initially designed by Paul Tenczar for use in computer assisted instruction (CAI) and computer managed instruction (CMI) (in computer programs called \"lessons\") and has many features for that purpose. For example, TUTOR has powerful answer-parsing and answer-judging commands, graphics, and features to simplify handling student records and statistics by instructors. TUTOR's flexibility, in combination with PLATO's computational power (running on what was considered a supercomputer in 1972), also made it suitable for the creation of games — including flight simulators, war games, dungeon style multiplayer role-playing games, card games, word games, and medical lesson games such as Bugs and Drugs (BND). TUTOR lives on today as the programming language for the Cyber1 PLATO System,[2] which runs most of the source code from 1980s PLATO and has roughly 5000 users as of June 2020.",
      "first_release": "1969",
      "types": "",
      "paradigms": "imperative, procedural",
      "website": ""
    },
    {
      "name": "txl",
      "source": "https://en.wikipedia.org/wiki/TXL_(programming_language)",
      "about": "TXL is a special-purpose programming language originally designed by Charles Halpern-Hamu and James Cordy at the University of Toronto in 1985. The acronym \"TXL\" originally stood for \"Turing eXtender Language\" after the language's original purpose, the specification and rapid prototyping of variants and extensions of the Turing programming language, but no longer has any meaningful interpretation.",
      "first_release": "",
      "types": "",
      "paradigms": "Pattern-matching, Term-rewriting",
      "website": "https://www.txl.ca/"
    },
    {
      "name": "typescript",
      "source": "https://en.wikipedia.org/wiki/TypeScript",
      "about": "TypeScript is a programming language developed and maintained by Microsoft. It is a strict syntactical superset of JavaScript and adds optional static typing to the language. TypeScript is designed for the development of large applications and transcompiles to JavaScript.[5] As TypeScript is a superset of JavaScript, existing JavaScript programs are also valid TypeScript programs.",
      "first_release": "2012",
      "types": "Duck, gradual, structural, [4]",
      "paradigms": "Multi-paradigm, functional, generic, imperative, object-oriented",
      "website": "https://www.typescriptlang.org/"
    },
    {
      "name": "tynker",
      "source": "https://en.wikipedia.org/wiki/Tynker",
      "about": "Tynker is an educational programming platform aimed at teaching children how to make games and programs. Instead of typing the source code, you visually drag blocks of code and snap them together. The visual design and principles are based on the free Scratch, just like Hopscotch and Snap!. Tynker is based on HTML5 and JavaScript, and can be used in the browser without plugins, as well as on tablets and smartphones.[1] Another difference is that Scratch is a free open source project, while Tynker is a commercial product, aimed at selling courses.[2] Tynker offers self-paced online courses for children to learn coding at home, as well as an engaging programming curriculum for schools and camps. It makes it easier for kids to learn coding as it teaches kids coding through creating games like Minecraft, Hour of Code etc.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://tynker.com/"
    },
    {
      "name": "ubercode",
      "source": "https://en.wikipedia.org/wiki/Ubercode",
      "about": "Ubercode is a high level programming language designed by Ubercode Software and released in 2005 for Microsoft Windows. Ubercode is influenced by Eiffel and BASIC. It is proprietary software and can be tried out for free for 30 days. Ubercode has the following design goals:",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "ucsd pascal",
      "source": "https://en.wikipedia.org/wiki/UCSD_Pascal",
      "about": "UCSD Pascal is a Pascal programming language system that runs on the UCSD p-System, a portable, highly machine-independent operating system. UCSD Pascal was first released in 1977. It was developed at the University of California, San Diego (UCSD).",
      "first_release": "1977",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "umple",
      "source": "https://en.wikipedia.org/wiki/Umple",
      "about": "Umple is a language for both object-oriented programming and modelling with class diagrams and state diagrams. The name Umple is a portmanteau of \"UML\", \"ample\" and \"Simple\",[1] indicating that it is designed to provide ample features to extend programming languages with UML capabilities.",
      "first_release": "2008",
      "types": "static",
      "paradigms": "object-oriented",
      "website": "http://www.umple.org/"
    },
    {
      "name": "unicon",
      "source": "https://en.wikipedia.org/wiki/Unicon_(programming_language)",
      "about": "Unicon is a programming language designed by American computer scientist Clint Jeffery with collaborators including Shamim Mohamed, Jafar Al Gharaibeh, Robert Parlett and others. Unicon descended from Icon and a preprocessor for Icon called IDOL. Compared with Icon, Unicon offers better access to the operating system as well as support for object-oriented programming. Unicon began life as a merger of three popular Icon extensions: an OO preprocessor named Idol, a POSIX filesystem and networking interface, and an ODBC facility. The name is shorthand for \"Unified Extended Dialect of Icon.\"",
      "first_release": "",
      "types": "",
      "paradigms": "object-oriented, procedural",
      "website": "http://unicon.sourceforge.net/"
    },
    {
      "name": "uniface",
      "source": "https://en.wikipedia.org/wiki/Uniface_(programming_language)",
      "about": "Uniface is a low-code development and deployment platform for enterprise applications that can run in a large range of runtime environments, including mobile, mainframe, web, Service-oriented architecture (SOA), Windows, Java EE and .NET. Uniface is a model-driven, Rapid Application Development (RAD) environment used to create mission-critical applications.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://uniface.com/"
    },
    {
      "name": "unity",
      "source": "https://en.wikipedia.org/wiki/UNITY_(programming_language)",
      "about": "UNITY is a programming language constructed by K. Mani Chandy and Jayadev Misra for their book Parallel Program Design: A Foundation. It is a theoretical language which focuses on what, instead of where, when or how. The language contains no method of flow control, and program statements run in a nondeterministic way until statements cease to cause changes during execution. This allows for programs to run indefinitely, such as auto-pilot or power plant safety systems, as well as programs that would normally terminate (which here converge to a fixed point).",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "unix shell",
      "source": "https://en.wikipedia.org/wiki/Unix_shell",
      "about": "A Unix shell is a command-line interpreter or shell that provides a command line user interface for Unix-like operating systems. The shell is both an interactive command language and a scripting language, and is used by the operating system to control the execution of the system using shell scripts.[2]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "unrealscript",
      "source": "https://en.wikipedia.org/wiki/UnrealScript",
      "about": "The Unreal Engine is a game engine developed by Epic Games, first showcased in the 1998 first-person shooter game Unreal. Although initially developed for first-person shooters, it has been used in a variety of genres, including platformers, fighting games, and MMORPGs, and has seen adoption by other markets, most notably the film and television industry. Written in C++, the Unreal Engine features a high degree of portability, supporting a wide range of platforms.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.unrealengine.com/"
    },
    {
      "name": "vala",
      "source": "https://en.wikipedia.org/wiki/Vala_(programming_language)",
      "about": "Vala is an object-oriented programming language with a self-hosting compiler that generates C code and uses the GObject system.",
      "first_release": "2006",
      "types": "static, strong",
      "paradigms": "Multi-paradigm, imperative, structured, object-oriented",
      "website": "https://wiki.gnome.org/Projects/Vala"
    },
    {
      "name": "verilog",
      "source": "https://en.wikipedia.org/wiki/Verilog",
      "about": "Verilog, standardized as IEEE 1364, is a hardware description language (HDL) used to model electronic systems. It is most commonly used in the design and verification of digital circuits at the register-transfer level of abstraction. It is also used in the verification of analog circuits and mixed-signal circuits, as well as in the design of genetic circuits.[1] In 2009, the Verilog standard (IEEE 1364-2005) was merged into the SystemVerilog standard, creating IEEE Standard 1800-2009. Since then, Verilog is officially part of the SystemVerilog language. The current version is IEEE standard 1800-2017.[2]",
      "first_release": "1984",
      "types": "Static, weak",
      "paradigms": "Structured",
      "website": ""
    },
    {
      "name": "vhdl",
      "source": "https://en.wikipedia.org/wiki/VHDL",
      "about": "VHDL (VHSIC-HDL, Very High Speed Integrated Circuit Hardware Description Language) is a hardware description language used in electronic design automation to describe digital and mixed-signal systems such as field-programmable gate arrays and integrated circuits. VHDL can also be used as a general-purpose parallel programming language.",
      "first_release": "1980",
      "types": "strong",
      "paradigms": "concurrent, reactive, dataflow",
      "website": "http://www.eda-twiki.org/cgi-bin/view.cgi/P1076/WebHome"
    },
    {
      "name": "vim script",
      "source": "https://en.wikipedia.org/wiki/Vim_(text_editor)",
      "about": "Vim (/vɪm/;[2] a contraction of Vi IMproved) is a clone, with additions, of Bill Joy's vi text editor program for Unix. Vim's author, Bram Moolenaar, based it on the source code for a port of the Stevie editor to the Amiga[3] and released a version to the public in 1991. Vim is designed for use both from a command-line interface and as a standalone application in a graphical user interface. Vim is free and open-source software and is released under a license that includes some charityware clauses, encouraging users who enjoy the software to consider donating to children in Uganda.[4] The license is compatible with the GNU General Public License through a special clause allowing distribution of modified copies \"under the GNU GPL version 2 or any later version\".[5]",
      "first_release": "1991",
      "types": "",
      "paradigms": "",
      "website": "https://www.vim.org/"
    },
    {
      "name": "viper",
      "source": "https://en.wikipedia.org/wiki/Ethereum",
      "about": "Ethereum is a decentralized, open-source blockchain featuring smart contract functionality. Ether (ETH) is the native cryptocurrency of the platform. It is the second-largest cryptocurrency by market capitalization, after Bitcoin.[1] Ethereum is the most actively used blockchain.[2][3]",
      "first_release": "2015",
      "types": "",
      "paradigms": "",
      "website": "http://ethereum.org/"
    },
    {
      "name": "visual dataflex",
      "source": "https://en.wikipedia.org/wiki/Visual_DataFlex",
      "about": "DataFlex is an object-oriented high-level programming language and a fourth generation visual tool 4GL for developing Windows, web and mobile software applications on one framework-based platform. It was introduced and developed by Data Access Corporation beginning in 1982.[5][2][6][7]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.dataaccess.com/DataFlex"
    },
    {
      "name": "visual dialogscript",
      "source": "https://en.wikipedia.org/wiki/Visual_DialogScript",
      "about": "Visual DialogScript (VDS) is an interpreted programming language for Microsoft Windows. It can be used to create small, fast programs. VDS has a large number of dialog and graphical elements available to create professional looking programs. VDS programs have access to the Windows API; therefore, it is possible to write applications that can perform the same advanced tasks as other programming languages such as Visual Basic, C++, or Delphi.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "visual foxpro",
      "source": "https://en.wikipedia.org/wiki/Visual_FoxPro",
      "about": "Visual FoxPro was a Microsoft data-centric procedural programming language that subsequently became object-oriented.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://msdn.microsoft.com/vfoxpro"
    },
    {
      "name": "visual j++",
      "source": "https://en.wikipedia.org/wiki/Visual_J%2B%2B",
      "about": "Visual J++ (pronounced \"Jay Plus Plus\") is Microsoft's discontinued implementation of Java. Syntax, keywords, and grammatical conventions were the same as Java's. It was introduced in 1996[1] and discontinued in January 2004,[2] replacing it to a certain extent with J# and C#.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "visual lisp",
      "source": "https://en.wikipedia.org/wiki/AutoLISP",
      "about": "AutoLISP is a dialect of the programming language Lisp built specifically for use with the full version of AutoCAD and its derivatives, which include AutoCAD Map 3D, AutoCAD Architecture and AutoCAD Mechanical.[1] Neither the application programming interface (API) nor the interpreter to execute AutoLISP code are included in the AutoCAD LT product line.[2]",
      "first_release": "1986",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "visual objects",
      "source": "https://en.wikipedia.org/wiki/Visual_Objects",
      "about": "Visual Objects is an object-oriented computer programming language that is used to create computer programs that operate primarily under Windows. Although it can be used as a general-purpose programming tool, it is almost exclusively used to create database programs.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "visual prolog",
      "source": "https://en.wikipedia.org/wiki/Visual_Prolog",
      "about": "Visual Prolog, formerly known as PDC Prolog and Turbo Prolog, is a strongly typed object-oriented extension of Prolog. As Turbo Prolog, it was marketed by Borland but it is now developed and marketed by the Danish firm Prolog Development Center (PDC) that originally developed it. Visual Prolog can build Microsoft Windows GUI-applications, console applications, DLLs (dynamic link libraries), and CGI-programs. It can also link to COM components and to databases by means of ODBC.",
      "first_release": "",
      "types": "static, strong, inferred",
      "paradigms": "multi-paradigm, logical, functional, object-oriented, imperative",
      "website": "https://www.visual-prolog.com/"
    },
    {
      "name": "watfiv, watfor",
      "source": "https://en.wikipedia.org/wiki/WATFIV_(programming_language)",
      "about": "WATFIV, or WATerloo FORTRAN IV, developed at the University of Waterloo, Canada is an implementation of the Fortran computer programming language. It is the successor of WATFOR.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "webassembly",
      "source": "https://en.wikipedia.org/wiki/WebAssembly",
      "about": "WebAssembly (sometimes abbreviated Wasm) is an open standard that defines a portable binary-code format for executable programs, and a corresponding textual assembly language, as well as interfaces for facilitating interactions between such programs and their host environment.[2][3][4][5] The main goal of WebAssembly is to enable high-performance applications on web pages, but the format is designed to be executed and integrated in other environments as well, including standalone ones.[6][7][8]",
      "first_release": "2017",
      "types": "",
      "paradigms": "structured, stack machine, [1]",
      "website": "https://webassembly.org/"
    },
    {
      "name": "webdna",
      "source": "https://en.wikipedia.org/wiki/WebDNA",
      "about": "WebDNA is a server-side scripting, interpreted language with an embedded database system, specifically designed for the World Wide Web. Its primary use is in creating database-driven dynamic web page applications. Released in 1995, the name was registered as a trademark in 1998.[1] WebDNA is currently maintained by WebDNA Software Corporation.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "whiley",
      "source": "https://en.wikipedia.org/wiki/Whiley_(programming_language)",
      "about": "Whiley is an experimental programming language that combines features from the functional and imperative paradigms, and supports formal specification through function preconditions, postconditions and loop invariants.[1] The language uses flow-sensitive typing also known as \"flow typing.\"",
      "first_release": "2010",
      "types": "Strong, safe, structural, flow-sensitive",
      "paradigms": "Imperative, Functional",
      "website": "http://whiley.org/"
    },
    {
      "name": "winbatch",
      "source": "https://en.wikipedia.org/wiki/Winbatch",
      "about": "Winbatch is a Microsoft Windows scripting language originally developed by Wilson WindowWare and currently supported, maintained and enhanced by Island Lake Consulting LLC. Its environment includes an interpreter and a code editor along with a dialog designer and optional compiler to create self-contained executables.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.winbatch.com/"
    },
    {
      "name": "wolfram language",
      "source": "https://en.wikipedia.org/wiki/Wolfram_Language",
      "about": "The Wolfram Language is a general multi-paradigm computational language[9] developed by Wolfram Research. It emphasizes symbolic computation, functional programming, and rule-based programming[10] and can employ arbitrary structures and data.[10] It is the programming language of the mathematical symbolic computation program Mathematica.[11]",
      "first_release": "1988",
      "types": "Dynamic, strong",
      "paradigms": "Multi-paradigm, term-rewriting, functional, procedural, array",
      "website": "https://www.wolfram.com/language/"
    },
    {
      "name": "wyvern",
      "source": "https://en.wikipedia.org/wiki/Wyvern_(programming_language)",
      "about": "Wyvern is a computer programming language created by Jonathan Aldrich and Alex Potanin for the development of web and mobile applications with security and assurance being number one priority. Wyvern supports object capabilities, it is structurally typed, and aims to make secure way of programming easier than insecure - as described in the Wyvern Manifesto. One of the early available features that make Wyvern special is a way to safely use multiple programming languages within the same program so programmers can use the language most appropriate for each function while at the same time increasing the program's security.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "x++",
      "source": "https://en.wikipedia.org/wiki/X%2B%2B",
      "about": "Microsoft Dynamics AX was one of Microsoft's enterprise resource planning software products. It is part of the Microsoft Dynamics family. In 2018, its thick-client interface was removed and the web product was rebranded as Microsoft Dynamics 365 for Finance and Operations as a part of Microsoft's Dynamics 365 suite.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "https://dynamics.microsoft.com/en-us/"
    },
    {
      "name": "x10",
      "source": "https://en.wikipedia.org/wiki/X10_(programming_language)",
      "about": "X10 is a programming language being developed by IBM at the Thomas J. Watson Research Center as part of the Productive, Easy-to-use, Reliable Computing System (PERCS) project funded by DARPA's High Productivity Computing Systems (HPCS) program. Its primary authors are Saravanan Arumugam (Aswath), Kemal Ebcioğlu, Vijay Saraswat, and Vivek Sarkar.[1]",
      "first_release": "2004",
      "types": "Static, strong, safe",
      "paradigms": "Object-oriented",
      "website": "http://x10-lang.org/"
    },
    {
      "name": "xbase",
      "source": "https://en.wikipedia.org/wiki/XBase",
      "about": "xBase is the generic term for all programming languages that derive from the original dBASE (Ashton-Tate) programming language and database formats. These are sometimes informally known as dBASE \"clones\". While there was a non-commercial predecessor to the Ashton-Tate product (Vulcan written by Wayne Ratliff), most clones are based on Ashton-Tate's 1986 dBASE III+ release — scripts written in the dBASE III+ dialect are most likely to run on all the clones.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "xbase++",
      "source": "https://en.wikipedia.org/wiki/XBase%2B%2B",
      "about": "Xbase++ is an object oriented programming language which has multiple inheritance and polymorphism. It is based on the XBase language dialect and conventions. It is 100% Clipper compatible language supporting multiple inheritance, polymorphism, object oriented programming. It supports the xBase data types, including Codeblocks. With Xbase++ it is possible to generate applications for Windows NT, 95, 98, Me, 2000, XP, VISTA and Windows 7, 8, 10.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "xbl",
      "source": "https://en.wikipedia.org/wiki/XBL",
      "about": "XBL (XML Binding Language) is an XML-based markup language for altering the behavior of XUL widgets. It was devised at Netscape in the late 1990s as an extension of XUL.[1][2]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "xc",
      "source": "https://en.wikipedia.org/wiki/XC_(programming_language)",
      "about": "XMOS is a fabless semiconductor company that develops audio products and multicore microcontrollers.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.xmos.com/"
    },
    {
      "name": "xmos architecture",
      "source": "https://en.wikipedia.org/wiki/XCore_XS1",
      "about": "XMOS is a fabless semiconductor company that develops audio products and multicore microcontrollers.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://www.xmos.com/"
    },
    {
      "name": "xharbour",
      "source": "https://en.wikipedia.org/wiki/XHarbour",
      "about": "xHarbour is a free multi-platform extended Clipper compiler, offering multiple graphic terminals (GTs), including console drivers, GUIs, and hybrid console/GUIs. xHarbour is backward-compatible with Clipper and supports many language syntax extensions, greatly extended run-time libraries, and extensive third party support.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "xl",
      "source": "https://en.wikipedia.org/wiki/XL_(programming_language)",
      "about": "XL (\"eXtensible Language\") is the first computer programming language designed to support concept programming.[1]",
      "first_release": "2000",
      "types": "strong",
      "paradigms": "Multi-paradigm, concept-oriented, imperative, functional",
      "website": "http://xlr.sf.net/"
    },
    {
      "name": "xojo",
      "source": "https://en.wikipedia.org/wiki/Xojo",
      "about": "The Xojo programming environment and programming language is developed and commercially marketed by Xojo, Inc. of Austin, Texas for software development targeting macOS, Microsoft Windows, Linux, iOS, the Web and Raspberry Pi. Xojo uses a proprietary object-oriented language.[2][3][4]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": "http://xojo.com/"
    },
    {
      "name": "xotcl",
      "source": "https://en.wikipedia.org/wiki/XOTcl",
      "about": "XOTcl is an object-oriented extension for the Tool Command Language created by Gustaf Neumann and Uwe Zdun. It is a derivative of MIT OTcl. XOTcl is based on a dynamic object system with metaclasses which as influenced by CLOS. Class and method definitions are completely dynamic. XOTcl provides language support for design patterns via filters and decorator mixins.",
      "first_release": "2000",
      "types": "dynamic typing, string",
      "paradigms": "multi-paradigm, object-oriented, functional, Imperative, event-driven programming",
      "website": "http://media.wu-wien.ac.at/"
    },
    {
      "name": "xod",
      "source": "https://en.wikipedia.org/wiki/XOD_(programming_language)",
      "about": "XOD – is an open-source visual programming language for microcontrollers started in 2016. As a supported platform XOD started with Arduino boards compatibility and Raspberry PI.[1][2][3][4][5][6]",
      "first_release": "2016",
      "types": "",
      "paradigms": "",
      "website": "https://xod.io/"
    },
    {
      "name": "xpl",
      "source": "https://en.wikipedia.org/wiki/XPL",
      "about": "XPL is a programming language based on PL/I, a portable one-pass compiler written in its own language, and a parser generator tool for easily implementing similar compilers for other languages. XPL was designed in 1967 as a way to teach compiler design principles and as starting point for students to build compilers for their own languages.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "xpl0",
      "source": "https://en.wikipedia.org/wiki/XPL0",
      "about": "XPL0 is a computer programming language that is essentially a cross between Pascal and C. It was created in 1976 by Peter J. R. Boyle who wanted a high-level language for his microcomputer and wanted something more sophisticated than BASIC, which was the dominant language for personal computers at the time.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "xquery",
      "source": "https://en.wikipedia.org/wiki/XQuery",
      "about": "XQuery (XML Query) is a query and functional programming language that queries and transforms collections of structured and unstructured data, usually in the form of XML, text and with vendor-specific extensions for other data formats (JSON, binary, etc.). The language is developed by the XML Query working group of the W3C. The work is closely coordinated with the development of XSLT by the XSL Working Group; the two groups share responsibility for XPath, which is a subset of XQuery.",
      "first_release": "2007",
      "types": "dynamic, [2], [3], strong",
      "paradigms": "declarative, functional, modular",
      "website": "http://www.w3.org/XML/Query/"
    },
    {
      "name": "xsb",
      "source": "https://en.wikipedia.org/wiki/XSB",
      "about": "XSB is the name of a dialect of the Prolog programming language and its implementation developed at Stony Brook University in collaboration with the Katholieke Universiteit Leuven, the New University of Lisbon, Uppsala University and software vendor XSB, Inc.",
      "first_release": "",
      "types": "",
      "paradigms": "Logic Programming",
      "website": "http://xsb.sourceforge.net/"
    },
    {
      "name": "xsharp",
      "source": "https://en.wikipedia.org/wiki/XSharp",
      "about": "X#, pronounced X sharp and often written XSharp, is an xBase-compatible programming language for the Microsoft .NET platform. X# has been built on top of Roslyn, the open source architecture behind the current Microsoft C# and Visual Basic .NET compilers.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "xslt",
      "source": "https://en.wikipedia.org/wiki/XSL_Transformations",
      "about": "XSLT (Extensible Stylesheet Language Transformations) is a language for transforming XML documents into other XML documents,[1] or other formats such as HTML for web pages, plain text or XSL Formatting Objects, which may subsequently be converted to other formats, such as PDF, PostScript and PNG.[2] XSLT 1.0 is widely supported in modern web browsers.[3]",
      "first_release": "1998",
      "types": "",
      "paradigms": "Declarative",
      "website": "https://www.w3.org/TR/xslt-30/"
    },
    {
      "name": "xtend",
      "source": "https://en.wikipedia.org/wiki/Xtend",
      "about": "Xtend is a general-purpose high-level programming language for the Java Virtual Machine. Syntactically and semantically Xtend has its roots in the Java programming language but focuses on a more concise syntax and some additional functionality such as type inference, extension methods, and operator overloading. Being primarily an object-oriented language, it also integrates features known from functional programming, e.g. lambda expressions. Xtend is statically typed and uses Java's type system without modifications. It is compiled to Java code and thereby seamlessly integrates with all existing Java libraries.",
      "first_release": "2011",
      "types": "Static, strong, inferred",
      "paradigms": "Object-oriented, imperative, functional",
      "website": "http://www.xtend-lang.org/"
    },
    {
      "name": "yorick",
      "source": "https://en.wikipedia.org/wiki/Yorick_(programming_language)",
      "about": "Yorick is an interpreted programming language designed for numerics, graph plotting, and steering large scientific simulation codes. It is quite fast due to array syntax, and extensible via C or Fortran routines. It was created in 1996 by David H. Munro of Lawrence Livermore National Laboratory.",
      "first_release": "1996",
      "types": "",
      "paradigms": "",
      "website": "https://yorick.github.com/"
    },
    {
      "name": "yql",
      "source": "https://en.wikipedia.org/wiki/YQL_(programming_language)",
      "about": "Yahoo! Query Language (YQL) is an SQL-like query language created by Yahoo! as part of their Developer Network. YQL is designed to retrieve and manipulate data from APIs through a single Web interface, thus allowing mashups that enable developers to create their own applications.[1]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "yoix",
      "source": "https://en.wikipedia.org/wiki/Yoix",
      "about": "In computer programming, Yoix is a high-level, general-purpose, interpreted, dynamic programming language. The Yoix interpreter is implemented using standard Java technology without any add-on packages and requires only a Sun-compliant JVM to operate.[citation needed] Initially developed by AT&T Labs researchers for internal use, it has been available as free and open source software since late 2000.",
      "first_release": "2000",
      "types": "",
      "paradigms": "Multi-paradigm, Object-based, procedural",
      "website": "https://github.com/att/yoix"
    },
    {
      "name": "yui",
      "source": "https://en.wikipedia.org/wiki/YUI_Library",
      "about": "The Yahoo! User Interface Library (YUI) is a discontinued open-source JavaScript library for building richly interactive web applications using techniques such as Ajax, DHTML, and DOM scripting. YUI includes several core CSS resources. It is available under a BSD License.[3] Development on YUI began in 2005 and Yahoo! properties such as My Yahoo! and the Yahoo! front page began using YUI in the summer of that year. YUI was released for public use in February 2006.[1] It was actively developed by a core team of Yahoo! engineers.",
      "first_release": "2006",
      "types": "",
      "paradigms": "",
      "website": "http://yuilibrary.com/"
    },
    {
      "name": "z notation",
      "source": "https://en.wikipedia.org/wiki/Z_notation",
      "about": "The Z notation /ˈzɛd/ is a formal specification language used for describing and modelling computing systems. It is targeted at the clear specification of computer programs and computer-based systems in general.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "zebra, zpl, zpl2",
      "source": "https://en.wikipedia.org/wiki/Zebra_(programming_language)",
      "about": "Zebra Programming Language (ZPL) is a page description language from Zebra Technologies, used primarily for labeling applications. The original language was superseded by ZPL II, but it is not fully compatible with the older version. Meanwhile, ZPL II is emulated by many label printers of various producers.[citation needed]",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "zeno",
      "source": "https://en.wikipedia.org/wiki/Zeno_(programming_language)",
      "about": "Zeno (after pre-Socratic Greek philosopher Zeno of Elea) is an imperative procedural programming language designed to be easy to learn and user friendly. Zeno is generic in the sense that it contains most of the essential elements used in other languages to develop real applications.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "zetalisp",
      "source": "https://en.wikipedia.org/wiki/ZetaLisp",
      "about": "Lisp Machine Lisp is a programming language, a dialect of the language Lisp. A direct descendant of Maclisp, it was initially developed in the mid to late 1970s as the system programming language for the Massachusetts Institute of Technology (MIT) Lisp machines. Lisp Machine Lisp was also the Lisp dialect with the most influence on the design of Common Lisp.",
      "first_release": "1976",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "zig",
      "source": "https://en.wikipedia.org/wiki/Zig_(programming_language)",
      "about": "Zig is an imperative, general-purpose, statically typed, compiled system programming language designed by Andrew Kelley.[3][4] The language is designed for \"robustness, optimality and maintainability\"[5] [6] , supporting compile-time generics and reflection, cross-compilation and manual memory management.[7] A major goal of the language is to compete with (and improve upon) C,[8][9] while also taking inspiration from Rust,[10][11] among others.",
      "first_release": "2016",
      "types": "Static, Strong, Inferred, Structural, Generic",
      "paradigms": "Multi-paradigm, imperative, concurrent, procedural, functional",
      "website": "https://ziglang.org/"
    },
    {
      "name": "zopl",
      "source": "https://en.wikipedia.org/wiki/ZOPL",
      "about": "ZOPL is a programming language created by Geac Computer Corporation in the early 1970s for use on their mainframe computer systems used in libraries and banking institutions. It had similarities to C and Pascal.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    },
    {
      "name": "zpl",
      "source": "https://en.wikipedia.org/wiki/ZPL_(programming_language)",
      "about": "ZPL (short for Z-level Programming Language) is an array programming language designed to replace C and C++ programming languages in engineering and scientific applications.[2] Because its design goal was to obtain cross-platform high performance, ZPL programs run fast on both sequential and parallel computers. Highly-parallel ZPL programs are simple and easy to write because it exclusively uses implicit parallelism.",
      "first_release": "1993",
      "types": "",
      "paradigms": "Array",
      "website": "https://web.archive.org/web/20060211013421/http://www.cs.washington.edu/research/zpl/home/"
    },
    {
      "name": "z++",
      "source": "https://en.wikipedia.org/wiki/Z%2B%2B",
      "about": "Z++ (pronounced zed plus plus) is an object-oriented extension to the Z specification language.",
      "first_release": "",
      "types": "",
      "paradigms": "",
      "website": ""
    }
  ],
  "meta": {
    "title": "Programming Languages with Paradigms and History - Free Download",
    "description": "692 programming languages with structured metadata including first release year, programming paradigms (object-oriented, functional, imperative, etc.), type system characteristics, and Wikipedia source links. Contains 692 records. Download in Excel, CSV, PDF formats.",
    "seo_title": "Programming Languages with Paradigms and History | ListBase",
    "seo_description": "Download Programming Languages with Paradigms and History — 692 records. Available in Excel, CSV, PDF formats.",
    "key_takeaways": [
      "Contains 692 records / 7 fields",
      "Available for free download in Excel, CSV, and PDF formats",
      "Data sourced from: https://github.com/raulpy271/languagesDataset"
    ]
  }
}