pldb/PLDB huggingface dataset:
lispyscript (pl, appeared 2012)
Creators: Santosh Rajan
Origin: https://github.com/santoshrajan/lispyscript/issues
Country: India
Website: http://lispyscript.com

A javascript With Lispy Syntax And Macros!


GitHub description: A javascript with Lispy syntax and macros

;; test with and without the "./"
;;(var k (require "square.ls"))
;;(var k (require "./square.ls"))
;; or test .ls files requiring .js files:
;;(var k (require "square.js"))
;;(var k (require "./square.js"))
;; or test omitting .ls extensions:
(var k (require "square"))
;;(var k (require "./square"))
(console.log (k 10))
Lite-C (pl, appeared 2007)
Origin: Conitec Datensysteme GmbH
Country: Germany
Website: http://www.3dgamestudio.de/litec.php


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. Lite-C claims to allow very fast programming with a minimum of code, and easy access to non-programmers. For this, the developer provides a 25-lesson workshop that especially deals with the game and multimedia related objects of the language.  Lite-C supports the Windows API and the Component Object Model (COM); therefore OpenGL and DirectX programs can directly be written in lite-C. It has integrated the free A8 rendering engine.
Literate Agda (pl, appeared 2009)
Origin: Chalmers University
Country: Sweden




\documentclass{article}

 % The following packages are needed because unicode
 % is translated (using the next set of packages) to
 % latex commands. You may need more packages if you
 % use more unicode characters:

 \usepackage{amssymb}
 \usepackage{bbm}
 \usepackage[greek,english]{babel}

 % This handles the translation of unicode to latex:

 \usepackage{ucs}
 \usepackage[utf8x]{inputenc}
 \usepackage{autofe}

 % Some characters that are not automatically defined
 % (you figure out by the latex compilation errors you get),
 % and you need to define:

 \DeclareUnicodeCharacter{8988}{\ensuremath{\ulcorner}}
 \DeclareUnicodeCharacter{8989}{\ensuremath{\urcorner}}
 \DeclareUnicodeCharacter{8803}{\ensuremath{\overline{\equiv}}}

 % Add more as you need them (shouldn’t happen often).

 % Using “\newenvironment” to redefine verbatim to
 % be called “code” doesn’t always work properly. 
 % You can more reliably use:

 \usepackage{fancyvrb}

 \DefineVerbatimEnvironment
   {code}{Verbatim}
   {} % Add fancy options here if you like.

 \begin{document}

 \begin{code}
module NatCat where

open import Relation.Binary.PropositionalEquality

-- If you can show that a relation only ever has one inhabitant
-- you get the category laws for free
module
  EasyCategory
  (obj : Set)
  (_⟶_ : obj → obj → Set)
  (_∘_ : ∀ {x y z} → x ⟶ y → y ⟶ z → x ⟶ z)
  (id : ∀ x → x ⟶ x)
  (single-inhabitant : (x y : obj) (r s : x ⟶ y) → r ≡ s)
  where

  idʳ : ∀ x y (r : x ⟶ y) → r ∘ id y ≡ r
  idʳ x y r = single-inhabitant x y (r ∘ id y) r 

  idˡ : ∀ x y (r : x ⟶ y) → id x ∘ r ≡ r
  idˡ x y r = single-inhabitant x y (id x ∘ r) r

  ∘-assoc : ∀ w x y z (r : w ⟶ x) (s : x ⟶ y) (t : y ⟶ z) → (r ∘ s) ∘ t ≡ r ∘ (s ∘ t)
  ∘-assoc w x y z r s t = single-inhabitant w z ((r ∘ s) ∘ t) (r ∘ (s ∘ t))

open import Data.Nat

same : (x y : ℕ) (r s : x ≤ y) → r ≡ s
same .0 y z≤n z≤n = refl
same .(suc m) .(suc n) (s≤s {m} {n} r) (s≤s s) = cong s≤s (same m n r s)

≤-trans : ∀ x y z → x ≤ y → y ≤ z → x ≤ z
≤-trans .0 y z z≤n s = z≤n
≤-trans .(suc m) .(suc n) .(suc n₁) (s≤s {m} {n} r) (s≤s {.n} {n₁} s) = s≤s (≤-trans m n n₁ r s)

