nyuuzyou/wikis huggingface dataset:
LaserFuck

LaserFuck is a 2d brainfuck derivative made by User:CappyIsCrappy.
== Memory ==
In LaserFuck, there is a tape with infinite cells in both directions, and the cells store signed 32-bit integers (-2147483648-2147483647).
== Commands ==
=== Laser movement ===
A laser's starting point is marked by a o.
Note that the direction the laser goes in is randomly chosen.
Lasers can be deleted with x.
Execution ends if no more lasers exist.
When the program ends, the value of all used cells are printed in decimal with line breaks (if first byte is 0xFF (aka ÿ) outputs unicode with no line breaks), except those of negative numbers.
Lasers can be reflected with the mirror characters: /\_|.
There are also conditional mirrors:
 ( act as _ if pointed cell not 0, else skip this.
 ) act as | if pointed cell not 0, else skip this.
Lasers can be duplicated with the *.
Direction also randomly chosen, can't duplicate backwards or forwards since that's where the original laser went from and will go to, respectively.
 
Their direction can also be set directly with:
 { left
 } right
 ^ up
 v down
The brackets ([]) don't make sense in 2d, so they have been replaced with the bridge: #
It just skips over the next command the laser will go to.
=== Notes ===
All brainfuck commands are preserved (except the square brackets and .) and all invalid commands are ignored.
== Examples ==
===Hello, world!===
By User:Bangyen:
ÿ}>+++++++>++++++++++>++++++++++>++++++++++>+++++++++++>++++>+++>++++++++v
 ^ { {v+++>++++++++++>++++++++++>+++++++++++>+++++++++++>+++{
 x++>+>+>>++>+>+>++>++>+>++>{
 }}++++++++++v } }<#/)>-#/)+++v } }>>>++>++>>+>>+++>>+>++>>+v } }<#/)>-#/)^
|o^ }#^)#^ / }#^)#^ /
 _ }#^)#^ / }#^)#^ /
=== Binary RNG ===
 }+-x
 |o+x
 }+-x
50% chance of printing 0, 50% chance of printing 1.
=== Cat program (until NUL) ===
 ÿ/\
 |o},#/)x
 _\> /
input, if 0 then end and output everything as unicode, else go to next cell and repeat.
==Implementations==
A Rust interpreter by User:Bangyen.
== See also ==
* brainfuck
* AsciiDots
* Half-Broken Car in Heavy Traffic
Category:Turing tarpitsCategory:Brainfuck derivativesCategory:ImplementedCategory:2022Category:Cell-basedCategory:Two-dimensional languages
Laser Pointer

