nyuuzyou/wikis huggingface dataset:
Looping counter

A looping counter counts up to infinity or a specific number (or possibly down to a specific number or negative infinity). Counting from 99 to 0 can be used as a simpler alternative of the 99 bottles of beer program to prove that a language is usable for computation.
The program exhausts unbounded memory over infinite time. It prints each value as it counts, and it exhausts infinite states in infinite time. The program is essentially an unbounded unary counter.
The output of a looping counter is as follows:
 *
 **
 ***
 ****
 *****
 ******
 *******
 ********
 *********
 **********
 ***********
 ************
With each iteration, the memory used grows.
==Examples==
===()()(())===
 ((())(()))
===()NEST()===
 [*] 
 [][*
 [] *
 []
 
 (N)
===:///===
Two examples are available on the page :///, printing rows of increasingly many asterisks with each run.
===95-98===
 A-A 41-43 0-1 A-A
===Befunge===
 1:v,*25<
 : :
 v_$1+ ^
 "
 *:
 "-
 ,1
 >^
===Black===
A looping counter written in Black can be found at Black#Example program.
The looping counter was used as the first demonstration that Black was possibly Turing-complete. (Although a looping counter does not prove Turing-completeness in its own right, it helps to demonstrate how a language is capable of storing and retrieving arbitrary amounts of data, which is often one of the hardest aspects of Turing-completeness to discover within a language.)
===Brainfuck===
 >>++++++++++[[->+<<++++>]<++[<]>[.>]>.]
===Iterate===
(*)∞<
 *n<
 (1*)42< // print "*"
 *~n< &1 >
 ~@
 >
 >
 (1*)10< // print "\n"
 *~n< &1 >
 ~@
 >
>
===MoreMathRPN===
 1
 repeat ]0
 outputS "*"
 next
 outputS "\n"
 1
 +
 jmp -6
===Muriel===
S:"@\"S:\\\"\"+|S+\"\\\";\\nA:\\\"\"+A+\"*\"+\"\\\";.A+\\\"\\\\n\\\";\\n\"+S";
A:"*";.A+"\n";
@"S:\""+|S+"\";\nA:\""+A+"*"+"\";.A+\"\\n\";\n"+S
===NO(t) MORE(than)===
 ([#])([#])([#])
===Not===
 1#1[1+=#N]
===Python===
 a=1
 while 1:print(a*'*');a+=1
Golfed variant by User:Ractangle:
 a=""
 while 1:print(a:=a+"*")
=== REG.TYPE = STR TRUE ===
 #+"*"A/(o[0]+"*"<+"/n")
===Stack-based===
VAR x
VAR y
VAR z
VAR one
S x 1
S one 1
S z 10
C x y
P "*"
SU y one
JB y 2
OC z
JB one 5
===STIYALFICL===
 page 1: "*)"
 ----
 1 owns *)
 2 owns *
 ----
 checklist:
 avoid 1 by rewriting as **)
 avoid 1 by rewriting as *
 see page 1
 avoid 2 by rewriting as *)
===Subleq===
 42 1 7 0 0 0 0 3 1 10
 5 4 13 6 5 16 5 5 19
 6 1 28 0 -1 25
 5 5 19
 4 3 0 9 -1 0 5 5 10
The 42 can be altered to print any character you like.
===Underload===
 (
 )(~(*)~*:S~:^):^
===Unlambda===
 ``ci`.*`c`.*r
or with an extra newline
 ``ci`.*`cr
without c
````sii``s``s`ks``s``s`ks``s`k`s``s`k``s``si`k.*`kri``s`kki``s`kki`k``s`k``s`k`s``s`ks``s`kki``s``s`ks``s`k`s`ks``s`k`s`kk``s``s`ks``s`kki`ki`k`kiii
===Thue===
(outputs are separated by |)
o::=~*
Sep::=~|
[0>]*::=*[0>]o
[0>]|::=*Sep[<1]|
*[<1]::=[<1]*
|[<1]::=|[0>]
::=
|[0>]*|
A faster one:
[*]::=~*
[|]::=~|
>*::=*>[*]
>|::=*[|]<|
*<::=[*]<*
|<::=|>[|]*
::=
|>*|
===UTC+8===
 无限地（重复循环次数次输出“*”然后输出字符10）。
