nyuuzyou/wikis huggingface dataset:
L00P

L00P is a Brainfuck-derived programming language designed by Georg Westenberger. Its name comes from the fact that every program is enclosed within an implicit loop.
Data are stored within cells of a circular memory array; the number of cells is implementation-defined (8192 in the reference implementation). Each cell is a 16-bit signed integer initialized to 0.
==Instructions==
The language retains Brainfuck's commands except for [ and ]. Additionally, the following commands are provided:
 ; Input at current cell in decimal notation
 : Output from current cell in decimal notation
 0 Set the current cell to 0
 * Multiply the current cell by 2
 _ Multiply the current cell by -1
 # Move n cells to the right where n is the value in the current cell
 @ Set the current cell to the value of the cell you would reach with a # command
 $ Set the cell you would reach with a # command to the value of the current cell
 & Terminate the program
 S Set the current cell to the sign of the current cell's present value
There is also a single control structure ( | ). If the value of the current cell is nonzero, the commands between ( and | are executed; otherwise, the commands between | and ) are executed. The | is optional, and if it is omitted, the cell being zero will result in none of the parenthesized actions taken place. This structure can also be written with square brackets, as [ | ].
==External resources==
* L00P spec
* Compiler written in Perl that translates L00P code to C
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
Category: 2001
LABEL