Laser Pointer is a 2D esolang created by User:AnotherUser05. This is basically a different version of Ice box.
==Syntax==
 Lasers actiavte anything that touches it.
 Any character that's noramlly used for a command used in an input, then it'll be ignored.
 
 --Requires Activating--
 > Laser shooter (right)
 < Laser shooter (left)
 v Laser shooter (down)
 ^ Laser shooter (up)
 @ Activate surrounding tiles each frame.
 & Activates surrounding tiles.
 $ Creates a new variable with the name equal to the character to the right or left.
 = Set the variable to the left to the character to the right.
 * Add the value from the right to the end of the variable to the left.
 ` Add the value from the right to the variable to the left.
 ~ Subtract the value from the right to the variable to the left.
 : Output the variable to the right.
 ; Gets an input and stores it into the variable to the right.
 % Pushes anyhting that's on the opposite side of activation. Basically a piston.
 ? If the variable to the right or left does not equal to 0, then follow the pipes. Else ignore.
 . Terminate the program.
 
 --Misc--
 # Blocks lasers.
 0-9 Acts as portals.
 | Upwards pipe.
 - Sideways pipe.
 + Pipe connector.
 / Mirror
 \ Mirror
 ! Activates the surrounding tiles upon program start.
==Examples==
===Hello World===
 .
 !v / \ / \ / \ / \ / \ / \ :P
 $P*HP*eP*lP*lP*oP*,P* P*WP*oP*rP*lP*dP*!
 \ / \ / \ / \ / \ / \ / \ /
===Truth Machine===
 !>$P\ +-&v /\
 ;P| v :P
 P?-+ 1\ /
 :P \
 . 1 %
 \ /
===Cat Program===
 !
 v
 $c
 ;c
 :c
 .
===Not finite loop===
 1
 %
 /
 !> \
 v \ /
 1
Category:Languages Category:Two-dimensional languages Category:Thematic Category:Concurrent programming
Laughing my ⁫ off

Laughing my ⁫ off (The unprintable character between the two spaces is ASS (ACTIVATE SYMMETRIC SWAPPING), U+206B), a.k.a Laughing my ASS off, a.k.a lmao, is an esolang invented by User:None1. It is like, and inspired by turning tarpits, but it is not, because it is based on Deadfish!
==Commands==
 (ASS, U+206B):⁫ Switch to the next command
 ⁪​(ISS, U+206A): Run the command
Command table:
 idso
 ^
The commands use unprintable characters, so programs in this esolang are invisible.
==Examples==
===XKCD Random Number===
 [⁪​⁪​⁪​⁪​⁫⁫⁫⁪​]
(Brackets are added only for being easy to copy and paste, and are not part of program.)
The unprintable characters used are:
 ISS ISS ISS ISS ASS ASS ASS ISS
==Translator to Deadfish in Python==
a,b,c=input(),0,'idso'
for i in a:
 if i=='\u206a':
 print(c[b],end=)
 elif i=='\u206b':
 b=(b+1)&3
Category:Languages
Category:Joke languages
Category:2024
Category:Deadfish derivatives
Category:Output only
Category:Implemented
Category:Total
Laundry shop

Laundry shop is an esoteric programming language that is influenced by laundry washing.
==Syntax==
 add laundry: add a piece of laundry onto the laundry stack (to the front of the program). bottom is a special piece of laundry that is on the top of the pile of laundries.
 lift number of times lifted: lift the bottom of the laundry number of times lifted.
Category:2019
Category:Languages
Category:Unimplemented
Category:Stack-based
Category:Self-modifying
Category:Output only
Category:Unknown computational class
Lawrence J. Krakauer's decimal computer

Lawrence J. Krakauer's decimal computer was an educational language invented after 1965 for teaching programming to children in a camp. It was implemented as an emulator on a PDP-1 machine. 
The computer has a memory of 1000 words, each a four-digit nonnegative number. Instructions are one word each, with a one digit opcode and a three-digit address or operand field. The computer can do simple arithmetic instructions on the one-word accumulator and a memory operand: add, subtract, multiply, divide. Oddly all four of these instructions are saturating, so subtraction results in 0 if the numerical result would be negative. It also has a jump and a conditional skip instruction, the latter skips if the comparison is equal. Indirect memory access is done using a code-modifying instruction that writes into the address field of an instruction. There are also custom IO devices defined. 
*“My emulated decimal computer” by Lawrence J. Krakauer
Category:Languages
Category:Before 1993
Category:Implemented
Category:Self-modifying
Category:Low-level
Lazy

Created by User:MagiMaster in 2006 (and conceived much earlier). Its main goal is to use lazy evaluation and have functions as first-class objects. Also, it tries to do everything as a function definition.
Currently this specification is incomplete.
== Example ==
A simple example is the cat program:
 main()=output(input())
Another example:
 fib(0)=1
 fib(1)=1
 fib(n)=+(fib(-(n,1)),fib(-(n,2)))
 main()=output(fib(input()))
== Built-in functions ==
* +(x,y), -(x,y), *(x,y), /(x,y), %(x,y)
* input(), output(n)
== Computational class ==
Lazy is Turing-complete as it includes the μ-recursive functions.
To show this, the only non-trivial function to define is μy f(y,x1,...,xk) (which does not actually have y as parameter, y is bound by the μ), which for a specific f can be given as follows:
 μy f(y,x1,...,xk) = g(0,x1,...,xk)
 g(n,x1,...,xk) = if0(f(n,x1,...,xk),n,g(+(n,1),x1,...,xk))
 if0(0,a,b) = a
 if0(n,a,b) = b
Category:Languages
Category:Functional paradigm
Category:2006
Category:Usability unknown
Category:Turing complete
Category:Unimplemented
Lazy K

Lazy K, designed by Ben Rudiak-Gould, is a Turing tarpit based on combinatory logic. It is lazily evaluated and purely functional.
==History==
Lazy K was designed to address a shortcoming of Unlambda; namely, its lack of functional purity. Lazy K's author felt that the functional programming paradigm needed an analog to the imperative paradigm's Brainfuck, and Unlambda was simply not it.
Lazy K was submitted to the 2002 Esoteric Awards.
==Instructions==
Lazy K is based on the SKI combinators. It provides several syntaxes for representing them:
* Combinator calculus style: S, K, and I characters are used to represent those combinators, with parentheses for disambiguation.
* Unlambda style: s, k, i, and a binary application operator ` are used.
* Iota and Jot style, each using the notation from its respective language.
i is a valid expression in both Unlambda and Iota, and with different meanings, so the Unlambda meaning takes precedence in this case.
==Input and output==
Rather than side effects, input and output in Lazy K are "front- and back-effects". A program is treated as a function mapping all possible inputs to all possible outputs.
Characters are represented as Church numerals from 0 to 255, with 256 indicating end of file. The list of input characters is infinite, and the first 256 is followed by an infinite number of 256s.
Any characters following the first number of 256 or greater in the output list are not used. The reference implementation returns n-256 as an exit code, where n is the number terminating the output list.
== Lazier ==
The implementation of Lazy K provides a meta-language, consisting of the lambda calculus written in Scheme notation, which can be compiled into Lazy K. Many of the example programs are written in this.
== Hello world ==
`k``s``si`k``s`k```sii``s``s`kski``s``s`ksk``s``s`ksk```s``siii``s``s`kski`k``s``si`k``s``s`ksk```s``s`ksk
i``s`k``s``s`kski``s``s`ksk```sii``s``s`kski`k``s``si`k``s`k```sii``s``s`kski```sii``s``s`ksk``s``s`kski`k
``s``si`k``s`k```sii``s``s`kski```sii``s``s`ksk``s``s`kski`k``s``si`k``s``s`ksk``s`k``s``s`kski``s``s`ksk`
`s`k``s``s`kski```sii``s``s`ksk``s``s`kski`k``s``si`k````s``s`ksk```s``siii``s``s`kski`s``s`ksk```sii``s``
s`ksk``s``s`kski`k``s``si`k``s`k``s``s`kski```s``siii``s``s`kski`k``s``si`k``s`k``s``s`ksk``s`k``s``s`kski
``s``s`ksk``s``s`kski``s``s`ksk```s``siii``s``s`kski`k``s``si`k``s``s`ksk``s`k``s``s`kski``s``s`ksk``s`k``
s``s`kski```sii``s``s`ksk``s``s`kski`k``s``si`k``s`k``s``s`kski``s``s`ksk``s`k``s``s`kski``s``s`ksk```sii`
`s``s`ksk``s``s`kski`k``s``si`k``s`k```sii``s``s`kski```sii``s``s`ksk``s``s`kski`k``s``si`k```s``s`kski``s
`k``s``s`kski``s``s`ksk```sii``s``s`kski`k``s``si`k``s``s`ksk``s`k``s``s`kski```s``siii``s``s`kski`k``s``s
i`k``s`k``s``s`kski``s``s`ksk```sii``s``s`kski`k``s``si`k```sii```sii``s``s`kski`k```sii```sii``s``s`kski
==See also==
* Jot
* Unlambda
==External resources==
* Lazy K
* Submission to 2002 Essies
* Two backups of the above distribution: 1 2
Category:Languages
Category:Implemented
Category:Turing tarpits
Category:Turing complete
Category:Functional paradigm
Category:2002
Lazy evaluation

Lazy evaluation or call-by-need is an evaluational plan that waits to process data until it is needed. This is in contrast with strict evaluation, where data is processed as soon as it is seen. As a result, the computer only performs the work necessary to output the final result. Though this may strike the casual reader as a brilliant idea, this approach may result in overhead costs required to store and manage the incomplete processes, often referred to promises, thonks, or futures.
To illustrate, consider the infamously lazy lists of Haskell. Haskell's lists only generate as many of their items as needed. This becomes troublesome when, for instance, summing all the items in the list. Now the Haskell computation must assemble a calculation object with partially applied addition on the entire list and then calculate an often huge expression spontaneously. Such an action can crash the program due to memory overflow. Meanwhile, a strict evaluator would merely store the running total of the summation.
Despite this, lazy evaluation has its merits. Among these are the ability to declare unbounded/infinite lists of values, the evaluation of whose elements can be deferred until necessary. This demonstrates that, while strict evaluators may be easier to implement, both execution strategies have their merits.
== Esolangs that utilize lazy evaluation ==
*Aardvark (?)
*Lazy Prefix
*Labra
*Revapp
*01_
(See here for a more complete article on the subject)
Category:Concepts
Lazyfuck

Lazyfuck is a trivial brainfuck substitution that requires the least possible effort to type on an ergonomic keyboard. (All keys used in lazyfuck are highly frequent letters in English, so they have been optimized by the keyboard to require the least force to press.)
Furthermore, the brainfuck commands have been ordered by frequency of appearance, according to the frequency of English letters. Therefore, if you're using a highly frequent brainfuck command (mapped to lazyfuck), it's a lot easier to press on the keyboard than a less frequent command. This makes full use of the ergonomic design of the MacBook Pro keyboard.
== Commands ==
Lazyfuck	brainfuck	Description
e 	> 	Move pointer east
t 	< 	Move pointer west
a 	+ 	add 1
o 	[ 	open a loop
i 	] 	close ("blizu") a loop
n 	- 	subtract ("levon") 1
s 	. 	display a character
r 	, 	read a character
== Example programs ==
=== Hello, World! ===
aaaaaaaaoeaaaaoeaaeaaaeaaaeattttnieaeaeneeaotitnieesennnsaaaaaaassaaaseestnstsaaasnnnnnnsnnnnnnnnseeaseaas
The same in brainfuck:
++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
== Implementations ==
Implementation in sed (transpiles to brainfuck; requires -E flag):
y/etaoinsr/><+[]-.,/
== See Also ==
* Alphuck, which inspired this language
Category:Languages
Category:2023
Category:Brainfuck equivalents
Category:Cell-based
Category:Joke languages
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Lbj

Lbj (Lego Block Jenga) is an esoterical language created by User:Cinnamony.
==Commands==
* A red 2x2 is a print block, printing what value is on top of it.
* A blue 2x2 is a user input block, representing whatever value the user puts in.
* A green 2x2 is a forever loop, that does things forever.
* A green 4x2 is an if loop, that does something is the value next to it is 1.
* A pink 2x2 is a variable, when on the bottom level or inside a loop, it is a set pink variable to.
* An orange 2x2 is also a variable, and it works like pink.
* Same with a yellow 2x2.
* But a yellow 4x2 is used for multiplication.
* And an orange 4x2 is used for adding.
* Pink 4x2 is a repeat block.
== Examples ==
=== Truth-machine ===
Put a user input in the yellow variable with a yellow and blue block. Then, on another part of the script, put an "if" loop, if yellow=1, than go to the green-red-yellow configuration, which repeats printing 1. It doesn't print 0 once when you put in 0.
Category:Languages
Category:2023
Category:Thematic
Category:Non-textual
Leadfish

leadfish is <x>< but different. it was created by User:Yayimhere
== additions ==
leadfish uses a stack. when <x>< says a cumulator it applies to the top of the stack. new commands:
 new commands
symbol 	meaning
} 	coming in from the left fo down if the top of the stack is 0 else continue going left
# 	pop the top of stack
: 	move the bottom of the stack to the top of the stack
; 	move the top of the stack to the bottom
g and p	same as befunge
Left-or-right

Left-or-right is a very simple language xnor made up. Its expression are made of arrows < (left), > (right), and parentheses.
An expression A<B picks the left item A, while A>B picks the right one B.
Take, for example, ><>. The operator in the middle is <, and, confusingly, the items on each side A and B are also arrows. Since the operator tells us to take the left one A, which is >. So, ><> equals >.
Expressions also nest. We can replace the expression with its value. So, for example, (><>)<< equals ><< equals >. And, >(><>)< equals >>< equals <. For another example, (><>)(<<<)(>><) equals ><< equals >.
== Instruction List ==
Instruction	What it does
A<B 	Return A, the left argument.
A>B 	Return B, the right argument
> 	If > is by itself, lazily return the value.
< 	If < is by itself, lazily return the value.
(...) 	Group ... to have a special precedence
Category:Languages
Category:2020
Category:Implemented
Category:Total
Category:Output only
Left Curly Brace Symbol

Left Curly Brace Symbol is an esolang made by User:Yes in 2022
It is User:Yes's first 2D language.
== Data Storage ==
There is an accumulator which can only be in the ranges 0-9, and a 1-dimensional tape of cells.
== Commands/Instructions ==
Command	Desc.
a 	Where the pointer starts (the program pointer ALWAYS goes right)
{ 	Path for the pointer to follow
} 	Commit function based on accumulator value
n 	Set accumulator to n (This is 1 digit only)
== "Commit function" ==
If accumulator is 0, NOP
If 1, Increment cell at pointer
If 2, Decrement cell at pointer
If 3, Shift pointer to the left
If 4, Shift pointer to the right
If 5, Output value of cell ascii
If 6, Clear accumulator
If 7, Get input and store character into cell on pointer
If 8, Set cell under pointer to 0
If 9, Terminate program
== A Makeshift "If" Function ==
If the program pointer comes to an intersection, then it will move left if the value of the cell the data pointer is 0. Otherwise, it will go right, and never straight. If straight is the only option, it will go straight.
== Examples ==
=== Hello, World ===
a{1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}5}1}5}9}
=== Cat program ===
 {{}
 { 0
 { }
 { 5
 { }
{{ 7
{ {
a{7{
 {
 9
 }
=== Terminate program imediatly after 2 steps===
a9}
== Notes ==
The program MUST terminate with 9} or equivelent or
Unexpected EOF
== Implementations ==
There is currently no implementations, but programs might be able to translate into Befunge one way or another.
Category:Languages
Category:2022
Category:Unknown computational class
Category:Two-dimensional languages
Category:Implemented
Leftoutside

leftoutside was a esolang made by User:Yayimhere but he forgot what it was. i have some scripts laying around. can it be reverse engineered? yes this is like burn but you know. people forget things. i have some scripts laying around:
 /from 1 to 7 after pushing:
 #1V #2V (#V:)
 #^~~(#V=DEC)^V~:[/=/]
 /memory:
 &[23][34][77]
 /show
 (77,a,77)
 {[01] >>> 0 1 0 1 7 5 2 4 2 3 1 2
 [==] <<< 6 4 5 3 2 %%%%%%%%%%%%%%
 <<5 >>> 2 3 4 5 1 2 4}
that was rule 110 although after 100 iterations it would crash
 [&&]
this script took user input. it was named test_of_io
 (3)/([][][])
a if statement. i think it was is 3 a multiple of 3.
 ($)/([3][5][0]) 0 000 =
if statement. check if program counter is a multiple of 5 or 3. then it would go back to the start of code
 104 101 108 108 111 44 32 119 111 114 108 100 33 ;;;;;;;;;;;;;
hello world
notes:
i know for a fact that the memory where in hex. it was written in a .txt file i found together with the scripts.
in leftoutside time matterd. alot.
&'s very used for a lot of things.
numbers has other meaning's than just numbers.
the name isnt the og name. its just how i named
Category:Languages
Legasm

The Legasm Virtual Machine is a RISC virtual machine implemented in software, invented by Philippe Clavel and David Madore in 1998. The machine was originally intended to serve some purpose in the Legendes II game engine, but eventually got abandonned, then later development of the game engine got abandonned too. Legasm is thus arguably not esoteric nor a toy language.
The machine has 256 registers, each 32 bits, of which 232 are general purpose registers, the rest either have some special function or are reserved for special purposes for the future. Four of the registers contain unchangable constants, one has the (writable) instruction pointer (similarly to 32-bit ARM), one has a carry flag for arithmetic, and one has a stack pointer. 
Memory is also addressed in 32-bit words, and contains both data and instructions, which thus allows self-modifying code, though self-modification doesn't seem necessary for useful programs. Memory is conventionally divided to two parts: main memory, which have small positive addresses starting from 0, and stack, which has small negative addresses going down from 0. Arithmetic instructions do operations only on the registers, but there are memory load/store, indirect load/store, push, pop, and call instructions to access memory. 
Each instruction is encoded as a 32-bit word. The instructions available are:
* Immediate load or add instructions, loading 16 bits from the instruction.
* Arithmetic: add, subtract, add with carry, subtract with borrow, and four bitwise operations. These have two register input operands and a register output operand. They all modify the carry bit, to an undefined value in case of the four bitwise operations, but keep unchanged the other 31 bits in the register that contains the carry bit. None of the instructions read the carry bit, the confusingly named add with carry and subtract with borrow instructions just add and subtract a constant 1 carry respectively. 
* Comparisons, with two input register operands and writing 0 or 1 to an output register operand. Both signed and unsigned integer compares are available.
* Shift and rotate. 
* Load and store memory. Address can be direct, which is computed as the sum of two registers, or indirect, in which case the effective address is read from memory based on the direct address. 
* Conditional jump and call. These jump using a 16-bit offset if an input register operand is zero or nonzero; the call versions push the address of the next instruction to the stack.
* Push and pop a register operand to/from stack. Pop can be used to return from subroutine because the instruction pointer is mapped to a register.
* Service call (system call) – this instruction doesn't do anything yet, but presumably this is how the machine would be integrated into whatever it's used for.
== Links ==
* Snapshot l980904 of the Legendes II game engine, which implements the virtual machine in the legendes-980904/legasm.c and has documentation about it in legendes-980904/legendes.html
* Copy of the documentation
Category:Languages Category:1998 Category:Implemented Category:Self-modifying
Legit

Website: https://morr.cc/legit/
Source code: https://github.com/blinry/legit
Programs written in legit are defined entirely by the commit graph in a Git repository. The content of the repository is ignored. legit is defined so that all relevant information is visible when running git log --graph --oneline. For example, here is hello world:
And here is a brainfuck interpreter:
Category:2019
Category:Stack-based
Category:Cell-based
Category:Turing complete
Category:Implemented
Category:Low-level
Category:Thematic