nyuuzyou/wikis huggingface dataset:
Tuvars

Tuvars is an Esolang created on 7/12/22 (July 12th), by User:SpaceByte. The idea behind Tuvars is to be semi powerful, yet be limited by the only having two accessible variables. These two variables make things difficult, but still allow for operations, and interactions between both variables.
==Language description==
Tuvars is an interpreted esolang written in C#. It was semi inspired by 512, and has many commands, allowing for printing strings, and ASCII values, and even the number values of variables. Tuvars is readable and commands are done line by line, variables are addressed by a and b, being the only two variables, and you are unable to change their names. The names of variables a and b will be replaced by their values when used in an argument that a variable is acceptable, and that the argument is usually an integer or double. Tuvars rounds to the nearest integer when a variable is needed as an integer, but they are stored as doubles.
==Commands==
Command 	Description
print [Predefined string]	Print a string set in code.
char [variable] 	Prints the ASCII character corresponding with the value of [variable]
number [variable] 	Print the value of [variable] to the console. Prints like an integer if it is a whole number.
read [variable] 	Sets the value of the variable with the name [variable] to the value of a read character.
linebreak 	Print a linebreak.
goto [line] 	Goto line of the number [line]
close 	Close the console window.
title [string] 	Set the console title to [string]
clear 	Clear the console window
if [variable] 	If the value of a variable is not 0, execute the next line, otherwise skip it
ifnot [variable] 	If the value of a variable is 0, execute the next line, otherwise skip it
All commands which first arguments are not any that a command holds, aren't checked or executed at all, and are fully comments.
==Example==
===Get ASCII Values===
Because input is recieved as the ASCII value of the inputted character, and you are also able to print the number value of variables, we can use this to get the ASCII value of whatever the user inputs. This program is bundled with the interpreter.
read a //Set a to ASCII value of input
clear //Clear the console
number a //Print a's value
linebreak // Print a linebreak
goto 1 //Restart
==Interpreter==
* Common Lisp implementation of the Tuvars programming language.
Category:Languages
Category:2022
Category:Turing_complete
Category:Implemented
Tweak

Tweak is a language by user:Maxsteele2 which starts like BASIC, but commands can be created, edited, or deleted to fit any task needed.
==Commands==
===Starting commands===
*Goto (number)
**Goto is used to go to another part of the program. This command cannot be deleted or edited.
*End
**End closes the program. This command cannot be deleted or edited.
*Newcom (command name)
**Newcom creates a new command or rewrites an old one; At this point, it is empty.
*Edit (command name)
**Edit edits a command.
*Delcom
** Delcom deletes a command.
===Creating Commands===
Commands are created in Javascript.
==EXAMPLE PROGRAM==
 10 Start
 20 Newcom Print
 30 Edit Print
 31 var x
 32 x = <input2>
 33 document.write ("ext");
 40 print Hello World
 50 End
Category:Languages
Tweet

Tweet is an output-only, interpreted programming language. It was coauthored by Nick Trebes and Brendan Gould. The language is designed to improve the social connectivity of the programmer.
==Source Code==
Every file is a valid Tweet script. Only the first 280 bytes will be used. The rest is treated as comments. Less than 280 bytes is sufficient, so long as there are an even, nonzero number of bytes in the program.
===Tokens===
There are three types of tokens in Tweet, literal strings, hash strings, and user strings. Hash strings are delineated by a '#' and are composed of [a-zA-Z0-9] characters, unbroken by whitespace or punctuation. User strings are exactly like hash strings, but are delineated by a '@'.
==Interpretation==
The first 280 bytes are interpreted into literal, hash, and user strings using the Unicode character encoding. These literal, hash, and user strings are then concatenated, outputting the result to the Twitter account of the user.
==Requirements==
Tweet requires a Twitter account.
==Example Program==
The following program outputs 'Hello, World! #MyFirstTweetProgram'.
 Hello, World! #MyFirstTweetProgram
==Important note==
This language is a joke language.
Category:Joke languages
Category:Output only
Category:Languages
Twimp