LABEL is a programming language based on goto-like jumps and loops and whose memory consists entirely of how many jumps have been made.
== Syntax ==
Every command takes a label as input
Command	Description
/ 	Ends a subroutine if it matches the label
\ 	Ends a subroutine if it matches the label
> 	Go to the nearest /label searching forwards as a subroutine
< 	Go to the nearest \label searching backwards as a subroutine
] 	Go to the nearest \label searching forwards as a subroutine
[ 	Go to the nearest /label searching backwards as a subroutine
) 	Go to the nearest /label searching forwards within this subroutine
( 	Go to the nearest \label searching backwards within this subroutine
} 	Go to the nearest \label searching forwards within this subroutine
{ 	Go to the nearest /label searching backwards within this subroutine
: 	Do the next command as many times as label has been run
! 	Output the number of times label has been run, as an ASCII character
? 	Run label an inputted number of times, using whichever run command occurs the most
. 	The next time you would run label, don't
, 	The next time you would stop running label, don't
~ 	Toggle all run commands that refer to label
+ 	Jump ahead a number of commands equal to the label's run count
- 	Jump back a number of commands equal to the label's run count
=== Rule Clarifications ===
1. If a label can't be found, it will start from the beginning of the program and move right or at the end of the program and move left, respectively.
2. When counting how many times label X has been run, subtract the number of times it has been run backward from the number of times it has been run forward.
3. Labels can have numbers at the end, which simply differentiate between different versions of the root label, and affect the same value in memory.
Category:Languages
LAIDBACK

LAIDBACK is a joke language created by John Unger Zussman, and is one of the lesser known programming languages. It was described in the Info World article as follows:
:Historically, VALGOL is a derivative of LAIDBACK, which was developed at the (now defunct) Marin County Center for T'ai Chi, Mellowness, and Computer Programming, as an alternative to the more intense atmosphere in nearby silicon valley.
:The center was ideal for programmers who liked to soak in hot tubs while they worked. Unfortunately, few programmers could survive there for long, since the center outlawed pizza and RC Cola in favor of bean curd and Perrier.
:Many mourn the demise of LAIDBACK because of its reputation as a gentle and nonthreatening language. For example, LAIDBACK responded to syntax errors with the message, SORRY MAN, I CAN'T DEAL WITH THAT. 
Category:Joke languages
Category: Languages
LAIN

LAIN is a esoteric language developed by User:Valtsu0 as his first language. It was designed to be a self modifying language that lacks if statements. The name LAIN is not an acronym and is only capitalized to indicate that the name is supposed to be yelled out loud.
==Syntax==
Any line that doesn't include a semicolon is printed. For example:
 example
will print example
Anything after a semicolon is a comment.
===Variables===
LAIN is a dynamically typed language, that has two data type. They are integers and strings. Variable names cannot include a ; or a ".
 string = "String";
 integer = 3;
 var = string;
An operation can be performed during variable assignation, but only one can be performed at a time. This is the only time operators can be used. Operators are +, -, min and max. Operator must be between two values or variables. The + will perform integer addition when both values next to it can be interpreted as integers. Otherwise it will perform string concatenation. Rest of the operators can only be used on integers.
 integer = 5 max integer;
 string = 4 + "String";
The variable # is always the line number of the next line.
===Input===
Input is taken with a variable followed by a semicolon
 input;
 var;
===Goto===
goto is followed by a integer or string. Line indexing starts at 0 for all purposes. If given a string the destinations will be a label corresponding to that string and if no such label currently exists the destination will be the next line. A label is created by starting a line with :.
 goto integer;
 goto 0;
 goto "label";
 :label;
===Line===
line command changes the specified line to the specified string.
 line integer string;
 line 3 "Hello, world!";
==Code examples==
===Truth-machine===
 var;
 var = var + 3;
 goto var;
 goto 6;
 1
 goto 4;
 0
===99 Bottles of beer on the wall===
 first = " bottles of beer on the wall,";
 second = " bottles of beer.";
 fourth = " bottles of beer on the wall.";
 beer = 99;
 lyric = beer + first;
 line 6 lyric;
 
 lyric = beer + second;
 line 9 lyric;
 
 Take one down, pass it around,
 beer = beer - 1;
 lyric = beer + fourth;
 line 14 lyric;
 
 
 var = beer min 2;
 var = var + 18;
 goto var;
 goto 21;
 goto 4;
 1 bottle of beer on the wall,
 1 bottle of beer.
 Take one down, pass it around,
 No bottles of beer on the wall.
==External resources==
* Imperfect LAIN interpreter made in python 3
Category:Languages
Category:2022
Category:Self-modifying
Category:Implemented
Category:Turing complete
LAMPA

LAMPA(A Low Level AutoMation Programming LAnguage), is an esoteric programming language with no strings, only numbers, and basic operands.
== Examples ==
=== Hello, world! ===
as main.
-- DECLARATION
module stop where.
hiding -1.
module cr where.
let lf 10.
type as lf.
rec proc.
-- END DECLARATION
-- MAIN MODULE
module main where.
let H 72.
type as H.
let e 101.
type as e.
let l 108.
type as l.type as l.
let o 111.
type as o.
let comma 44.
type as comma.
let space 32.
type as space.
let W 87.
type as W.
type as o.
let r 114.
type as r.
type as l.
let d 100.
type as d.
let ! 33.
type as !.
as cr.
as stop.
-- END MAIN MODULE
=== Truth-machine ===
as main.
-- DECLARATION
module 0 where.
type null.
hiding -1.
module 1 where.
type one.
as 1.
-- END DECLARATION
-- MAIN MODULE
module main where.
let input $.
if in input null 0.
if in input one 1.
-- END MAIN MODULE
== External resources ==
* https://github.com/SLNETAIGA/LAMPA (Implement on PHP CLI by Roman Didrag)
Category:Languages
Category:2016
Category:Implemented
LCTDNH

B but very very very encrypted
==Encrytion==
B command’s letter
Into
Base12
Ccl+Base12=var
Flip var
Into
Encrypted letter
==B Programming Language==
 if {A=B} then (
 ) end if statement
 inc var be (66)
 let var be (66)
 print_ascii (66)
 print (B)
 loop (
 ) end loop
 loop [66] times (
 ) end looping
 go to (x,y) with color [(R,G,B)]
Category:Languages
LCode

LCode (aka LoserCode) is a "coding language" made by User:Nitrogen_Dioxide as a joke.
The "official" interpreter is made in C#.
The interpreter accepts any type of file extension.
== Instructions ==
Instruction 	Description
CPR 	Print the given text
CPRVAR 	Print the text at the current cursor position's variable's value
MPR 	Move the current cursor position to the right by 1
MPL 	Move the current cursor position to the left by 1
MPRNUM 	Move the current cursor position to the right by the given number
MPLNUM 	Move the current cursor position to the left by the given number
CPRVAR:NAME 	Print the given variable (from name)'s value
AD (not including different variants)	Add the first number given to the second number given
SB (not including different variants)	Subtract the first number given to the second number given
ML (not including different variants)	Multiply the first number given with the second number given
DV (not including different variants)	Divide the first number given with the second number given
DF 	Define a variable at the current cursor position, setting the name to the first argument and the value to the second argument
GI:VAR,KEY 	Prints "Press any key:" to the console, reads the key input given and creates a variable with the key string as value and the first argument as the name
GI:VAR,KEY,NOPROMPT 	Reads the key input given and creates a variable with the key string as value and the first argument as the name
== External resources ==
* "Official" GitHub page with the compiler and examples
Category:Languages Category:Implemented
LECHEI

LECHEI(Language where changing register possible only by inputing and using it as queue.) is a language by User:ChuckEsoteric08 inspired by FakeScript.
==Commands==
Command 	Operation
inp a 	input string and store it in a.
out a 	output variable a.
enq a b 	concatenate variable a and string b and store it in variable a.
move a b	remove first letter in variable a and store it in variable b.
if a b c	if variable a equals to string b goto command c(Counting starts at 1 or 0. It is implementation defined).
end 	halts
if variable doesn't exist, create it.(not in move or if command.)
==External resources==
Scratch interpreter
Category:Languages Category:Turing complete Category:Turing tarpits Category:Implemented
LFSR CPU

This language consists of a Virtual Machine (VM) specification for a "weird"
processor, and less of a language. What makes this processor weird is that
instead of using a normal Program Counter (PC), one that increments with an adder to
move to the next instruction, this processor uses a Linear Feedback Shift
Register (LFSR) instead to move to the next instructions. This means
instructions are executed in a Pseudo Random order and the execution order
appears obfuscated or scrambled.
The language was create by howerj, much like Muxleq. An implementation
in C is available at here and one that runs on an
FPGA is at here.
This technique has been used in the past with real devices when gates and
transistors were especially scarce. You can make a LFSR with fewer gates and
(that operates at a faster speed) than with a normal Program Counter.
Despite this, this system is capable of running a full blown programming
language, Forth.
The instruction layout is:
 +----------+---------------+-------------------+
 | BIT 15 | BITS 12 to 14 | BITS 0 to 11 |
 +----------+---------------+-------------------+
 | INDIRECT | INSTRUCTION | VALUE / ADDRESS |
 +----------+---------------+-------------------+
The INDIRECT flag determined whether bits 0 to 11 are treated as
a value (not set) or an address (INDIRECT is set).
The INSTRUCTION field is 3-bits in size, the instructions are:
* 0 : XOR : ACC = ACC ^ ARG
* 1 : AND : ACC = ACC & ARG
* 2 : LLS1 : ACC = ARG << 1
* 3 : LRS1 : ACC = ARG >> 1
* 4 : LOAD : ACC = MEM[ARG]
* 5 : STORE : MEM[ARG] = ACC
* 6 : JUMP : PC = ARG
* 7 : JUMPZ : IF (ACC == 0) { PC = ARG }
The PC is only 8-bits in sizes and uses the polynomial 
0xB8. A different polynomial results in a different execution order and
maximum program size.
At least 0x1000 16-bit words are dedicated to the machine.
As the PC is only 8-bits in size the first 256 16-bit instructions are
dedicated to implementing a VM that can be used to execute Forth, on top of
which the Forth interpreter is built. The tool-chain for this system is
written in Forth and is available here at here.
Category:Languages Category:Implemented Category:Low-level
LINR

== Summary ==
LINR is an interpreted language invented by Sam Lord in March 2017. The name alludes to the unconventional order in which the written code may be run.
== Operations ==
LINR has five operations.
Operation	Arguments 	Summary
ADD 	[val/var] [val/var] [var]	Adds the left value or variable to the right value or variable and stores the result in the final variable
SUB 	[val/var] [val/var] [var]	Subtracts the right value or variable from the left value or variable and stores the result in the final variable
MUL 	[val/var] [val/var] [var]	Multiplies the left value or variable and the right value or variable and stores the result in the final variable
DIV 	[val/var] [val/var] [var]	Divides the left value or variable by the right value or variable and stores the result in the final variable
NUL 	[Anything] 	NUL acts as a comment. Anything can be included in its arguments and it's ignored at runtime. It is, however, included in the instruction count.
=== Execution order ===
The order of execution of LINR programs is dependant on the modulus 8 of the number of operations. Starting from line 0 the program is stepped through skipping [linecount]%8 lines. Then, the starting point of the program is increased to 1 and so on. The program completes when all operations have been run. No operation is completed twice.
It is worth noting that only the second section of the code, containing the operations themselves, are taken into account when determining the line skip value.
== Example code ==
The code of LINR is split into two sections separated by an @ symbol. The first half is variable declaration and the second are the operations. Operations may only be performed on float-like values and variables.
 ;
 a;
 b;
 c;
 d;
 e;
 @
 ADD 1 0 a;
 ADD 2 0 b;
 ADD 3 0 c;
 ADD a b e;
 ADD c e e;
 MUL c b d;
 DIV e 2.43 e;
 SUB e 6.78 e;
 NUL Literally anything can go here, probably;
The above code will set ; to be the operation separator, a-e as variables and then all instructions after the @ sign are executed in order.
If the final NUL Literally anything can go here, probably; instruction is removed, the program will hang due to the [linecount]%8 being equal to 0 therefore only allowing the first operation to execute. 
The above code completes with the variables containing the following a:1, b:2, c:3, d:6, e:-4.310864
Each instruction needn't be on a new line, however it is presented here as such to make it more readable.
== Interpreters ==
As of the time of writing, only one interpreter exists for LINR and it's called LINR. See Resources.
== External resources ==
* LINR interpreter called, somewhat inventively, LINR. It's written in C# and offers some crude debugging features.
* Creator, Sam Lord
Category:Languages
Category:Usability unknown
Category:Output only
Category:Low-level
Category:Implemented
LISPS

LISPS was made by User:Yes in 2022, and stood for List Processing Sussy
LISPS is LISP but the docs requires you to play 5000 games of among us.
As such, the person who played 5001 games of among us in thier life shared this info:
It is a modified version of Common Lisp
=== Hello World Program ===
Common Lisp Hello World:
(format t "Hello, World!")
LISPS Hello World:
{{{{{{{{{{{{{{sus{{{(}}}susformat sust sus"Hello, World!"sus{{{)}}}sus}}}}}}}}}}}}}}}}
From what we can make out, the prefix "sus" is always required except in strings,
And that there is an excessive use of curly braces.
Category:Languages
Category:Unimplemented
Category:Turing complete
Category:Joke languages
Category:2022
LITHP

