nyuuzyou/wikis huggingface dataset:
ListScript

// ListScript //
// ListScript made by User:Robotrage //
//syntax
 $ 		 - line input when no parameters specified
 _var	 	 - variable definition start with _
 p[VAR]		 - print // cant name functions 'p'
 [CONDITION]?(WHENTRUE)(WHENFALSE) - if statment, first () for when true second () for when false	 
 ;		 - separate inline commands
 [_a,_b,_c]		 - for mutliple param output and input
//notes
-script executes in order of index, with input of next line being output of last line unless line is called as a function
in which case the single paramater is specified.
// Line definition (CAPITAL words to be replaced) //
 >[INPUTPARAMS]>>LINENAME>>INDEX>OUTPUTTYPE|LINEBODY|>RETURN
(blank inputparams defaults to $)
//example//
 >>>initial>>0>int|_x = 1+1|>_x
 >>>addOne >>1>int|_y = $+1|>_y
 >>>foo >>2>int|_z = addFive[addOne[$]]|>_z
 >>>addFive>>3>int|_i = $+5|>_i
 >>>print >>4>int|p[$]|>$
 >>>if>>5>nul|[$==14]?(print[$+1])(print[$]) ; print[0]|>nul
// execution order of code above //
 -line index 0 executes and does 1+1 to _x variable then returns _x OUTPUT = 2
 -line index 1 runs taking _x input from previous line and adding 1, returning that variable _y OUTPUT = 3
 -line index 2 runs taking input _y of value 3, that value is passed as input to line index 1 (addOne)
 which returns a value of 4, this value is then passed to line index 3 (addFive) as input where we get 4 + 5
 returning a value of 9 as _z which will then be returned from line index 2 (foo) OUTPUT = 9
 -line index 3 runs taking input of 9 from foo, adding 5 making 14 and returning that value _i OUTPUT = 14
 -line index 4 runs, the print function takes input parameter 14 and prints it
 -line index 5 runs, conditional code within [] marked with ?, first parentheses run if true second if false, therefore
 line index 4 runs with input 15, printing 15, then print[0] calls index 4 ands prints 0
 -nul return and no larger indexes means program ends.
printed output is:
14
15
0
//anonymous function, function inside function gets executed in new index order starting at 0//
//to pass a parameter to an anonymous function we place it after the first > //
 >INPUT>>>>INDEX>OUTPUTTYPE|LINEBODY|>RETURN
 >>>init>>0>int|_x = 1|>_x
 >>>plusOne>>1>int|_x = 2 ; >$>>>>0>int|_z = _x + $|>_z |>_x // 2+1 = 3
//first class function demonstration//
//must be able to be returned from other functions, assigned to variables and passable as a parameters. //
 >>>init>>0>int |_x = 0|>_x			//0
 >>>foob>>1>func|_func = minusOne|>_func	//returns minusOne function
 >>>bar >>2>int |_output=$[1]|>_output		//1-1 = 0
 >>>minusOne>>3>int|_output=$-1|>_output	//0-1 = -1
 >>>>>4>nul|p[$]|>nul				//print -1 and end
	
//Kestral or K combinator
 >[_x,_y]>>kestrel>>0>int | |>_x	
//Starling or S combinator
 >>>Starling>>0>int ||>[1,2,3]	
 >[_x,_y,_z]>>one>>1>int |_res= >[_x,_z]>>two>>0>int ||>_x+_z ; >[_xz, _y, _z]>>three>>1>int[] ||>[_xz, _y+_z] ; >[_xz, _yz]>>four>>2>int[] ||>_xz+_yz|>_res
	
																
Category:Languages
List of Turing-complete models of computation

Many people want to make new and unique Esolangs. Or base an Esolang on something a million others have done. That works too.
Unfortunately, there is no central resource to find out about interesting and esoteric models of computation. That's where this page comes in.
== Models ==
=== Turing machines ===
(Included for completeness)
A Turing machine is a simple machine that works with a Reader Head, a Symbol Tape, and a Rule Table. The Reader head moves along the tape and, based on what the rule table says regarding its current state and the current cell's symbol:
* Changes the current cell's symbol
* Changes state
* Goes either left or right
If at any point the Turing Machine enters the special halt state, execution halts immediately.
It is the original Turing complete thing (hence the name).
An esoteric example is Brainfuck, sort of.
Turing Script is built on one of these, using Turing Machine programs as subroutines.
=== Lambda calculus ===
The original author was too stupid to understand Lambda calculus, and if you're reading this, no one has fixed this yet (OR you're looking at an old article).
=== Combinatory logic ===
Combinatory logic is similar to the lambda calculus, and thus the author doesn't understand those very well, either. See the Combinatory logic page for details.
=== Concatenative calculus ===
Concatenative calculus is similar to the combinatory logic, but function application is replaced by function composition as the default operation. It has similar properties to lambda calculus and combinatory logic, but makes it easier to incorporate non-pure aspects of the language, like I/O or variables.
The first concatenative language was Forth, but Factor is an example closer to the concatenative calculus ideas.
An esoteric example is Brainfuck Encoded Concatenative Calculus.
=== Unrestricted grammar ===
An Unrestricted grammar is basically what you'll find in Thue. (This section needs to be improved)
== See also ==
:Category:Computational models
Listfunc