The Twimp programming language was invented by accident in 2004. Some information can be found in http://zzo38computer.org/esoteric/twimp/ But now I forget mostly how it works (but see the documentation and PHP code).
==Features==
* There is no way to store numbers.
* Input is a nybble at a time, but output is a byte at a time. This makes a cat program to be a bit long
* If you type AVARTA KADAVRA then it returns a fatal error "Fatal: Bad Magic"
* There are 4 built-in constants: ZERO (actually 1, to confuse you), ONE (actually 0, to confuse me), PI (set to 3, in case you are too much religious, and because only integers are supported), and HOURSINADAY (which can be used as a filter criterion, or at least could if the programming language had filter criteria).
* Forced constants are in roman numerals
* You can type a program without ever using the shift key
* You can deal with "half-references" with the REF and PULL commands
* The program can be drunk by using DRINK command
* Duck-sauce replaces the entire equasion with zero
==Preprocessor Commands==
* ABREV (abbreviation)
* INSTRUCT
* ACT
* ACTS
* NPR (Combination of NEW, PUSHLN, and RET)
==Program Commands==
* RET
* PUSHL
* PUSHLN
* OUT
* POP
* MOVE
* KEYOUT
* KEYIN
==Examples==
Copy input to output (cat):
 NEW 1
 NEW 2
 PUSHLN 1
 PUSHLN 2
 -NO
 NEW 3
 COPY 1 2
 MOVE 1 3
 COPY 2 2
 MOVE 2 3
 COPY 3 2
 COPY 3 []
 NEW 4
 FORGET
 PUSHLN 4
 STEP IV
 POP 3 1
 OF [6-[3]]
 NEW 5
 PUSHLN 5
 RET 4
 ON 5
 OUT [[[=====]--[]]-16]
 RET 2
Twitty

Twitty is a stochastic non-imperative language without any control. The design goal of this language is to explore computational ability (and reliability) of a hivemind of non-cooperative human beings.
==Source Code==
Every UTF-8 encoded file is a valid Twitty script. Only the first 280 characters will be used. The rest is treated as comments.
==Requirements==
Twitty also requires a Twitter account.
==Implementation Details==
The contents of a file are dumped into a distributed cloud computing service (here, Twitter), to be processed by HBCU (human being computational units). The reply with most likes is the output of the program.
==Example Program==
The following program sometimes outputs 'Hello, World!'.
Hello, World!
So, it may be a Quine.
==Important note==
This language is a joke language.
Category:Joke languages
Category:2021
Category:Probabilistic
Category:Nondeterministic
Category:Languages
Two

Two is a language invented by User:Tailcalled. It is an uncomputable extension to a Brainfuck dialect, designed to increase the power as much as possible with a single instruction.
Two has nine instructions, eight of which are similar to Brainfuck. The syntax rules are the same as in Brainfuck.
Instruction 	Description 	Name
Increment 	Increments the value pointed to. There is no maximal value. 	+
Decrement 	Decrements the value pointed to. The minimum value is 0. Noops if the value is already 0. 	-
Next 	Increments the pointer. There is no maximal index. 	>
Previous 	Decrements the pointer. There is no minimal index. 	<
Loop (begin)	Loops the body while the value pointed to is not zero. 	[
Loop (end) 	Loops the body while the value pointed to is not zero. 	]
Output 	Outputs the value pointed to as a unicode codepoint if valid; otherwise noops. 	.
Input 	Inputs a unicode codepoint and stores it as the value pointed to. Stores zero on EOF. 	,
Instruction 	Intuitively, sets the value pointed to to "infinity". More formally, sets the value so high that increasing it further will not change the behaviour of the program.	I
Instruction might seem a bit vague, but can be explained as follows: we say that the effect of a program is its I/O behaviour and whether it terminates. Thus, the effect of the program + is "nothing"; a program consisting of + simply terminates. Instruction will then increase the value pointed to until further increases do not change the effect. If that cannot be done (for example, in the program I[->.<]), Instruction will loop forever.
Instruction has been inspired to adding an "infinite" number to arithmetic by exploiting the compactness theorem.
== Computational class ==
Two is easily able to solve the Halting problem, so it is more powerful than Turing-equivalent languages. The exact power of Two is unknown, but it would not be unreasonable to question its consistency or well-definedness.
Category:LanguagesCategory:Uncomputable
Two-instruction madness! (fr this time)