LITHP is a joke language created by John Unger Zussman, and is one of the lesser known programming languages. It was described in the Info World article as follows:
:This otherwise unremarkable language is distinguished by the absence of an "s" in its character set. Programmers and users must substitute "TH". LITHP is said to be useful in prothething lithtth.
Category:Joke languages
Category:Languages
LJAPL

LJAPL (or Literally Just A Programing Language) is a "APL-like" language made by User:Ractangle, and is also Array?'s predecessor
==Commands==
Command	Action
- 	Push a number
 	Halt the program
 	Output as number
 	Output as a charecter
 	Add the two TOS's
 	Multiply the two TOS's
 	Duplicate the TOS
 	Move the BOS to the top
==Examples==
===Hello world===
Outputs the characters Hello, world!
 5a6*+6a+4a2*+3a*7a2*+5a3*+2a+5a7*+7a2*+4a2*+=7a+6a4*+ccccccccccccc
Due to the non-standard encoding used, 65 → ! instead of 33.
==Implementation==
* LJAPL folder in Thewierd repo
* MoreMathRPN Esointerpreter
LLL

LLL is an esoteric programming language designed by Lode Vandevenne in 2012. Programs in LLL are made from a circuit of logic components. Special components allow console input and output. A graphical mode where the circuit can be seen in action is also possible. In theory, an existing CPU could be built in this given its logic diagram.
The language itself is textual, the logic circuits are made from a 2D grid of ASCII characters. Characters are slightly lower level than logic gates.
Every tick, the language updates the state of every part based on neighbor parts. Parts can exist out of multiple ASCII characters. A signal requires one tick per part it goes through.
==Instructions==
The language has no instructions, instead it has cells from which logic gates and other parts can be made.
Cell 	Description
space, . 	Isolator
* 	Wire
+, x 	Wire crossing
b 	Backplane connection
^, >, v, <	Diode
m, ], w, [ 	Inverter
i, I, j 	input
o, O 	Output
0–9 	Mark input or output for console I/O and other special signals
r 	XOR wire
c 	Counter wire
d 	Delay wire
" 	Comment
With wires, diodes and invertors alone, every logic gate can be made, including XOR. The "r" and "c" cells are optional, anything these can do, could also be created from the other cells, but they are added to make them smaller, faster and more convenient.
==Example program==
The following program displays Hello world! on the console.
 *o3 *o0 *o2 *o2 *o0 *o5 *o0 *o0 *o1 *o2 *o2 *o0 
 * * * * * * * * * * * * 
 *o6 *o2 *o3 *o3 *o1 * *o1 *o1 *o4 *o3 *o5 *o5 
 * * * * * * * * * * * * 
 * *o5 *o5 *o5 *o2 * *o2 *o2 *o5 *o5 *o6 * 
 * * * * * * * * * * * * 
 * *o6 *o6 *o6 *o3 * *o4 *o3 *o6 *o6 * * 
 * * * * * * * * * * * * 
 * * * * *o5 * *o5 *o5 * * * * 
 * * * * * * * * * * * * 
 * * * * *o6 * *o6 *o6 * * * * 
 * * * * * * * * * * * * 
 * * * * * * * * * * * * 
 **]* * * * * * * * * * * * * 
 I**>>*]***>>***>>***>>***>>***>>***>>***>>***>>***>>***>>***>>***>>***O0
 O O O O O O O O O O O O 
 1 1 1 1 1 1 1 1 1 1 1 1
