nyuuzyou/wikis huggingface dataset:
Line Feed

Line Feed is a language by User:PythonshellDebugwindow in which the only valid character is a newline. It shares a file extension (.lf) with LogicF---.
==Commands==
Command 	Definition
(newline)	Nop
All others raise an error.
==Interpreter in Python==
 code = "\n\n"
 assert code == "\n" * len(code), "Invalid character in source code"
Try it online!
Another implementation:
code = "\x01\nf\n"
assert(max(code)==min(code)=="\n")
==Interpreter in Io==
 code := "\n\n"
 if("\n" repeated(code size) == code, 0, fail)
Try it online!
==See also==
* Definitely unusable
Category:Languages Category:Joke languages Category:2020 Category:Unusable for programming Category:Implemented Category:Total
Linear

Linear is a esolang created by User:Yayimhere
== syntax ==
the program is made up of a list of lists separated by spaces. lists themselves are set up like this:
 ⟨n, m⟩
where n and m are positive integers
== semantics ==
for every n, and m we do this function and solve for the lowest x:
\sum_{x}^{n}*\sqrt[m]{n^x}=|\sum_{x}^{n}*\sqrt[m]{n^x}|
now we do a check when we have got to the end of the program: if x's value entered chaotic behaviour the program halts. else it adds a new list thats made up with the first element being x and the second one is x*2. also if at any point x entered linear behaviour the list it started at is deleted
Category:Languages Category:Unknown computational class Category:Unimplemented Category:2024
Linear bounded automaton

A linear bounded automaton (LBA) is an abstract machine that would be identical to a Turing machine, except that during a computation with given input its tape-head is not allowed to move outside a bounded region of its infinite tape, the number of accessible tape-cells being a linear function of the input-size. The tape itself has infinite length in order to accomodate inputs of arbitrary length. (An equivalent alternative version of this model supplies the LBA with a different finite-length tape for each input of different size, the length of the tape being a linear function of the input-size. In this alternative version, there is a supply of infinitely many finite tapes, there being one tape for each input-size.) 
Like the Turing machine, an LBA is a finite state machine equipped with a tape. Unlike a Turing machine system, an LBA system (the finite state machine plus its tape) has only finitely many system states for each input; that is, for each input, an LBA system behaves as a finite automaton. A pertinent difference between an LBA and a FSA is that the number of states of an FSA is fixed for that FSA, while the number of states of an LBA varies as a linear function of the amount of input given to that LBA.
It is possible to show, using the Pumping lemma, that there are languages which are recognized by some LBA that cannot be recognized by any push-down automaton. Linear-bounded automata recognize the class of context-sensitive languages.
==History==
Myhill (1960) introduced LBAs, motivated by the research of Rabin and Scott (1959) on finite automata.
==See also==
* :Category:Linear bounded automata (a list of languages on this wiki which have equivalent power to an LBA)
==External resources==
* Wikipedia:Linear bounded automaton
Category: Computational models
Linear bounded brainfuck