Two instruction madness! (fr this time) is my first esolang after my hiatus from esolanging for a long time. 
==Main==
As it's name implies, Two instruction madness! (fr this time) is Two-instruction madness! with actually 2 instructions, and it's still turing complete! (Also so that people cant complain "I/D machine has two instructions!!!") It keeps the micro transactions, using e and a. Before understanding the instructions, we need to understand the data direction. The data direction is the direction the data pointer moves when executing a e instruction. The e instruction checks if the current cell the data pointer is pointing to and if it is 255, (cells are 8 bit numbers) e will flip the direction of the data pointer, jump execution to the instruction before the last e in the code, however, if it is a e, move the code pointer back until the last a, then go to the e in front, and then move the data pointer. If the cell is not 255, e just moves the data pointer. a adds 1 to the current cell without moving the data pointer.
==I/O==
There is a optional instruction , fittingly named i/o which if the data pointer is on a cell with 255, it takes all cells up to the next 255 and displays them as a string. If not, it sets the current cell to the input value.
==Turing completeness proof==
The proof is by reduction to everyones favorite language!!!!! brainfuck. (a modified version of it) We are readucing to the instructions of brainfuck.
-
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+
a
[] (0=255) (assuming code ends in a and has 1 255 padding byte 2 bytes after the main data and the data pointer is at the end of the data (not the padding byte) and the data direction is facing the padding byte and the code is designed for the data direction to be facing the opposite direction of the direction to the padding byte 2 bytes of movement after the "end of the data") 
ee(insert code here)eaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaee
Category:Languages Category:Cell-based Category:Turing complete Category:Turing tarpits
TwoFiftyFive

TwoFiftyFive is an esoteric programming language by User:SoundOfScripting with only two instructions and limited memory.
==Syntax==
===Instructions===
* Move instruction (xxyy): Sets RAM(xx) to yy. Whitespace is allowed after a move instruction.
* Pointer instruction (*zz): Gets RAM(zz). This is stackable and can be used as the input of a move instruction.
===Memory mapping===
There are 256 bytes of RAM in TwoFiftyFive. In order to do computation, some indexes of RAM are memory mapped.
RAM Index	Mapping
FF 	Instruction pointer. Incremented after every move instruction unless changed. (Only 256 instructions per program, wraps from 256-0)
FE 	NAND Input A.
FD 	NAND Input B.
FC 	Hardwired to RAM(FE) NAND RAM(FD) (bitwise). Read only.
FB 	Stack I/O (Pushes to stack on set, pops from stack on read)
FA 	Program I/O (Outputs on set, inputs on read)
F9 	Left shift (After every instruction, the value of the address gets shifted to the left 1 bit)
F8 	Right shift (After every instruction, the value of the address gets shifted to the right 1 bit)
==Memory Extension==
In order to actually get anything done, TwoFiftyFive will probably need more memory. In order to achieve this, we can combine multiple programs into one, which can communicate using the stack. Here's an example that forever outputs the value 1:
 <Generate>: //Header for a program called "Generate"
 FB01 <Output> FF00 //"<Output>" tells the interpreter to switch execution to program "Output". This is NOT an instruction, and can not be jumped to.
 <Output>:
 FA*FB <Generate> FF00
Each program in the above example has its own memory and instruction pointer. When a program is swapped to, it's instruction pointer will resume to the location it ended in the previous time executing the program (defaults to 0).
A program without any headers is just counted as a single program.
==Examples==
===Hello, World!===
 FA48 FA65 FA6C FA6C FA6F FA2C FA20 FA57 FA6F FA72 FA6C FA64 FA21 FF0D
Output:
 48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21 (Hex)
 Hello, World! (UTF8)
==Computational class==
TwoFiftyFive is probably possibly turing complete using the memory extension.
==External resources==
None.
Category:Languages
Category:2017
Category:Push-down automata
TwoStep