==External resources==
* The language's main page
* LLLL, a cellular automaton version of LLL
Category:Languages
Category:Implemented
Category:Cell-based
Category:Two-dimensional languages
Category:Low-level
Category:2012
LLLL

LLLL stands for Lazy Logic Like Language and is a cellular automaton rulset that was designed in 2015https://lodev.org/ca/llll.html. The ruleset allows design of logic circuits (similar to Wireworld).
It is based on the LLL 2D language for describing circuits, and shares similarities with WireWorld and Minecraft redstone.
== Language overview ==
The ruleset consists of 32 states plus a background state. The 32 states consist of 8 electrical components (wire, diode input, inverting input, diode output, inverted output, xor output, counter output, substrate) which all can be in 4 different states (off, head, on, tail).
 States table
Char	Description 	Color
 	background 	BLACK
. 	wire off 	DARK GREY
h 	wire head 	LIGHT GREY
* 	wire on 	WHITE
t 	wire tail 	DARK GREY
a 	diode input off 	DARK BLUE
E 	diode input head 	MEDIUM BLUE
A 	diode input on 	LIGHT BLUE
e 	diode input tail 	DARK BLUE
i 	invertor input off 	DARK ORANGE
J 	invertor input head 	MEDIUM ORANGE
I 	invertor input on 	LIGHT ORANGE
j 	invertor input tail 	DARK ORANGE
b 	diode output off 	DARK GREEN
D 	diode output head 	MEDIUM GREEN
B 	diode output on 	LIGHT GREEN
d 	diode output tail 	DARK GREEN
c 	invertor output off 	DARK RED
S 	invertor output head	MEDIUM RED
C 	invertor output on 	LIGHT RED
s 	invertor output tail	DARK RED
x 	xor output off 	DARK YELLOW
Y 	xor output head 	MEDIUM YELLOW
X 	xor output on 	LIGHT YELLOW
y 	xor output tail 	DARK YELLOW
m 	counter output off 	DARK MAGENTA
N 	counter output head 	MEDIUM MAGENTA
M 	counter output on 	LIGHT MAGENTA
n 	counter output tail 	DARK MAGENTA
u 	substrate off 	DARK CYAN
V 	substrate head 	MEDIUM CYAN
U 	substrate on 	LIGHT CYAN
v 	substrate tail 	DARK CYAN
The rules of execution are lengthy and can be found on the homepage within the rule file
== External resources ==
* LLLL homepage
* conwaylife.com forum discussion about LLLL
Category:2014
Category:Cellular automata
Category:Cell-based
Category:Implemented
Category:Languages
LMCode