===WhatLang===
 (*):{."\n"._(*)+:}
===XUS===
using {} instead of *:
 = counter {}
 X Counter
 (X Counter Y Counter)
Category:Program forms
Loopnest

Loopnest is a Turning tarpit that can be modeled by an infinitely nested torus-like shape, embedded in 3d euclidean space. The pointer is essentially a particle with an initial velocity; the instructions build the nested structure that the particle will traverse by giving a rotation angle that will rotate the nested loops so that they will align with the pointer's trajectory. The last instruction will be a special one: nest, which will create a subloop, as well as change the velocity of the pointer. The multiples of complete rotations to reach the nest instruction will determine the amount of nested loops created. When the particle reaches a nest instruction it will be taken down into the sub-loop, and then return. The program ends when the pointer completes one cycle of the initial loop. 
==Initial State==
The initial state of the structure can be thought of as a single loop with 4 loops attached to it perpendicularly, similar to the top of a torus if at every 90 degrees there was a special circle slice with instructions written on it. The instructions AND, OR, NOT, and the nest can be inscribed to points along each loop. 
==Defining Instructions by a Function==
If all instructions are rotations, then one available feature is to define them inductively by a function. 
Category:Languages
Category:Turning tarpits
Category:Multi-dimensional languages
Loops

in loops there can only be loops.
==syntax==
 [: start of loop
 ]: end of loop
 #: add condition to loop
 +: add loop numerals
 -: subtract loop numerals
 @: put in front of a loop and then whats in front of the @ will be saved as that loop's name. this is for memory and can now be used as a variable(only for loop numerals)
 "@": a variant of @ that works like functions where you use @ and then the names a set in the front of the function inside of its brackets
 I:input. only numbers
==loop numerals==
loop numerals are the numbers in loops
loop numerals are made by loops in loops with a condition that isn't possible
example for 0:
 []#1<0
example for 1
 #1<0
and so on
 2:[[[]]]#1<0
 3:[[]]#1<0
 ect.
==rules==
 using functions in a recursive manner is ok
 negatives does not exist in loop numerals
 strings does only exist in ascii codes
Category:Languages
Lorry

==Lorry==
Lorry is a minimalistic programming language operating via a head on a tape of non-negative integers. It gets its name from the unique feature that the head (the conceptual lorry) also has an associated non-negative integers which is decreased on instructions that move the head or enter an iteration of a loop (conceptual fuel consumption). These instructions are not performed if the value of the head is zero, being the only way of implementing conditionals in the language.
===Setup===
A lorry program operates via a pointer (called the lorry) on an infinite, one-sided tape of memory cells (called depots) holding non-negative integers. The depots are all initially empty, except for the first one, which (always) contains an infinite amount of fuel. The lorry, starting at the first depot, also has an associated non-negative integer (its tank), initially 0 as well.
===Execution===
A valid lorry program is any finite string consisting of the characters
 > < + - [ ]
where the brackets are matching. To execute a lorry program, the characters are read one by one, starting at the left end. Each character corresponds to different instruction, which might depend on the fuel level (and position) of the lorry:
 > : if the tank is not empty, move the lorry one step to the right and remove 1 from the tank
 < : if the tank is not empty (and the lorry is not at the first depot), move the lorry one step to the left and remove 1 from the tank
 + : if the tank is not empty, move 1 from the tank to the current depot
 - : if the current depot is not empty, move 1 from the current depot to the tank
 [ : if the tank is empty, jump ahead in the program to the matching closing bracket, else remove 1 from the tank 
 ] : if the tank is not empty, jump back in the program to the matching opening bracket and remove 1 from the tank