≤-refl : ∀ x → x ≤ x
≤-refl zero = z≤n
≤-refl (suc x) = s≤s (≤-refl x)

module Nat-EasyCategory = EasyCategory ℕ _≤_ (λ {x}{y}{z} → ≤-trans x y z) ≤-refl same
 \end{code}

 \end{document}
Literate CoffeeScript (pl, appeared 2013)
Creators: Jeremy Ashkenas
Origin: https://github.com/jashkenas/coffeescript/issues
Country: United States
Website: https://coffeescript.org/#literate

Besides being used as an ordinary programming language, CoffeeScript may also be written in “literate” mode. If you name your file with a .litcoffee extension, you can write it as a Markdown document — a document that also happens to be executable CoffeeScript code. The compiler will treat any indented blocks (Markdown’s way of indicating source code) as executable code, and ignore the rest as comments. Code blocks must also be separated from comments by at least one blank line.


GitHub description: Unfancy JavaScript
Literate Haskell (pl, appeared 1991)
Origin: https://www.haskell.org/community/
Country: United States

Haskell is one of the few languages that provides native features to support literate programming. In haskell, a literate program is one with the suffix .lhs rather than .hs. In a literate Haskell program, there are two ways to distinguish between code and non-code portions. You can either prepend all code with a > , (bird style) or surround lines of code with \begin{code} and \end{code} pairs (latex style). For those who know, use and love latex, the latter is the suggested way to go.
Little b (pl, appeared 2004)
Creators: Aneil Mallavarapu
Origin: Harvard Medical School
Country: United States
Website: http://www.littleb.org/


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. This language is based on Lisp and is meant to allow modular programming to model biological systems.  It will allow more flexibility to facilitate rapid change that is required to accurately capture complex biological systems. The language draws on techniques from artificial intelligence and symbolic mathematics, and provides  syntactic conveniences derived from object-oriented languages.  The language was originally denoted with a lowercase b (distinguishing it from B, the predecessor to the widely used C programming language, but the name was eventually changed to "little b" to avoid confusion and to pay homage to Smalltalk, the first object-oriented programming language.
LiveCode (pl, appeared 2001)
Origin: LiveCode Ltd
Country: Scotland
Website: https://livecode.org/


LiveCode (formerly Revolution and MetaCard) is a cross-platform rapid application development runtime environment inspired by HyperCard. It features the Transcript (formerly MetaTalk) programming language which belongs to the family of xTalk scripting languages like HyperCard's HyperTalk. The environment was introduced in 2001. The "Revolution" development system was based on the MetaCard engine technology which Runtime Revolution later acquired from MetaCard Corporation in 2003. The platform won the Macworld Annual Editor's Choice Award for "Best Development Software" in 2004. "Revolution" was renamed "LiveCode" in the fall of 2010. "LiveCode" is developed and sold by Runtime Revolution Ltd., based in Edinburgh, Scotland. In March, 2015, the company was renamed "LiveCode Ltd.", to unify the company name with the product. In April 2013 a free/open source version 'LiveCode Community Edition 6.0' was published after a successful crowdfunding campaign at Kickstarter. The code base was re-licensed and made available as free and open source software with a version in April 2013. LiveCode runs on iOS, Android, OS X, Windows 95 through Windows 10, Raspberry Pi and several variations of Unix, including Linux, Solaris, and BSD. It can be used for mobile, desktop and server/CGI applications. The iOS (iPhone and iPad) version was released in December 2010. The first version to deploy to the Web was released in 2009. It is the most widely used HyperCard/HyperTalk clone, and the only one that runs on all major operating systems. A developer release of v.8 was announced in New York on March 12, 2015. This major enhancement to the product includes a new, separate development language, known as "LiveCode Builder", which is capable of creating new object classes called "widgets". In earlier versions, the set of object classes was fixed, and could only be enhanced via the use of ordinary procedural languages like C. The new language, which runs in its own IDE, is a departure from the transitional x-talk paradigm in that it permits typing of variables. But the two environments are fully integrated, and apart from the ability to create new objects, development in LiveCode proceeds in the normal way, within the established IDE. A second crowdfunding campaign to Bring HTML5 to LiveCode reached funding goals of nearly $400,000 USD on July 31, 2014. LiveCode developer release 8.0 DP4 (August 31, 2015) was the first to include a standalone deployment option to HTML5.
LiveScript (pl, appeared 2011)
Creators: Jeremy Ashkenas
Satoshi Murakami
George Zahariev
Origin: https://github.com/gkz/LiveScript/issues
Country: United States


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. For a brief period in the 1990s, LiveScript was the name of JavaScript.
Livr (dataValidationLanguage, appeared 2012)
Stands for: Language Independent Validation Rules
Creators: Viktor Turskyi
Origin: https://github.com/koorchik/LIVR/issues
Country: United States
Website: https://livr-spec.org/



GitHub description: Language Independent Validation Rules Specification

{
    name: 'required',
    phone: {max_length: 10},
    address: {nested_object: {
        city: 'required',
        zip: ['required', 'positive_integer']
    }}
}
Legal Knowledge Interchange Format (xmlFormat, appeared 2007)
Origin: https://github.com/RinkeHoekstra/lkif-core/issues
Country: The Netherlands


The Legal Knowledge Interchange Format (LKIF) was developed in the European ESTRELLA project and was designed with the goal of becoming a standard for representing and interchanging policy, legislation and cases, including their justificatory arguments, in the legal domain. LKIF builds on and uses the Web Ontology Language (OWL) for representing concepts and includes a reusable basic ontology of legal concepts. The core of LKIF consists of a combination of OWL-DL and SWRL.LKIF was designed with two main roles in  mind: the translation of legal knowledge bases written in different representation formats and formalisms and to be a knowledge representation formalism which could be part of larger architectures for developing legal knowledge systems.
llhd (hardwareDescriptionLanguage, appeared 2016)
Origin: https://grosser.science/
Country: United Kingdom
Website: http://llhd.io/




proc %Accumulator.always_comb.227.0 (i1$ %0, i16$ %1, i16$ %2) -> (i16$ %3) {
%4:
    br %body
%body:
    %direction = prb i1$ %0
    br %direction, %if_false, %if_true
%check:
    wait %body, %0, %1, %2
%if_true:
    %result = prb i16$ %2
    %increment = prb i16$ %1
    %5 = add i16 %result, %increment
    %6 = const time 0s 1e
    drv i16$ %3, %5, %6
    wait %7 for %6
%if_false:
    %result1 = prb i16$ %2
    %increment1 = prb i16$ %1
    %8 = sub i16 %result1, %increment1
    %9 = const time 0s 1e
    drv i16$ %3, %8, %9
    wait %10 for %9
%if_exit:
    br %check
%7:
    br %if_exit
%10:
    br %if_exit
}
proc %Accumulator.always_ff.228.0 (i1$ %0, i16$ %1) -> (i16$ %2) {
%3:
    br %init
%init:
    %clk = prb i1$ %0
    wait %check, %0
%check:
    %clk1 = prb i1$ %0
    %4 = const i1 0
    %5 = eq i1 %clk, %4
    %6 = neq i1 %clk1, %4
    %posedge = and i1 %5, %6
    br %posedge, %init, %event
%event:
    %next = prb i16$ %1
    %7 = const time 0s 1d
    drv i16$ %2, %next, %7
    br %3
}
entity @Accumulator (i1$ %clk, i1$ %direction, i16$ %increment) -> (i16$ %result) {
    %0 = const i16 0
    %next = sig i16 %0
    inst %Accumulator.always_comb.227.0 (i1$ %direction, i16$ %increment, i16$ %result) -> (i16$ %next)
    inst %Accumulator.always_ff.228.0 (i1$ %clk, i16$ %next) -> (i16$ %result)
}
Low Level Lisp (pl, appeared 2014)
Origin: https://github.com/benjaminion/LLL_docs/issues
Country: United Kingdom

LLL is one of the original Ethereum smart contract programming languages and provides a different perspective and programming discipline when compared to the ubiquitous Solidity language. Lisp Like Language (LLL) is a low level language similar to Assembly. It is meant to be very simple and minimalistic; essentially just a tiny wrapper over coding in EVM directly.
LLVM IR (ir, appeared 2003)
Also known as: llvm
Origin: https://github.com/llvm
Country: Various
Website: http://llvm.org/docs/LangRef.html


The LLVM compiler infrastructure project is a "collection of modular and reusable compiler and toolchain technologies" used to develop compiler front ends and back ends. LLVM is written in C++ and is designed for compile-time, link-time, run-time, and "idle-time" optimization of programs written in arbitrary programming languages. Originally implemented for C and C++, the language-agnostic design of LLVM has since spawned a wide variety of front ends: languages with compilers that use LLVM include ActionScript, Ada, C#, Common Lisp, Crystal, D, Delphi, Fortran, OpenGL Shading Language, Halide, Haskell, Java bytecode, Julia, Lua, Objective-C, Pony, Python, R, Ruby, Rust, CUDA, Scala, Swift, and Xojo. The LLVM project started in 2000 at the University of Illinois at Urbana–Champaign, under the direction of Vikram Adve and Chris Lattner. LLVM was originally developed as a research infrastructure to investigate dynamic compilation techniques for static and dynamic programming languages. LLVM was released under the University of Illinois/NCSA Open Source License, a permissive free software licence. In 2005, Apple Inc. hired Lattner and formed a team to work on the LLVM system for various uses within Apple's development systems. LLVM is an integral part of Apple's latest development tools for macOS and iOS. Since 2013, Sony has been using LLVM's primary front end Clang compiler in the software development kit (SDK) of its PS4 console. The name LLVM was originally an initialism for Low Level Virtual Machine. This initialism has offically been removed to avoid confusion, as the LLVM has evolved into an umbrella project that has little relationship to what most current developers think of as virtual machines. Now, LLVM is a brand that applies to the LLVM umbrella project, the LLVM intermediate representation (IR), the LLVM debugger, the LLVM C++ Standard Library (with full support of C++11 and C++14), etc. LLVM is administered by the LLVM Foundation. Its president is compiler engineer Tanya Lattner. The Association for Computing Machinery presented Adve, Lattner, and Evan Cheng with the 2012 ACM Software System Award for LLVM.
lmdb (library, appeared 2011)
Creators: Howard Chu
Origin: https://github.com/LMDB
Country: United States
Website: http://www.openldap.org/software/repo.html

LMDB is a Btree-based database management library modeled loosely on the BerkeleyDB API, but much simplified. The entire database is exposed in a memory map, and all data fetches return data directly from the mapped memory, so no malloc's or memcpy's occur during data fetches. As such, the library is extremely simple because it requires no page caching layer of its own, and it is extremely high performance and memory-efficient. It is also fully transactional with full ACID semantics, and when the memory map is read-only, the database integrity cannot be corrupted by stray pointer writes from application code.


GitHub description: Read-only mirror of official repo on openldap.org. Issues and pull requests here are ignored. Use OpenLDAP ITS for issues.
Logica (queryLanguage, appeared 2020)
Creators: Evgeny Skvortsov
Origin: https://github.com/EvgSkv/logica/issues
Country: United States
Website: https://logica.dev/

Logica is an open source declarative logic programming language for data manipulation. Logica is a successor to Yedalog, a language created at Google earlier.


GitHub description: Logica is a logic programming language that compiles to StandardSQL and runs on Google BigQuery.

# Define natural numbers from 1 to 29.
N(x) :- x in Range(30);
# Define primes.
Prime(prime: x) :-
  N(x),
  x > 1,
  ~(
    N(y),
    y > 1,
    y != x,
    Mod(x, y) == 0
  );
LOGLAN (pl, appeared 1982)
Origin: Institute of Informatics
Country: Poland


Loglan is a constructed language originally designed for linguistic research, particularly for investigating the Sapir–Whorf Hypothesis. The language was developed beginning in 1955 by Dr James Cooke Brown with the goal of making a language so different from natural languages that people learning it would think in a different way if the hypothesis were true. In 1960 Scientific American published an article introducing the language. Loglan is the first among, and the main inspiration for, the languages known as logical languages, which also includes Lojban. Brown founded The Loglan Institute (TLI) to develop the language and other applications of it. He always considered the language an incomplete research project, and although he released many papers about its design, he continued to claim legal restrictions on its use. Because of this, a group of his followers later formed the Logical Language Group to create the language Lojban along the same principles, but with the intention to make it freely available and encourage its use as a real language. Supporters of Lojban use the term Loglan as a generic term to refer to both their own language, and Brown's Loglan, referred to as "TLI Loglan" when in need of disambiguation. Although the non-trademarkability of the term Loglan was eventually upheld by the United States Patent and Trademark Office, many supporters and members of The Loglan Institute find this usage offensive, and reserve Loglan for the TLI version of the language.
Logo (pl, appeared 1967)
Origin: Massachusetts Institute of Technology
Country: United States


Logo is an educational programming language, designed in 1967 by Wally Feurzeig, Seymour Papert and Cynthia Solomon. "Logo" is not an acronym. It was derived from the Greek logos meaning word or "thought" by Feurzeig, to distinguish itself from other programming languages that were primarily numbers, not graphics or logic, oriented. A general-purpose language, Logo is widely known for its use of turtle graphics, in which commands for movement and drawing produced line graphics either on screen or with a small robot called a turtle. The language was conceived to teach concepts of programming related to Lisp and only later to enable what Papert called "body-syntonic reasoning", where students could understand, predict and reason about the turtle's motion by imagining what they would do if they were the turtle. There are substantial differences among the many dialects of Logo, and the situation is confused by the regular appearance of turtle-graphics programs that call themselves Logo. Logo is a multi-paradigm adaptation and dialect of Lisp, a functional programming language. There is no standard Logo, but UCBLogo has the best facilities for handling lists, files, I/O, and recursion in scripts, and can be used to teach all computer science concepts, as UC Berkeley lecturer Brian Harvey did in his Computer Science Logo Style trilogy. Logo is usually an interpreted language, although there have been developed compiled Logo dialects (such as Lhogho and Liogo). Logo is not case-sensitive but retains the case used for formatting.
Logos (pl, appeared 2010)
Origin: https://github.com/DHowett/theos-logos-examples/issues
Country: United States

Logos is a component of the Theos development suite that allows method hooking code to be written easily and clearly, using a set of special preprocessor directives. Theos is a cross-platform suite of development tools for managing, developing, and deploying iOS software without the use of Xcode. It is an important tool for people building extensions (tweaks) for jailbroken iOS; most extension developers use Theos.



%group iOS8
%hook IOS8_SPECIFIC_CLASS
  // your code here
%end // end hook
%end // end group ios8

%group iOS9
%hook IOS9_SPECIFIC_CLASS
  // your code here
%end // end hook
%end // end group ios9

%ctor {
  if (kCFCoreFoundationVersionNumber > 1200) {
    %init(iOS9);
  } else {
    %init(iOS8);
  }
}
Logres (queryLanguage, appeared 1990)
Origin: Politecnico di Milano
Country: Italy

LOGRES is a new project for the development of extended database systems which is based on the integration of the object-oriented data modelling paradigm and of the rule-based approach for the specification of queries and updates. The data model supports generalization hierarchies and object sharing, the rule-based language extends Datalog to support generalized type constructors (sets, multisets, and sequences), rule-based integrity constraints are automatically produced by analyzing schema definitions. Modularization is a fundamental feature, as modules encapsulate queries and updates, when modules are applied to a LOGRES database, their side effects can be controlled. The LOGRES project is a follow-up of the ALGRES project, and takes advantage of the ALGRES programming environment for the development of a fast prototype.
Logtalk (pl, appeared 1998)
Creators: Paulo Moura
Origin: https://github.com/LogtalkDotOrg
Country: Portugal
Website: http://logtalk.org


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. It provides support for encapsulation and data hiding, separation of concerns and enhanced code reuse. Logtalk uses standard Prolog syntax with the addition of a few operators and directives. The Logtalk language implementation is distributed under an open source license and can run using a Prolog implementation (compliant with official and de facto standards) as the back-end compiler.
Lola-2 (pl, appeared 1994)
Creators: Niklaus Wirth
Origin: Eidgenössische Technische Hochschule Zürich
Country: Switzerland

Lola-2: A Logic Description Language. Lola is a notation (language) for specifying digital circuits (logic). In many ways it resembles a programming language. However, Lola texts describe static circuits rather than dynamic processes. Objects occurring in a description can be variables representing signals or registers. Their values are defined as expressions of other objects and operators representing gates.