Linear bounded brainfuck is brainfuck as a linear bounded automaton, created by User:PythonshellDebugwindow.
==The input-size function==
The function of the input-size used is l+p, where l is the length of the input (1 if no input) and p is the length of the program.
==Commands==
The same as in brainfuck, but minus input (which is preloaded onto the tape). The tape without input on it is initialized to all zeros, and all cells are bytes.
Command	Description
> 	Move the pointer to the right
< 	Move the pointer to the left
+ 	Increment the memory cell under the pointer
- 	Decrement the memory cell under the pointer
. 	Output the character signified by the cell at the pointer
[ 	Jump past the matching ] if the cell under the pointer is 0
] 	Jump back to the matching [ if the cell under the pointer is nonzero
Going out of the tape bounds causes the program to error and exit.
==Examples==
===Cat program===
This version doesn't actually error at the end because for an input of length p, it has a tape of length p + 4.
 [.>]
This version does error at the end because it keeps going along the tape.
 [.>]+[>+]
===Truth-machine===
 [>+>+<<-]>------------------------------------------------[>.<].
==Implementation==
def run_lbf(code: str, textfile=False, starting_input=) -> None:
 pointer = 0 # for instructions
 location = 0 # for tape
 counter = 0
 if textfile:
 code = .join(open(f'{code}', 'r').readlines())
 corresponding_bracket = {} # dictionary where the values are the corresponding bracket positions of the keys
 bracket_stack = [] # acts as a stack for the last bracket
 for num, char in enumerate(code):
 if char == '[':
 bracket_stack.append(num)
 elif char == ']':
 assert len(bracket_stack) > 0, 'unmatched ]'
 corresponding_bracket[num] = bracket_stack[-1]
 corresponding_bracket[bracket_stack[-1]] = num
 bracket_stack.pop()
 assert len(bracket_stack) == 0, 'unmatched ['
 tape = [ord(x) for x in starting_input] + ([0] * len(code))
 while pointer < len(code):
 if code[pointer] == '>':
 location += 1
 assert location < len(tape), f'Cannot move right from position {len(tape)}'
 elif code[pointer] == '<':
 assert location > 0, 'Cannot move left from position 0'
 location -= 1
 elif code[pointer] == '+':
 tape[location] = (tape[location] + 1) % 256
 elif code[pointer] == '-':
 tape[location] = (tape[location] - 1) % 256
 elif code[pointer] == '.':
 print(chr(tape[location]), end=)
 elif code[pointer] == '[':
 if tape[location] == 0:
 pointer = corresponding_bracket[pointer]
 elif code[pointer] == ']':
 if tape[location] != 0:
 pointer = corresponding_bracket[pointer]
 pointer += 1
Category:Languages
Category:2020
Category:Linear bounded automata
Category:Brainfuck derivatives
Category:Implemented
Category:Low-level
Linefuck6

Linefuck6 is a version of Brainfuck, but it's only made up of 6 - not 8 - different characters, which are lines. It was invented by Random Idiot
==Commands==
These lines are:
Linefuck6	Brainfuck
– 	>
_ 	.
~ 	,
' 	[
" 	]
==Architecture==
As you might have noticed, there is no - or < in this Language. If you increase the pointer above 10, it goes to 1.
If you increase the value above 62, it goes to back to 0.
==Data Types==
Besides its peculiar integer range from 0 to inclusive 62, Linefuck6 employs a special encoding for characters, distinct from the ASCII table. This custom table is:
Code range	Character group
0-25 	a-z
26-51 	A-Z
52-61 	0-9
62 	SPACE
==Examples==
===Hello World===
This is Hello World in Brainfuck:
-[------->+<]>-.-[->+++++<]>++.+++++++..+++.[--->+<]>-----.---[->+++<]>.-[--->+<]>---.+++.------.--------.
And this is Hello World in Linefuck6 (I'm bad at using loops in brainfuck so I think it can be done better):
---------------------------------_–
----_
-------__
---_–
--------------------------------------------------------------_–
–––––––
---------------_–
_---_–
------------_–
---_
===Cat program===
An infinitely repeating cat program is presented in the following:
 -'–~_–––––––––"
==Interpreter==
* Common Lisp implementation of the Linefuck6 programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:Languages Category:Brainfuck derivatives Category:Cell-based Category:Implemented Category:Finite state automata
Lines

Lines is a language based on :///, but with input.
==Specification==
The program is interpreted exactly as in ///, with one exception. If \| is encountered, rather than doing something with |, the program gets one character from the standard input.
==Examples==
All of the examples for /// are valid in Lines, as long as they do not contain | anywhere.
===Read a character and print it===
 \|
===Read a character and print it twice===
 /~/\|/~~
(Both this and the next program freeze if the user inputs a ~.)
===Read a character and print it, unless it is a q===
 /~/\|//q//~
==Interpreter==
 import java.util.Scanner;
 public class Lines {
 public static void run(String prog) {
 Scanner input = new Scanner(System.in);
 input.useDelimiter("");
 StringBuilder program = new StringBuilder(prog);
 program:
 while (true) {
 while (true) {
 if (program.length() == 0) {
 break program;
 }
 if (program.charAt(0) == '\\') {
 char next = program.charAt(1);
 if (next == '|') {
 next = input.next().charAt(0);
 }
 System.out.print(next);
 program.delete(0, 2);
 } else if (program.charAt(0) == '/') {
 program.deleteCharAt(0);
 break;
 } else {
 System.out.print(program.charAt(0));
 program.deleteCharAt(0);
 }
 }
 StringBuilder pattern = new StringBuilder();
 while (true) {
 if (program.length() == 0) {
 break program;
 }
 if (program.charAt(0) == '\\') {
 char next = program.charAt(1);
 if (next == '|') {
 next = input.next().charAt(0);
 }
 pattern.append(next);
 program.delete(0, 2);
 } else if (program.charAt(0) == '/') {
 program.deleteCharAt(0);
 break;
 } else {
 pattern.append(program.charAt(0));
 program.deleteCharAt(0);
 }
 }
 StringBuilder replacement = new StringBuilder();
 while (true) {
 if (program.length() == 0) {
 break program;
 }
 if (program.charAt(0) == '\\') {
 char next = program.charAt(1);
 if (next == '|') {
 next = input.next().charAt(0);
 }
 replacement.append(next);
 program.delete(0, 2);
 } else if (program.charAt(0) == '/') {
 program.deleteCharAt(0);
 break;
 } else {
 replacement.append(program.charAt(0));
 program.deleteCharAt(0);
 }
 }
 String patternStr = pattern.toString();
 String replaceStr = replacement.toString();
 int index = program.indexOf(patternStr);
 while (index != -1) {
 program.replace(index, index + pattern.length(), replaceStr);
 index = program.indexOf(patternStr);
 }
 }
 }
 
 public static void main(String[] args) {
 Scanner scanner = new Scanner(System.in);
 String line;
 while (!(line = scanner.nextLine()).isEmpty()) {
 run(line);
 System.out.println();
 }
 }
 }
== See also ==
itflabtijtslwi
Category:Languages
Category:String-rewriting paradigm
Category:Implemented
Category:Self-modifying
Category:Turing complete
Category:2015
Lines are cool

Lines are cool is an esolang made by .
== Commands ==
Note that the boxes do not need to be exact. They can be different.
Lines can have arrows at the end of them, but they are not needed. Mainly only used for clarification.
More commands may be added in the future.
=== Start and end ===
To start a program, use this.
To terminate a program, use this.
=== Print ===
To print something, put it in a blue box.
Blue text means to print a string. Red text means a variable. Green text means a number.
=== Variables ===
To define a variable, put the variable name in red text, and its value next to it in green text (optionally, otherwise it goes to 0), and all of that goes in a red box.
You can also set it to another variable, or a string in blue.
=== Operations ===
Put the operations in a mini-box inside of another box. An example would be:
=== If ===
If is like this:
=== User input ===
Just use a purple circle to represent user input.
=== Red lines ===
Red lines store values on them. To turn them into variables, put a red box with a name.
=== Functions ===
Surround a code snippet into a colored box (apart from black red and blue) with a label above, and then use that box with the label when you want to use that code snippet.
Variable names that start with "t_" are temp variables to be used in functions and not anywhere else.
=== Merger ===
A merger merges code streams back into eachother. An example was used in the example for functions.
== Examples ==
More exmaples may be added in the future.
=== Hello World ===
=== Truth-machine ===
=== 7 bottles of tommyaweosme ===
(note: this one uses blue for numbers)
=== A+B problem ===
=== Looping counter ===
=== Factorial ===
==See also==
* 100px|link=Nice, a similar language.
Category:Languages
Category:Non-textual
Lingua abstrusa

:This article needs a complete sort-out. It is also unfinished.
lingua abstrusa is an esoteric programming language based on the Latin language.
== Language Features ==
The language is made up by definitions of objects called viri. A single one of these objects is called a vir. Each vir has, at most, one patronum, and many clientes. These are defined as follows:
 Augustus cliens Claudii est
Which is equivalent too:
 Claudius patronus Augusti est
Note that all virorum names must begin with a capital letter, must be second declension masculine with an -us ending in the nominative, and must be unique.
Each vir has an occupation, which defines their role in the program.
Occupation	Declension	Purpose
agricola 	1st 	Creates cibos
artifex 	3rd 	Creates artes
mercator 	3rd 	Moves cibos and artes around, at a cost
scriba 	1st 	Writes things down for later recall
sacerdos 	3rd 	Controls I/O
Each viri occupation is defined with various parameters, for instance:
 Claudius agricola est
 Claudius cibos CXVII facit die
Which means, Claudius is a farmer who grows 117 units of food a day.
Agricolae and artifeces sell all their available wares to every merchant that visits them.
Every unit must buy 10 cibos a day, otherwise they die, and as such are unusable for the remainder of the program's execution. They must buy 1 artem every 28 days, otherwise they cannot do their job, and are as such useless until they get the required number of artes (if they go another 28 days, they need 2 artes, etc.) or die. They can only buy from merchants, and cannot use objects that have not came from merchants (i.e., that they have made themselves). The exception to this rule is sacerdotes, who do not need to eat or use tools, and have no need for money.
Items can be donated to sacerdotes by agricolis, artificibus, and mercatoribus. For each sacerdotem (ordered alphabetically), at the end of each day the number of cibi he has recieved is outputted (if 0, nothing is outputted), followed by the character with an ASCII value of the number of artes he has recieved (if none, nothing is outputted). Donation uses the word donit and takes precedence over trading.
Scribae record things, such as how many cibi have been bought by a mercator in the past week, or how many sestertios an agricola has spent. They then publish this after a set amount of time. This publishment, called liber [nomen scribae]], can be used in place of any number.
Numeric input is defined as sacerdos omen vidit. Similarly, character input is defined as sacerdos bonum accepit. If scriba does not notit this, the input is discarded.
Category:Pseudonatural
Category:Languages
Linguine

Linguine, created by Jeffry Johnston in November 2005, is designed as a "flattened Spaghetti", and adds unbounded memory and cell values, negative cell indices, unlimited pointers, and multiple commands per line.
==Examples==
Hello World
 1[0=72,0$,0+29,0$,0+7,0$,0$,0+3,0$,1=32,1$,0-24,0$,0+24,0$,0+3,0$,0-6,0$,0-8,0$,1+1,1$,1-23,1$]0
Cat program
 1[0?,0$,0~10:0]1
Fibonacci sequence calculator
 1[0=32,2=1,1#,0$,2#]2
 2[1+*2,3=*1,1=*2,2=*3,0$,2#]2
Digital root calculator 
 1[1?,1~10:3,0+*1,0-49,0<9:2,0-9]2
 2[0+1]1
 3[0#,1$]0
ROT13 
 1[-2?,-2~10:3,-2<65:2,-2<91:5,-2<97:2,-2<123:6]2
 2[*-1=*-2,-1+1]1
 3[*-3~0:4,*-3$,-3+1]3
 4[-2$]0
 5[-2+13,-2<91:2,-2-26]2
 6[-2+13,-2<123:2,-2-26]2
==Computational class==
A Brainfuck implementation is given in the spec, featuring 8-bit (wrapping) cells and the required unbounded memory tape.
 
==See also==
* Spaghetti, the language Linguine was based upon
==External resources==
* Language Specification and Example Code
* Python implementation and many examples
* Language home, including programs written by Keymaker and jix
Category:Languages
Category:Turing complete
Category:Implemented
Category:2005
Linguistic Calculus

The Linguistic Calculus (LC) was created in 2013 and patterned after natural language and the lambda calculus, with the idea to make code that could be 
* Written as prose
* Be read aloud in a consistent manner
* Interesting to write
== Syntax ==
The syntax of LC is given by the following grammar. Please note that white space is only valid in places where white space is denoted in the grammar
 program := sentence+
 sentence := phrase '.'
 phrase := assign | apply
 assign := 'as' symbol ' ' body
 apply := 'ap' ' ' body ' ' body
 body := phrase | ref | lam
 ref := 'rf' symbol
 lam := 'lm' symbol ' ' body
The symbol production denotes a identifier consisting of letters
== Phonetics == 
* Symbols are pronounced as themselves
* as- : "Assign-the-value-that-follows-to"
* ap- : "Use-the-following-value-as-parameter-in-the-function-that-follows-it"
* rf- : "In-the-current-scope-reference"
* lm : "The-function-with-the-following-body-and-parameter"
== Turing-completeness ==
Unless I've overlooked something, this should be turing complete as it is simply a encoding of the lambda calculus
Category:Languages Category:2013 Category:Pseudonatural Category:Functional paradigm
LinuxLang

LinuxLang is an esoteric programming language designed and implemented by User:Local Kings. It was inspired by script kiddies who think that Linux is a programming language.
Source
== Examples==
=== Hello, world ===
linux Hello, world!
=== Foobar with variables ===
li foo_var foo
li bar_var bar
linux {foo_var} {bar_var}
=== User input ===
linux Enter variable
li a !inu
linux Variable is {a}
More examples are in the github page
Category:2021
Category:Joke_languages
Category:Languages
Category:Implemented
Liquid

This esoteric programming language was designed by Jonathan Todd Skinner. He is known as user User:Jonskinner.
Liquid is as of yet an unimplemented esoteric programming language, that attempts to create an esolang based entirely on the concept of liquids. From now on when the word liquid is used it will refer to the esoteric programming language not the property of matter.
The principle of Liquid is fairly simply. Picture, a series of 30,000 containers on a conveyor belt, as they pass along a "tap" maybe instructed to turn on and drop a fixed amount of water into the container. Tubes hooked into the container allow fluid to flow from them, depending on the logical operator or arithmetic operation, or depending on various other factors. A printer or device will output the results into human readable form. Think of it has a hydro-turing machine or Brainfuck meets water. It is interesting to note that a MIT student has actually built a fluid computer, fluid computers are not a new idea either as you would assume.
== Instructions, commands, syntax, etc. ==
<nowiki>
\ - Turn "tap" on
lets water flow, it is the beginning 
statement like C's curly braces, before any statement other 
then the logical operation, halt instruction, output instruction or jump instruction gets executed the tap must be 
turned on.
/ - Turn "tap" off -- the opposite effect of "tap" on
-> - Value of accumulator "flows" into next container
<- - Value of accumulator "flows" into the previous container
: - Is the logic operator
:' - If value of previous container, and the present container 
are both the same then allow value to flow into the next container
:. - If value of previous container, and the present container are 
not both the same then allow value to flow into the next container
:~ - If value of the present container is less than the previous container 
then carrying out the next command, if it is not less than the previous 
container then skip the next instruction
{ - Jump past the matching } if the container behind/under the pointer is 0
} - Jump past the matching {
? - Read one character/integer from input and place it into the current container
" - Output the value of the current container
; - Is the arithmetic operator
;+ - Increment the value of the current container by one
;- - Decrement the value of the current container by one
% - Is the value manipulator
%y - Move value of y into accumulator
%% - Current value of the accumulator is now an integer
%$ - Current value of the accumulator is now a character(ascii-based)
! - Halt, turn off all taps and stop the conveyor belt! 
This instruction ends the program.
#x - Jump back/forward to the xth container
</nowiki>
== Liquid machine language ==
In theory it is possible that an entire architecture of a microprocessor or CPU could be based on the ideas presented.
== External resources ==
An article about how a MIT student constructed "programmable water", a fairly simple but working hydrocomputer
Category:Languages
Category:Turing complete
Category:2007
Category:Unimplemented
Category:Cell-based
LisL/examples

:This page is an orphan.
"Hello, World!" program:
(write "Hello, World!")
Truth-machine:
(set input (read))
(write input)
(if (= input "1") (
 (while opt (
 (write "1"))))
 elif (= input "0") ()
 else (
 (write "Must enter 1 or 0")))
Ackermann function:
(guide ack a (
 (args a (x y))
 (if (= x 0) (
 (+ y 1))
 elif (= y 0) (
 (ack (- x 1) 1))
 else (
 (ack (- x 1) (ack x (- y 1))))))
Category:Examples
Lisp2d

Lisp2d is a syntax replacement/extension for lisp created as a joke by shinh, who also compiled an interpreter for it to befunge. It allows bracketed expressions to travel vertically as well as the usual horizontal.
== Example ==
(defun fizzbuzz ^ (fizzbuzz 1) @
 ^ zzuB ( 0 (5 n dom)
 i ^
 f v ^ q
 ( eq ^
 ^ fi) ^ v m
 e o
 q l f d
 i i
 n (mod n 15) 0) Fizzbuzz v n
 1 q 3
 0 e v
 1 (if v
 v 0
 t v
 n n
 i i F
 l r i
 p ^ z
 (if v ^ z
 1
 n
 v
 n v
 v
 + v
 v zzubzzif )
== External resources ==
* Blog post with example
* Implementation in C
Category:Languages
LispNTI

LispNTI (an acronym meaning "Listen, It's Shit, Please Never Try It") is a minimal Lisp-like language created by Katrina Scialdone. The language's primary conceit is that instead of implementing a proper list parser, its interpreter implementation (written in NodeJS) uses Regex replacements to convert the program into valid JSON, which is then parsed by Javascript's built-in JSON parser.
== External links ==
* Github Gist
Category:Languages
Category:2019
Category:Functional paradigm
LispSpace

LispSpace is a Lisp syntax that uses whitespace for brackets. This should work with any Lisp that doesn't explicitly need reader macros. The whitespace size is exactly 2 spaces, no more, no less. Space count on empty lines does matter, as it can mean an s-expression ending.
== Format ==
2 spaces correspond to an s-expression. For example,
 A
 B
 C
 D
is equivalent to
 (A (B C) D)
To seperate 2 s-expressions of the same level, you can use tab (not spaces) to seperate them. For example,
 A
 B
 C	
 D
 E
 F
is (where \s is 2 spaces, \t is tab and \n is newline)
 \sA\n\s\sB\n\s\sC\t\n\s\sD\n\s\sE\n\sF
which is equivalent to
 (A (B C) (D E) F)
Examples
Hello world function (Common Lisp)
 defun
 hello
 	
 format
 t
 "Hello, World!"
Define a square function, and execute it with 5 (Common Lisp)
 defun
 square
 x	
 *
 x
 x
 
 square
 5
Category:Joke languages Category:2022 Category:Unimplemented Category:Languages
ListLang

ListLang is an esoteric programming language that finds its inspiration in Befunge. It is a stack-based language with arithmetic and logical capabilities.
==Overview and Tutorial==
An overview and tutorial of ListLang is available at the ListLang Wiki.
==Examples==
===Hello World===
 0dlroW391+*2+491+*4+olleH["],
===Factorial of 5===
 0352**2+552**8+50352**2+fo352**2+lairotcaf352**2+gnitaluclaC["],.["],011[,_1+_5-],[:+:],.
Category:Languages Category:Implemented Category:2016 Category:Implemented Category:Stack-based