The program halts when the end of he string is reached.
===Input and output===
We index the depots by the non-negative integers. A lorry program can take as input a sequence of non-negative integers, which determine the initial values of the first few depots after depot 0. The output of a halting lorry program are the (first few) final values of the depots, excluding depot 0.
===Computational power===
With a few simple observations it is easy to show that any program for a register machine can be translated into an equivalent lorry program. It follows that lorry is Turing complete.
===Examples===
Lorry program that computes the function f(x,y) = x+y:
 -[----->>-<+<]->-<
Category:Languages
Category:2022
Category:Cell-based
Category:Turing complete
Category:Brainfuck derivatives
Category:Implemented
Category:Low-level
Category:Thematic
Loss

===Syntax & structure===
Loss has 4 commands:
l 	Print selected data as unicode character
l ‎ l	Half selected data, rounding down
l l 	Incrimemt selected data by 3
l _ 	Selects slot with an ID of currently selected data
 
"l", "I", "|", and "ı" can be used as the tall keys for the program (capitalisation matters). Anything after the command acts like a comment.
Loss takes place on an infinitely long line of slots, which store nonnegative integers. Every slot starts at 0, and the program starts on slot 2. Slots 0 and 1 have special functions: 
*Slot 0 stores where in the code you are, and thus can be used to recreate jump commands.
*Slot 1 can be edited by the user.
The first command in a program is treated as command 0. Newlines seperate commands.
Something important to note is that inputting a digit such as "1" will result in the Unicode value for the digit, and not the digit's actual value. In the "1" example, you'd actually be inputting the number 49.
In adition to having an easy to learn command list, Loss has numerous other advantages,
===Advantages===
Zero is a number and thus is "numerous".
Category:Cell-based Category:Languages Category:Joke languages
Loss, v. 1.11.11.1

Loss is a language that is currently in its most stable version, 1.11.11.1_. It is no longer being updated.
= Syntax =
I prints I
II prints II
II prints II
I_ prints I_
= Example Program =
Input:
 I II
 II I_
Output:
 I II
 II I_