Listfunc, listfunk, or listpunc is an esoteric programming language created by User:CreeperBomb in 2023. Listfunc may be capitalised however* you want when it's in the middle of a sentence. Everything in listfunc is either a list or a func(tion). Listfunc is also very hard to read.
*The two options are all lowercase and all uppercase
== List & func ==
Lists are ordered and may contain any number of elements from none to infinitely many, although this upper "bound" is impossible to be reached without infinite program runtime. Lists begin with ( and end in ), and elements are do not have any spacing between them. All elements of a list are themselves lists. An example of a list (with lists inside) is (()()()(()())())
Functions are slightly more complicated. In the middle and end of a definition is a |. On the left, the names of the function and argument(s) are defined. On the right, the output is defined. The function name is defined in [] while the argument name is defined in {}. A definition will take effect if it matches the current situation, but if not then a later definition is used; in other words, previous definitions have higher priority and argument conditions may be used. Functions are applied with []. A succesor function might be defined as [()]({})|({}({}))|. TL;DR: [name]input(s)|output|.
In a way, Listfunc acts somewhat like a string-rewriting paradigm; outputs can be considered similar to replacements. Any undefined characters are ignored. Functions prefer to act on the least amount of stuff as possible, so []() when []{}|()| becomes ()() instead of (). Code is lazy evaluated, and the code after the last pipe is the code initially run.
== I/O ==
The user may input by adding defined functions onto the beginning of the program state. If an argument on the right side is undefined on the left, then it should be user-inputted. The use sees the program state at all times, which is equivalent to output.
== Turing completeness ==
Listfunc can simulate SKI calculus as follows:
S definition: [()()]({})({()})({()()})|{}({()()})({()}({()()}))|
K definition: []([])|[()]|[()]({})|[]|[]([()()])|[()()()]|[()()()]({})|[()()]|
It is known that I can be defined as S K K, which here would be written as [()()]([])([]). Not explicitly including it shortens the K definition.
== Example programs ==
Successor function: [()]({})|({}({}))|
Decrement function: [()()]({}({}))|({})|
Literally every golflang ever