TwoStep is an esoteric programming language where each statement consists of two characters: a command character and a single digit (or other character). There are 12 commands, and it uses digits 0-9 and a single byte of memory.
==Commands==
Command 	Function
Adds the given digit to the memory 	
Subtracts the given digit from the memory	
/ 	Divide the memory by the given digit if the digit is not zero
* 	Multiply the memory by the given digit
> 	Do next statement if the given digit is less than the memory, otherwise skip over next statement
< 	Do next statement if the given digit is greater than the memory, otherwise skip over next statement
) 	Do previous statement if the given digit is less than the memory, otherwise skip over next statement
( 	Do previous statement if the given digit is greater than the memory, otherwise skip over next statement
[ 	Output the ASCII character associated with the memory. Digit is ignored
] 	Input an ASCII character store its code in the memory. Digit is ignored
. 	Stop the program. Digit is ignored
 	(space) No operation. Digit is ignored, so it can be used for comments
==Examples==
This program prints out "Hello, World!" Notice the comment at the beginning.
 H e l l o , W o r l d ! *0+6*2*6[ *0+5*5*4+1[ +7[ [ +3[ *0+5*9-1[ *0+8*4[ *0+9*9+6[ *0+5*5*4+9+2[ +3[ -6[ -8[ *0+8*4+1[ . 
This program runs an infinite loop that prints out "x".
 *0+6*4*5[ )0. 
This cat program outputs its input.
 ] [ . 
It may be possible to create a quine in TwoStep, if you can manage to run the following program using the same byte of the memory the program is stored in. However, this program only uses a single character, instead of the required two, for the statement.
 [
==Interpreter==
* Common Lisp implementation of the TwoStep programming language.
Category:Languages
Category:Implemented
Category:2006
Two Fifty Six

TFS is a little idea of mine (User:Jercos). I was playing around with logical gates and truth tables, and realized any two-input gate could be represented by reading the Z column of a truth table as a nybble, like so:
 1100 A
 1010 B
 ------
 0000 False
 0001 NOR
 0010 B && !A
 0011 !A
 0100 A && !B
 0101 !B
 0110 A != B (xor)
 0111 !(A && B)
 1000 A && B
 1001 A == B (xnor, or cmp)
 1010 B
 1011 B || !A
 1100 A
 1101 A || !B
 1110 OR
 1111 True
So for example, for the OR gate, one looks up the A and B combination for the input (A=0 B=1 is column 3) then picks that bit from the code for the gate (column 3 is a "1") and that's the result.
One could easily see how this could be used just as easily for three-input one-output gates, resulting in (ta-da) 256 possible gates. these gates are fairly boring, as they can all be easily represented using two of the sixteen gates above with the ternary operator (I took this shortcut quite bit bit making the table... see below.) however, this *would* allow the gates to perform *any* possible operation, using a shift register (see below, tape.) however, most of the useful gates will simply be repeated over a given space (01100110 for the XOR(B,C) gate, for example, ignores A completely, and thus allows working on the tape without caring what comes back...)
A start on a handmade table of gates, represented in C-like syntax is at http://jercos.dyndns.org/~jercos/256gates.txt (I'm not quite done, only about half-way through as of writing this...)
I figured that this would make a decent basis for a esoteric language that wouldn't be too hard to implement, as I'm not all that great of a coder :P
so, on to TFS itself. TFS, as the name implies, uses 256 different gates, represented by 8 bits. There are three single-byte registers, all of which are passed to any operation, A, B, and C. three more bits address the destination, A (000), B(001), C(010), or the tape (011 for the current cell, 100 moves the tape backwards one bit before writing, 101 moves the tape forward one bit before writing, 110 and 111 do the same for whole bytes).
The tape is a (theoretically) unlimited string of bits, and any operation on the tape saves the old value of the tape in register A after the operation completes (e.g., A for the operation is the old A, A for the *next* operation is the value of the tape before the previous operation. if that doesn't make sense, tmp=*tape;*tape=operation(A,B,C);A=tmp). I added this after I realized there was no way to do bit shifts, and thus, addition, without some kind of shift register. also, tapes of memory and turning completeness seem to be close cousins, so, ya know...
Category:Ideas
Two commands

Two commands is a programming language that uses two commands
== Commands ==
 0 - add 0 to the start of the code and add 1 to the end of the code
 1 - if the end of the code is 1, add 0 at the end of the code as a command, and remove the first digit of the program
 EOF - return program
== Example ==
 0
 infinite loop
 0
 001
 0010
 001001
 0000010
 000001001
 ...
 10
 longer infinite loop
 10
 10
 10001
 100010
 10001001
 100010010
 10001001001
 ...
 11
 short infinite loop
 11
 10
 0101
 1010
 010101
 101010
 ...
Category:Languages Category:Self-modifying Category:String-rewriting paradigm Category:Unknown computational class Category:No IO
Two variable language

Two variable language is an esolang by User:ChuckEsoteric08 based on B2C.
==Specification==
Language works on two variables, a and b, which store unsigned and unbounded integers. Initially, a is set to 0 and b is set to 1
===Commands===
Pointer starts at variable a
 + - add values of current variable and other variable, store result in current variable
 - - subtract value of current variable from other variable, store result in current variable. If result is less than 0, then halt
 * - multiply values of current variable and other variable, store result in current variable
 / - divide value of another variable by value of current variable, store result in current variable. If current variable was 0, or value of another variable is not divisible by value of current variable, then halt.
 % - divide value of another variable by value of current variable, store remainder in current variable. If current variable was 0, or value of another variable is not divisible by value of current variable, then halt.
 !x - perform operation x with both arguments being current variable.
 | - swap variables
 ( - if variable is not 0
 ) - end if
 { - while not 0
 } - end while
 [x - repeat commands x times. x is digit from 0 to 9
 ] - end repeat
 . - output variable as an integer
 , - input integer and set variable to it
 ; - input Unicode character and set variable to it
 : - output variable as Unicode character.
 $x - set variable to value of Unicode character x
 digit from 0-9 - set variable to it
 > - increment variable
 < - decrement variable
==Examples==
===Character-based Cat===
 ;(:;)
===Integer-based Cat===
 ,(.,)
===Hello, world!===
 $H:$e:$l::$o$,:$ :$w:$o:$r:$l:$d:$!:
===Infinite loop===
 >(.>)
Category:Languages Category:Turing complete Category:Turing tarpits Category:Unimplemented
Twocoman

Twocoman is a worse version of BF.
==Commands==
 0 moves mode pointer to the next mode
 1 executes command at mode pointer
Everything else is a comment
==Modes==
 x the mode you start in. does LITERALLY NOTHING but you HAVE to use it at start NO MATTER WHAT
 + when used 1 in this mode, increments cell at memory pointer by 1
 - when used 1 in this mode, decrements cell at memory pointer by 1
 . when used 1 in this mode, outputs cell at memory pointer in ascii
 , when used 1 in this mode, asks for input in ascii and saves it at memory pointer
 ? when used 1 in this mode, outputs cell at memory pointer in numbers
 ! when used 1 in this mode, asks for input in numbers and saves it at memory pointer
 [ when used 1 in this mode, BF bracket
 ] when used 1 in this mode, BF bracket
 < when used 1 in this mode, moves pointer left
 > when used 1 in this mode, moves pointer right
==Examples==
===Hello, World!===
This program in the binary format prints the message “Hello, World!”:
 1010000001000000110000000010001000001000110010000000001000111110000000110000000000101000011000000010000111000000100100010100000001110010010000000110000110000000001110000001000000010000000100000000010111100000100000000011100100000000001111110100000011000010100000001111001001
====Hex====
Its hexadecimal equiparation can be yielded via
 A040C02208C8023E0300286021C09140724061803810101005E08039003F40C280F24
====Mode sequence====
Illustrated by the sequence of its modes, we obtain:
 x+[-->-[>>+>-----<<]<--<---]>-.>>>+.>>..+++[.>]<<<<.+++.------.<<-.>>>>+.
===Cat program===
In its binary format, a repeating cat program, which terminates on a null character input, is implemented as follows:
 101000000100000000100000000001000001
====Hex====
Its hexadecimal reformulation applies as such:
 A04020041
====Mode sequence====
The program's mode sequence equivalent assumes the form
 x+[,.]
===Truth-machine===
A truth-machine is provided in the following:
 100000010100000000010001000000001
In no language would I think the cat would be longer than the truth machine, but here we are. 
====Hex====
The hexadecimal twin amounts to:
 814011008
====Mode sequence====
The sequence of modes constitutes:
 x![?]?
==Interpreter==
* Common Lisp implementation of the Twocoman programming language. The program amplects the capability to interpret three formats of source code: binary, hexadecimal, and immediate mode sequences.
==See also==
* ?!, an extremely similar language, but uses the question mark and exclamation mark, and lacks the , and modes.
* Malbrain
Category:2023Category:LanguagesCategory:Turing completeCategory:Implemented