= Implementation =
The following implementation is realized in the programming language Common Lisp:
 (defun interpret-Loss-v-.1.11.11.1_ (code)
 "Interprets the piece of Loss, v. 1.11.11.1_ source code and returns
 no value."
 (declare (type string code))
 (let ((ip 0))
 (declare (type fixnum ip))
 (symbol-macrolet
 ((current-character (the character (char code ip)))
 (next-character (the character (char code (1+ ip))))
 (next-character-is-identifier-p
 (the boolean
 (not (null
 (and (array-in-bounds-p code ip)
 (find next-character "I_" :test #'char=)))))))
 (declare (type character current-character next-character)
 (type boolean next-character-is-identifier-p))
 (loop while (< ip (length code)) do
 (case current-character
 (#\I
 (format T "~c" current-character)
 (when next-character-is-identifier-p
 (format T "~c" next-character)
 (incf ip))
 (incf ip))
 ((#\Space #\Tab #\Newline)
 (format T "~c" current-character)
 (incf ip))
 (otherwise
 (error "Cannot print the character \"~c\" at position ~d."
 current-character ip))))))
 (values))
Category:Joke languages
Category:2023
Category:Languages
Category:Implemented
Lossia

Lossia is a language made by Tetrapyronia. It uses 1 stack. All commands must be prefixed with l. Spaces can be put anywhere, including inside commands. Everything including and after the first invalid command is a end-of-line comment. (ex: l- l- Push 2 -1s to the stack <- all italics are comments)
== Commands ==
Command	Meaning
. 	If top stack item is <1, jump 1 past matching _
, 	If top stack item is >1, jump 1 past matching _
_ 	Jump back to matching . or ,
l 	Print top of stack (as a number, keeps value)
i 	Print top of stack (as a Unicode character, keeps value)
L 	Push input to stack
s 	Pop A and B, push A-B
- 	Push -1 to stack
= 	If top 2 commands are equal, skip next command
[ 	Duplicate top of stack
x 	Swap top 2 stack items
== Example program: Truth-machine ==
 l Loss l
 llIIIIll
 
 l[ l.
 ll l_
== Online Interpreter==
Lyxal made an online interpreter for this esolang. You place the code into the "code" box.
Category:2021
Category:Implemented
Category:Stack-based
Category:Languages
LottoScript

== Commands ==
LottoScript is an esolang with five randomized commands:
 Commands
Command 	Name 	Function
Add 	[ADD]	Add 1, or 10 (see later at EXR) to the cell
Subtract	[SUB]	Remove 1, or 10 (ditto) from the cell
Append 	[APP]	Append the cell (as chr value) to the current string and reset the cell
Extra 	[EXR]	Increase the affect of ADD and SUB (comes after)
Output 	[OUT]	Output the current string and reset it
Available characters for the commands:
 1234567890-=qwertyuiop[]\\asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:\"ZXCVBNM<>?
There's also an option for a space, a tab, or a newline. 
This means if you try to make a program with random operators, there is a ~0.000000011645049% chance it will work. Probably a higher chance if you use less commands, but that's the number if you use all 5.
== Example ==
Example program:
 +<+<+<+<+<+<+<++>+<+<+<+<+<+<+<+<+<+<+++++>+<+<+<+++>+<+<+<++>
 +<+<+<+<+<+<+<+++>+<+<+<++>+<+<+<+<+<+<+<+<+<+<+<+<->+<+<+<+<+<+<+<+<+<+<+<+>+<+<+<+<+<+<+<+<+<+<+<>+<+<+<+++>!
Output:
 Hi! I won!
This uses:
 Example Commands
Command	Symbol
[ADD] 	+
[SUB] 	-
[APP] 	>
[EXR] 	<
[OUT] 	!
== Interpreter ==
 import random
 import contextlib
 
 chars="`1234567890-=qwertyuiop[]\\asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:\"ZXCVBNM<>? \t\n"
 
 addCMD = chars[random.randint(0, len(chars)-1)]
 subCMD = chars[random.randint(0, len(chars)-1)]
 appCMD = chars[random.randint(0, len(chars)-1)]
 exrCMD = chars[random.randint(0, len(chars)-1)]
 outCMD = chars[random.randint(0, len(chars)-1)]
 
 with open("main.lotto") as raw:
 con = raw.read()
 
 with contextlib.suppress(Exception):
 curstring = ""
 curcell = 0
 lines = con.split("\n")
 for line in lines:
 for chariter in range(len(line)):
 curchar = line[chariter]
 if curchar == appCMD:
 curstring += chr(curcell)
 curcell = 0
 elif curchar == outCMD:
 print(curstring)
 curstring = ""
 
 with contextlib.suppress(Exception):
 nextchar = line[chariter+1]
 editor = 1
 if nextchar == exrCMD:
 editor = 10
 if curchar == "+":
 curcell += editor
 elif curchar == "-":
 curcell -= editor
If you want to change the commands and not make it impossible to use, just change the CMD variables (addCMD, subCMD, etc.)
Category:Languages
Category:Joke_languages
Category:Implemented
Category:Nondeterministic
Category:Probabilistic
Category:2024
Category:Cell-based
LstackG+

<stack>+ is a derivative of <stack> by the same author: User:None1.
There is almost no difference, except that <stack>+ has one more command: +, that decrements the top of stack.
==Interpreter in JavaScript==
function lstackgp(code,input){
 var stack=[0],par=[];
 var match={},cp=0,output=;
 for(let i=0;i'){
 if(par.length==0){
 return 'Unmatched >';
 }
 var b=par.pop();
 match[b]=i;
 match[i]=b;
 }
 }
 if(par.length!=0){
 return 'Unmatched <';
 }
 while(cp+'.includes(code[cp])==false){
 cp=cp+1;
 }
 if(code[cp]=='<'){
 if(stack[stack.length-1]==0){
 cp=match[cp];
 }else{
 cp=cp+1;
 }
 continue;
 }
 if(code[cp]=='>'){
 if(stack[stack.length-1]!=0){
 cp=match[cp];
 }else{
 cp=cp+1;
 }
 continue;
 }
 if(code[cp]=='+'){
 stack[stack.length-1]+=255;
 stack[stack.length-1]%=256;
 cp=cp+1;
 continue;
 }
 if(code[cp]=='a'){
 stack[stack.length-1]+=1;
 stack[stack.length-1]%=256;
 cp=cp+1;
 continue;
 }
 if(code[cp]=='s'){
 stack.push(0);
 cp=cp+1;
 continue;
 }
 if(code[cp]=='t'){
 if(input.length==0){
 stack.push(255);
 }else{
 var inch=input.charCodeAt(0);
 input=input.slice(1);
 stack.push(inch);
 }
 cp=cp+1;
 continue;
 }
 if(code[cp]=='c'){
 if(stack.length>=2){
 output+=String.fromCharCode(stack.pop());
 }
 cp=cp+1;
 continue;
 }
 if(code[cp]=='k'){
 if(stack.length>=2){
 stack.pop();
 }
 cp=cp+1;
 continue;
 }
 }
 return output
}
==Note==
This is the same as BFStack.
Category:Stack-based
Category:Brainfuck derivatives
Category:Languages
Category:Implemented
Category:Push-down automata
Category:2023
Luigi

Luigi is an esoteric programming language invented by Nathan van Doorn, which is based on L-Systems, which are a kind of parallel string rewriting. (That is, they rewrite strings in parallel, not that they rewrite parallel strings.)
==Background==
The L-System was originally developed by not a computer scientist, but Hungarian botanist Aristid Lindenmayer, after whom it is named (the L is short for Lindenmayer), originally for documenting the growth of algae.
==Structure==
An L-system consists of two parts:
* The axiom, or initial state
* A set of production rules, consisting of two strings: the predecessor and the successor. If a character is not used on the left hand side of any production rule, it is assumed to have the Identity Rule, n->n.
These parts may contain any character, other than ';' (semicolon), '<' (less than) and '>' (more than). These symbols have special meanings. Newlines are ignored.
In Luigi, rules may not be ambiguous. However, context-sensitive rules (see below) take priority over normal rules. The structure of the program is as follows, with a semicolon at the beginning and the end, and between everything:
 ;axiom;predecessor;successor;predecessor;successor;etc.;
===Context-sensitive rules===
Context-sensitive rules are only activated if the predecessor part of a rule is after what is called the "left part", and before the "right part". This is expressed in the following format, where content in square brackets is optional:
 ;[left-part<]predecessor[>right-part];successor;
A rule with both a left part and a right part takes priority over a rule with just one, which in turn takes priority over a rule with none.
==Computational class==
Luigi is Turing-Complete, as it is possible to translate arbitrary Turing machines into it. For instance, the two-state five-colour universal Turing machine given at http://mathworld.wolfram.com/UniversalTuringMachine.html becomes:
 ;{initial-state}; a^;^b ;^b a; a^a;^b b; a^b;^b c; a^c;^b d; a^d;^b e; a^e;^c a;
 a^a;^c b; a^b;^c c; a^c;^c d; a^d;^c e; a^e;^d a; eva;^d b; evb;^d c; evc;^d d;
 evd;^d e; eve; e^;vd ; av;^c ;vb a; a^a;vb b; a^b;vb c; a^c;vb d; a^d;vb e; a^e
 ;vc a; e^a;vc b; e^b;vc c; e^c;vc d; e^d;vc e; e^e;vd a; eva;vd b; evb;vd c; evc
 ;vd d; evd;vd e; eve; ev;vc ;{;{a;};a};
==Examples==
===Fibonacci Numbers===
 ;a;a;b;b;ab;
The length of the data string in each iteration is a successive fibonacci number.
===Thue-Morse sequence===
 ;0;0;01;1;10;
Each iteration doubles the computed digits,.
Category:Languages
Category:String-rewriting paradigm
Category:2011
Category:Cell-based
Category:Turing tarpits
Category:No IO
Category:Unimplemented
Category:Low-level
Category:Turing complete
Luke's Box Programming

Luke's Box Programming (abbreviated as LBP1) is an esoteric programming language made by User:ClearLimediWater.
== Introduction ==
LBP1 uses box-drawing characters for programming.
It's still developing now and maybe i'll put a github link or what. Maybe next week?
== Alphabets ==
 '　'(fullwidth space, used to fill the inside of the box)
 ─│(L1)
 ━┃(H1)
 ┄┆(L3)
 ┅┇(H3)
 ┈┊(L4)
 ┉┋(H4)
 
 (lots of corners)
 ┌┍┎┏
 ┐┑┒┓
 └┕┖┗
 ┘┙┚┛
 ├┝┞┟┠┡┢┣
 ┤┥┦┧┨┩┪┫
 ┬┭┮┯┰┱┲┳
 ┴┵┶┷┸┹┺┻
 ┼┽┾┿╀╁╂╃╄╅╆╇╈╉╊╋
== Syntax ==
As we all known, a box has 4 sides, like this:
 ┌─┐
 │　│
 └─┘
LBP only focuses on its left and top.
If there is no line between two corners, LBP calls it 'L0'(Light) or 'H0'(Heavy)
 (L0)
 (H0)┎┐
 ┖┘
== Commands ==
 L\T L0 L1 L3 L4 H0 H1 H3 H4
 L0 END... ...... ...... CLOSE. BREAK. ...... ...... ......
 L1 FUNC.. PRINTN INPUTN ...... NOT... IF.... EQUAL. AND...
 L3 RET... PRINTC INPUTC ...... COND.. GREAT. ...... ......
 L4 LOOP.. PRINTL INPUTL OPEN.. ELSE.. OR.... ...... ......
 H0 CTN... ...... ...... ...... ZERO.. ...... GLBREF ......
 H1 BNOT.. BAND.. BOR... BXOR.. NEG... NUM... ADD... MUL...
 H3 ...... BSHL.. ...... ...... LOCREF DIV... RANDOM ASSIGN
 H4 ...... BSHR.. ...... ...... ...... MOD... ASGSEC SECT..
== See also ==
Luke's Box Pseudocode (or LBP2): It's very difficult to use LBP1 so I invented this.
Category:Languages
Luke's Box Pseudocode

Luke's Box Pseudocode (abbreviated as LBP2) is an not very esoteric programming language made by User:ClearLimediWater.
== Introduction ==
This is a simplified version of LBP1.
== Examples ==
=== Hello, world! ===
 PRINTC[ZERO](NUM{8,9})
 PRINTC[ZERO](ADD[NUM{1,1}](NUM{10,10}))
 PRINTC[ZERO](NUM{9,12})
 PRINTC[ZERO](NUM{9,12})
 PRINTC[ZERO](ADD[NUM{1,1}](NUM{10,11}))
 PRINTC[ZERO](NUM{4,11})
 PRINTC[ZERO](NUM{8,4})
 PRINTC[ZERO](NUM{7,17})
 PRINTC[ZERO](ADD[NUM{1,1}](NUM{10,11}))
 PRINTC[ZERO](ADD[NUM{2,2}](NUM{10,11}))
 PRINTC[ZERO](NUM{9,12})
 PRINTC[ZERO](NUM{10,10})
 PRINTC[ZERO](NUM{3,11})
=== A+B Problem ===
 INPUTN[ZERO](ZERO)
 INPUTN[ZERO](NUM{1,1})
 ASSIGN[NUM{1,2}](ADD[LOCREF(ZERO)](LOCREF(NUM{1,1})))
 PRINTN[ZERO](LOCREF(NUM{1,2}))
=== Truth-machine ===
 INPUTN[ZERO](ZERO)
 CONDIT(
 IF[EQUAL[LOCREF(ZERO)](ZERO)](
 PRINTN[ZERO](ZERO)
 END #optional
 )
 IF[EQUAL[LOCREF(ZERO)](NUM{1,1})](
 LOOP(
 PRINTN[ZERO](NUM{1,1})
 )
 )
 )
=== 99 bottles of beer ===
=== Factorial ===
=== Fibonacci sequence ===
=== Sieve of Eratosthenes ===
=== Bubble Sort ===
=== Quick Sort ===
=== Brainfuck Interpreter ===
== See also ==
Luke's Box Programming (or LBP1)
Category:Languages
Lunchable

Lunchable is an esolang created by User:Tommyaweosme to sound like instructions to making a lunchable.
== Commands ==
 open lunchable - start script
 place dough - pushes 0 to stack
 put a little cheese on - changes 1 to top of stack
 put a handful of cheese on - changes 10 to top of stack
 put sauce on - changes 100 to top of stack
 put pepporoni on - toggles add or subtract (starts as add)
 spread sauce - duplicates top of stack
 move some cheese - rotates top 2 of stack
 take bite of pizza - outputs top of stack in ascii
 eat pizza - pops top of stack (without output)
 open crunch bar - brainfuck [
 take bite of crunch bar - brainfuck ]
== Hello World ==
 open lunchable
 place dough
 put sauce on
 put pepporoni on
 put a handful of cheese on
 put a handful of cheese on
 put a handful of cheese on
 put pepporoni on
 put a little cheese on
 put a little cheese on
 take bite of pizza
 eat pizza
 put sauce on
 put a little cheese on
 take bite of pizza
 put a handful of cheese on
 spread sauce
 put pepporoni on
 put a little cheese on
 put a little cheese on
 put a little cheese on
 take bite of pizza
 take bite of pizza
 eat pizza
 take bite of pizza
 place dough
 put pepporoni on
 put a handful of cheese on
 put a handful of cheese on
 put a handful of cheese on
 put a little cheese on
 put a little cheese on
 take bite of pizza
 put sauce on
 put pepporoni on
 put a handful of cheese on
 put a little cheese on
 put a little cheese on
 put a little cheese on
 put a little cheese on
 take bite of pizza
 eat pizza
 take bite of pizza
 put pepporoni on
 put a little cheese on
 put a little cheese on
 put a little cheese on
 take bite of pizza
 put pepporoni on
 put sauce on
 put pepporoni on
 put a little cheese on
 put a little cheese on
 put a little cheese on
 put a little cheese on
 take bite of pizza
 eat pizza
 put sauce on
 take bite of pizza
Lye

Lye is a declarative language for musical expressions. It is inspired by a feature of the LilyPond toolchain which renders musical expressions to MIDI files.
=== Syntax ===
Lye's syntax is a strict subset of LilyPond which has no computational content. Notably, it lacks embedded Scheme. Supported features include:
* Notes
** Pitches
** Accidentals
** Octaves
** Durations
** Ties
* Rests
* Chords
* Voices
* Dynamics
* Tuplets
* Drums mode
* Relative mode
Category:Implemented
Category:2011
Category:Languages
Category:Unknown computational class
Category:Non-textual
M0

The M0 assembly language is the simplest assembly language you can create that enables the creation of real world programs with practical application. It includes only a single keyword: DEFINE and leverages the language properties of Hex2 along with extending the behavior to populate immediate values of various difference sizes and formats.
Thus a programmer is able to write a series of defines like so:
DEFINE LOADR 2E0
DEFINE LOADR8 2E1
DEFINE LOADRU8 2E2
and then use them to create a rather readable assembly program:
# We still support these comments
;; We also added support for hex inserts like so
:My_Global
'00440044'
;; And we also support strings, that we null pad to 4byte boundaries to make disassembly easier.
:My_String
"Hello world!"
:Prompt_Loop
	LOADXU8 R0 R3 R4 ; Get a char
	CMPSKIPI.NE R0 0 ; If NULL
	JUMP @Prompt_Done ; We reached the end
	FPUTC ; Write it to TTY
	ADDUI R3 R3 1 ; Move to next char
	JUMP @Prompt_Loop ; And loop again
And more impressive programs have been created in it such as C compilers. such as the cc_* family of C compilers written in assembly.
Category:Bootstrapping Category:Languages