LMCode — esoteric programming language. Based on the Little man computer command system. 
LMCode operates on an array of memory cells, also referred to as the tape, each initially set to zero. There is a pointer, initially pointing to the first memory cell. The commands are:
Command	Description
, 	Download a value from INBOX into the accumulator
. 	Upload a value from the accumulator into OUTBOX
~ 	Download a value from the accumulator into the current memory cell
^ 	Upload a value from the current memory cell into the accumulator
> 	Move the pointer to the right
< 	Move the pointer to the left
+ 	Add a value from the current cell to the accumulator
- 	Sub a value in the current cell from the accumulator
? 	Jump to the label !
! 	The label of the command ?
{ 	Jump to the label } 
This does only work if acc>=0
} 	The label of the command {
( 	Jump to the label ) 
This does only work if acc=0
) 	The label of the command (
== Examples ==
=== Double a value ===
,~+.
So the way this works is:
Download a value from INBOX into the accumulator
Download a value from the accumulator into cell 0
Add a value from the cell 0 to the accumulator (double a value)
 
Upload doubled value from the accumulator into OUTBOX
=== The largest element in the list ===
To run the program, you must first upload initial values to cells 0 and 1, then go back to cell 0. 
,~>,~<
Then run
^>-{^?}<^!.
The way this works is:
Upload the first value from cell 0 into the accumulator
Move the pointer to cell 1 
Sub the second value from the accumulator
If acc>=0, jump to label }
Upload the second value from the cell 1 into the accumulator
Jump to label !
Move the pointer to cell 0
Upload the first value from cell 0 into the accumulator
Upload a value from the accumulator into OUTBOX
=== Fibonacci ===
}>>^>+.~<+.~<<^>-<~{
To run the program, you must first upload count of the cycles (into cell 0), decremet of the count - the natural number 1 (into cell 1), first Fibonacci number - the natural number 1 (into cell 2).
== See also ==
CARDboard Illustrative Aid to Computation
OISC
FALSE
Brainfuck
== External resources ==
Article about LMCode, posted on habr.com
Interpreter of LMCode on github.com
Category:Languages Category:Implemented Category:Cell-based Category:Low-level