literally every golflang ever
 
 stack-based, stack is set to input [lazily evaluated]
 unbalanced anything is fixed using HTML error correction rules. e.g. (:a)b becomes (:a;)b, and (a becomes (a)
 
 h - prints Hello world
 H - prints Hello World
 h, - prints Hello, world
 H, - prints Hello, World
 h! - prints Hello world!
 H! - prints Hello World!
 h,! - prints Hello, world!
 H,! - prints Hello, World!
 b - 99 bottles of beer, last lyric being "0 bottles of beer on the wall, 0 bottles of beer!"
 B - 99 bottles of beer, last lyric being "0 bottles of beer on the wall, 0 bottles of beer!\nGo to the store and buy some more, 99 bottles of beer on the wall!"
 f - fibbonacci numbers
 l - lucas numbers
 ! - factorial
 p - prime numbers
 P - palindrome
 d - disan count
 D - digital root
 m - output the mandelbrot set in ASCII art
 < - interpret brainfuck
 > - interpret deadfish
 ^ - eval
 r - rot13
 i - calculate pi to [POP] digits
 ? - truth machine
 F - FizzBuzz
 F! - FizzBuzz!
 # - loop
 c - count from [POP 2] to [POP 1] in unary
 C - count from [POP 2] to [POP 1] in decimal
 % - swap
 + - increment
 - - decrement
 " " - push string to stack. \\ -> \, \" -> "
 [ ] - do while nonzero
 { } - do while zero
 ( ) - if nonzero then
 : ; - if zero then
 @ - print the letter @
 $ - convert to leetspeak
 & - bitwise and
 | - bitwise or
 ~ - bitwise not
 * - [POP 2] divided by [POP 1]
 , - discard
 = - push a random number if [POP 1] is equal to [POP 2], otherwise push a string
 ' - 'x is equivalent to "x". this is useful in exactly 1 situation
 \ - segfault
 ` - calls [POP 2] with the argument [POP 1]
 I - \x. x
 K - \xy. x
 S - \xyz. xz(yz)
 s - print the letter s
 M - \x. xx
 X - \f. M(\x. f(xx))
 Y - \f. (\x. f(xx))(\x. f(xx))
 Z - \f. M(\x. f(\v. xxv))
 x - M(\xy. y(xxy))
 y - (\xy. y(xxy))(\xy. y(xxy))
 z - M(\xyz. y(xxy)z)
 v - C:\Riot Games\VALORANT\live\VALORANT.exe
 0 - pushes 0
 1 - pushes 1
 2 - pushes 2
 3 - pushes 3
 4 - pushes 4
 5 - pushes 5
 6 - pushes 6
 7 - pushes 7
 8 - pushes 8
 9 - pushes 9
 q - pushes 10
 w - pushes 11
 e - pushes 12
 t - pushes 13
 y - pushes 14
 u - pushes 15
 o - pushes 16
 a - pushes 17
 s - pushes 18
 g - pushes 19
 j - pushes 20
 k - pushes 21
 n - pushes 22
 Q - pushes 23
 W - pushes 24
 E - pushes 25
 R - pushes 26
 T - pushes 27
 U - pushes 28
 O - pushes 29
 A - pushes 30
 G - pushes 31
 J - pushes 32
 L - pushes 33
 V - pushes 34
 N - pushes 35
 _ - performs a command at random
 / - halts execution
 . - print
 - nop
Category:Joke languages Category:2022 Category:Unimplemented Category:Stack-based Category:Unusable for programming Category:Turing complete Category:Languages Category:Golfing language
Livefish

Livefish is a slight modification of Deadfish made by User:Areallycoolusername. 
== Commands ==
The commands are the same as from Deadfish, except for o, which now inputs things rather than output them. h can still be used to halt the program.
Command	Deadfish 	Livefish
i 	increments	increments
d 	decrements	decrements
s 	square 	square
o 	output 	input
In the reference interpreter, the input is not involved with the accumulator and functionally serves no purpose.
== Implementations ==
=== Pascal ===
There is one reference interpreter for Livefish, and it's in Pascal. Here it is.
 program Livefish (input,output);
 uses crt;
 var
 coke : integer;
 cook : char;
 crak : string;
 begin
 repeat
 coke := 0;
 readln(cook);
 if(cook='i')then
 coke := coke + 1;
 if(cook='d')then
 coke := coke - 1;
 if(cook='s')then
 coke := sqr(coke);
 if(cook='o')then
 readln(crak);
 if(coke=256)then
 coke := 0;
 if(coke<0)then
 coke := 0;
 until cook='h';
 end.
However, two more interpreters are added for Livefish by A.
=== C ===
 #include <stdio.h>
 int main()
 {
 int ac=0;
 char c;
 while(c!='h')
 {
 c=getchar();
 if(c=='i')ac++;
 else if(c=='d')ac--;
 else if(c=='s')ac*=ac;
 else if(c=='o')scanf("%d",&ac);
 if(ac==256||ac<0)ac=0;
 }
 return 0;
 }
=== Lua ===
 ac=0
 while cmd~="h" do
 cmd=io.read()
 if cmd=="i" then ac=ac+1
 elseif cmd=="d" then ac=ac-1
 elseif cmd=="s" then ac=ac*ac
 elseif cmd=="o" then ac=math.floor(tonumber(io.read()) or 0) end
 if ac==256 or ac<0 then ac=0 end
 end
=== Python ===
DockedChutoy also made a Python interpreter. This is it:
 acc = 0
 while True:
 prg = input(" >")
 for cmd in prg:
 if acc == 256 or acc <= 0: acc = 0
 if cmd == "i": acc += 1
 if cmd == "d": acc -= 1
 if cmd == "s": acc *= acc
 if cmd == "o": acc = input(" input>")
== Hello World ==
The hello world program in Deadfish is still valid in Livefish, but this time it doesn't output anything, since Livefish doesn't have any output capabilities. So, it would be like:
 input
 iisiiiisiiiiiiiioiiiiiiiiiiiiiiiiiiiiiiiiiiiiioiiiiiiiooiiio
 dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddo
 dddddddddddddddddddddsddoddddddddoiiioddddddoddddddddo
 output
== Computational Properties ==
Due to the lack of output capabilities, Livefish isn't Turing-complete as it can't do much of the things a Turing machine can.
A Turing-complete programming language does not require output capabilities. It is instead Turing-incomplete because it cannot execute an infinite loop, or perform any sort of conditional branching.
Category: 2019 Category: Unusable for programming Category: Languages Category: Total Category: Implemented
Category: Input only
Llec

llec is an esolang by User:ChuckEsoteric08.
==Specification==
llec operates on a tape of unbounded integers. *x would reference cell x. Cells are 0-indexed. There are 8 commands:
Command	Description
+x 	Increment the cell x
-x 	Decrement the cell x
"x+y 	Increment the cell x by the value of the cell y, and store the result in cell x
/x 	Declare the label x
\x 	Goto label x
?x=y 	If the cell x equals y, skip the next command
'x 	Set the cell x to the next byte of the user input
:x 	Output the cell x as an ASCII character
==Examples==
===Cat===
 /loop
 '0
 :0
 \loop
===Truth-machine===
This program implements a truth-machine:
 '0
 "1+0
 -1 -1 -1 -1 -1 -1 -1 -1
 -1 -1 -1 -1 -1 -1 -1 -1
 -1 -1 -1 -1 -1 -1 -1 -1
 -1 -1 -1 -1 -1 -1 -1 -1
 -1 -1 -1 -1 -1 -1 -1 -1
 -1 -1 -1 -1 -1 -1 -1 -1
 /print_1
 :0
 ?1=0
 \print_1
===brainfuck interpreter===
Program is seperated from input like that: program!input, similar to dbfi
+0
+0
/input
+0
'*0
?*0=33
\input
/iptofirst
-0
?0=2
\iptofirst
"1+0
+1
+1
/interpret
+0
?*0=0
\notend
\end
?*0=43
\not+
\+
/not+
?*0=44
\not,
\,
/not,
?*0=45
\not-
\-
/not-
?*0=46
\not.
\.
/not.
?*0=60
\not<
\<
/not<
?*0=63
\not>
\>
/not>
?*0=91
\not[
\[
/not[
?*0=93
\interpret
\]
/+
+*1
\interpret
/-
-*1
\interpret
/,
'*1
\interpret
/.
:1
\interpret
/>
+1
\interpret
/<
-1
\interpret
/[
?*1=0
\interpret
/find]
+0
?*0=91
\find]not[
\find][
/find]not[
?*0=93
\find]
?2=0
\find]dec
\interpret
/find]dec
-2
\find]
/find][
+2
\find]
/]
?*1=0
\interpret
/find[
-0
?*0=93
\find[not]
\find[]
/find[not]
?*0=91
\find[
?2=0
\find[dec
\interpret
/find[dec
-2
\find[
/find[]
+2
\find[
==Interpreter==
* Common Lisp implementation of the llec programming language.
Category:Languages Category:Turing complete Category:Implemented
Lo'reran

Lo'reran is a esoteric programming language, language of Li'ara project.
== Control ==
Lo'reran does actions based on symbols that represent them.
 Control instructions:
 ! doing actions
 <- leading in results of previous action
 -> leading in results of next action
 . and _ gets informations from variable's context
 .->|. ends command
 .|->. starts commands
 :--comment--: comment
 < and > confront values
 brackets [] {} () union actions
== Hello world ==
 .|->. out!<-("Hello world"!<-crlf) .->|.
== 99 bottles of beer ==
.|->.
num![[int]]99
<?>(num!>1)?:T:!
{
out!<-num!<-" bottles of beer on the wall, "!<-num!<-"bottles of beer."!<-crlf!<-"Take one down and pass it around, "
num!num-1
out!<-num!<-"bottles of beer on the wall."!<-n.2*(crlf)[[arr(2)[[num]]]]
}:f: del!<<num
out!<-"1 bottle of beer on the wall, 1 bottle of beer."!<-crlf!<-"Take one down and pass it around, no more bottles of beer on the wall."!<-n.2*crlf!<-"No more bottles of beer on the wall, no more bottles of beer."!<-crlf!<-"Go to the store and buy some more, 99 bottles of beer on the wall."
Category:Languages
Category:Unimplemented
LoadedFuck

LoadedFuck is an esoteric language written by User:Is this the Krusty Krab. It is a Brainfuck derivative written in C++ which adds more commands and features multiple storage units. It was named so due to it being loaded with commands you'll probably not use.
== Features ==
As the usual in Brainfuck, there is an array of values that can be modified. However, in LoadedFuck, the array is extended from 30,000 cells to 65,536 cells.
Another two feature of LoadedFuck are a stack, which operates like a normal stack you probably studied in school, college, or your room at night, and a buffer, able store a value to be used later.
== Syntax ==
Command 	Description 	
> 	Move the memory pointer to the right 	
< 	Move the memory pointer to the left 	
+ 	Increment the pointed cell 	
- 	Decrement the pointed cell 	
[ 	Jump past the matching ] if the pointed cell is 0 	
] 	Jump back to the matching [ if the pointed cell is nonzero 	
. 	Output the value of pointed cell as a character 	
, 	Input a character and store it in the pointed cell 	
" 	Output the value of pointed cell as its ASCII code 	
; 	Input a character with buffer (pressing enter) 	
( 	Push the value of the pointed cell to the stack 	
) 	Pop the top value of the stack to the pointed cell 	
@ 	Assign the value at the top of the stack to the pointed cell 	
$ 	Pop the top value of the stack without writing it to the pointed cell 	
{ 	Shift the value of the pointed cell to the left 	
} 	Shift the value of the pointed cell to the right 	
/ 	Store the value of the pointed cell into the buffer 	
\ 	Write the value of the buffer to the pointed cell 	
= 	Add the top value of the stack to the pointed cell 	
_ 	Subtract the top value of the stack from the pointed cell 	
* 	Multiply the top value of the pointed cell by the top value of the stack 	
: 	Divide the top value of the pointed cell by the top value of the stack 	
% 	Store the remainder left from dividing the value of the pointed cell by the top value of the stack	
& 	Store the value of performing a logical AND with the pointed cell and the top value of the stack 	
style="text-align:center" 	 	Stores the value of performing a logical OR with the pointed cell and the top value of the stack
^ 	Stores the value of performing a logical XOR with the pointed cell and the top value of the stack 	
Any uppercase letter or any digit	Print said letter or digit 	
== Links ==
Click here for the code on Pastebin, written in C++
==See also==
* Brainfuck
Category:Languages Category:Implemented Category:Brainfuck derivatives Category:Turing complete Category:Stack-based Category:Cell-based Category:Low-level Category:2018
Lode Vandevenne

Lode Vandevenne designed the following languages:
*Gammaplex: a 2-dimensional language with graphical output
*Brainloller: an image based Brainfuck clone
*Braincopter: a Brainloller clone
*Mycelium: an image based Befunge clone
*Deltaplex: an image based language with 3D output
*Unary: a joke language: Brainfuck converted to the unary number system
*Roco: a coroutine experiment
He also wrote platform independent interpreters in C++ for most of these languages.
Category:People
Log

log is an esolang invented by User:A based on NOR logic.
==Syntax==
There are only 2 commands:
 (... ...)
 It changes the operation into the answer after using the NOR operation.
 Note that the space is just for seperating the parameters and can be replaced into any invisible character.
 If one or both parameter(s) is (...), the seperation can be deleted.
 And also, if there is only 1 parameter, the operation is parameter NOR parameter.(Inspired by FerNANDo)
 0 NOR 0 = 1
 0/1 NOR 1 = 0
 1 NOR 0 = 0
 A-Z
 Input a bit and change it into 0 or 1 (input in ASCII order). Each letter will be input once (if it is used), A is input before B before C.
 The result of every end of () will be outputted.
==XOR==
 (((A A)(B B))(A B))
or
 (((A(A B))(B(A B)))((A(A B))(B(A B))))
or
 (((A)(B))(A B))
or
 (((A(A B))(B(A B))))
==NOT==
 (A A)
or
 (A)
==OR==
 ((A B)(A B))
or
 ((A B))
==AND==
 ((A A)(B B))
or
 ((A)(B))
==NAND==
 (((A A)(B B))((A A)(B B)))
or
 (((A)(B)))
==XNOR==
 ((A(A B))(B(A B)))
or
 ((B(A A))(A(B B)))
or
 ((B(A))(A(B)))
Category:Languages
Category:Joke languages
Category:Total
Category:Unusable for programming
Category:Low-level
Category:2018
Log++

It is Log invented by User:A, but with this extension:
 (.)
 That is NAND. Change the operation into the answer after the NAND operation.
 !
 Make a Brainfuck Interpreter.
==NOT==
 (A.A)
==AND==
 ((A.B).(A.B))
==OR==
 ((A.A).(B.B))
==NOR==
 ((A.A ).(B.B))
==XOR==
 ((A.(A.B)).(B.(A.B)))
Or:
 ((A.(A.B)).(B.(A.B)))
==XNOR==
 (((A.A).(B.B)).(A.B))
Or:
 (((A.(A.B)).(B.(A.B))).((A.(A.B)).(B.(A.B))))
==See also==
Log
Category:Languages
Category:Joke languages
Category:Self-modifying
Category:Low-level
Category:2018
Category:Turing complete
Category:Turing tarpits
LogOS

logOS is an imperative and partially object-oriented language based around the 'Desktop metaphor' that modern operating systems use. It was brainstormed with the unaffiliated Esolangs Discord server and implemented in Python by User:IFcoltransG in late 2019.
== Programs ==
Programs are built-in objects, and their commands are methods or functions that transform text. Each program stores data in a buffer, a string that is manipulated whenever a program's commands are executed.
Editor is a text editor used for manipulating the strings that are the lifeblood of any logOS algorithm. Calculator can parse arithmetic with order of operations. Email is used for IO. Terminal parses and executes logOS code, so can be used for control flow.
== Example Code ==
=== Hello World ===
 Editor
 write "Hello, world!"
 copy
 minimise
 Email
 paste
 send
With comments:
 rem "rem" starts a comment.
 rem Start a text editing program:
 Editor
 rem Input the appropriate words to the text editor:
 write "Hello, world!"
 rem Note that "write" only works while in the text editor.
 copy
 rem Bring up the Desktop:
 minimise
 rem Start up Email - the tool used for communicating with the user:
 Email
 paste
 rem Output whatever the Email program stores in its buffer to the user.
 send
A golfed version:
 Email Hello, world!
 send
=== cat ===
 Editor
 rem Write out the main loop code.
 rem "write" without arguments writes a newline.
 write "switch Email"
 write
 write "refresh"
 write
 write "send"
 write
 write "switch Terminal"
 write
 rem The "run" command deletes the contents of the Terminal.
 write "paste"
 write
 write "run"
 rem Move the code to the clipboard
 cut
 minimise
 rem Boot up Email so the loop can switch to and from it.
 Email
 minimise
 Terminal
 paste
 rem Run the program's contents as logOS code:
 run
=== Truth-machine ===
 Editor paste\nswitch Email\nsend\nswitch Terminal\nrun
 replace "\n" with newline
 cut
 minimise
 LOOP
 paste
 minimise
 Email
 refresh
 copy
 switch Editor
 paste
 replace "1" with "switch LOOP\ncopy\nswitch Terminal\npaste\nrun"
 replace "\n" with a newline
 replace "0" with "rem"
 cut
 minimise
 Terminal
 paste
 run
== Etymology ==
The name is a combination of the word logos meaning reason and logic, and OS for Operating System. The log also represents the fact that source code looks like a transcript of a person accessing a computer. The language doesn't have any logos designed yet.
== External Resources ==
* A specification can be found here.
* The implementation can be found here.
Category:2019
Category:Object-oriented paradigm
Category:Turing complete
Category:Implemented
Category:Thematic
Category:Languages
Category:Pseudonatural
Logic

Logic by User:PuzzleHunter84 uses binary logic gates to output 1's and 0's. These are then translated into ASCII characters. The cat program below copies an inputed digit 1 or 0 into output by outputting digits 011000I where I is the inputed digit. 
 0-O
 #-O
 1-O |
 !-|
 0-| | |
 /-O |
 0-| |
 %-O
 I-| |
 &-| |
 1-O | |
 %-|
 0-O |
 ?-|
 1-|
The - and | symbols are used to connect operands to their operator. I indicates an inputed digit. O indicates an outputed digit which are taken top to bottom, left to right. The operands are as follows:
 &: and: 1&1=1
 0&1=0
 1&0=0
 0&0=0
 /: or: 1/1=1
 0/1=1
 1/0=1
 0/0=0
 %: nand: 1%1=0
 0%1=1
 1%0=1
 0%0=1
 !: nor: 1!1=0
 0!1=0
 1!0=0
 0!0=1
 ?: xor: 1?1=0
 0?1=1
 1?0=1
 0?0=0
 #: xnor: 1#1=1
 0#1=0
 1#0=0
 0#0=1
==See also==
* log
Category:Languages Category:Output only Category:Unimplemented Category:2009