nyuuzyou/wikis huggingface dataset:
Tapelang

Tapelang is a cell-based language by User:ChuckEsoteric08 that compiles to UBLANG.
==Description and Commands==
It has inital tape 1001 and points to third cell.
r	move pointer right
l	move pointer left
0	creates cell with value 0 left to current cell and move pointer to that cell
1	creates cell with value 1 left to current cell and move pointer to that cell
o	output tape
If you are trying to move right if current cell is 0 and there not other cells after it or the same for trying to move left, then goto start of the program. How it will be executing is based on compiled code.
===How it works===
2 accumulators are named "left" and "right". Conversion is based on this. Because of UBLANG have not multiply and divide commands it adds and substracts value of accumulators to it. 
==Compiler==
Here
Category:Languages Category:Finite state automata Category:Cell-based Category:2022 Category:Implemented Category:Output only Category:Unusable for programming
Tau-Alpha-Upsilon

Tau-Alpha-Upsilon, or simply TAU(pronounces [tʰay]), is designed by PSTF and it is to expand Deadfish.
== Commands ==
This didn't uses accumulator, but a memory.
 Command Table in 1.0 version
TAU 	Origin
i 	increment
d 	decrement
s 	square
S 	say(output as integer)
l 	listen(input integer)
w 	write(output as Unicode)
r 	read(input character)
><,.[] 	Same as brainfuck
c[language name] 	Change to language_name
f(name, *args, **kwargs){	(Start to define a function)
} 	(End of function)
ex(name, *args, **kwargs)	execute function
h 	Hello, world!
; 	(seperates the command)
== Example ==
=== Hello, world! ===
h;
== Categories ==
Category:Languages
Category:Deadfish derivatives
Category:Unimplemented
Category:2024
TaurusVM

TaurusVM is a virtual machine with esoteric properties (well, technically, a collection of VMs). It is managed by the Zodiac Working Group.
== Virtual Machines ==
TaurusVM supports multiple Virtual Machines with different esoteric properties. An optimal [lang]->TVM compiler will analyze the program for the optimal VM to use, but any real compiler is not expected to. As such, a compiler can just use IndeterminantVM (or another, if they please, but that one should be the easiest to work with usually). Speaking of which...
=== IndeterminantVM ===
IVM supports variable (indeterminant)-length arguments. Instead of ADD, it has SUM, et cetera.
=== ThueVM ===
ThVM is based on string operations. It is not actually that much like Thue otherwise.
=== ArbourVM ===
AVM is like a normal VM, but the Registries lie on a tree as opposed to an array. It uses a pointer for simplicity.
=== GreekVM ===
GkVM is a kind of simulation of what the Greeks' (who did a LOT of geometry) computers' ISAs would look like. The Registries are 64-bits, with the first 32 representing a point's position on the x-axis and the second 32 on the y (in floating-point, of course). Operations involve constructing things out of these points.
== See also ==
*Virgo: A midlevel (partway between assembly and programming) language that will compile to the TVM
*Stare: A declarative language group that will run on Taurus
*Zodiac Working Group: The TVM, Virgo, and Stare designers
==External resources==
* The Homepage
Tautologos

Tautologos is an esoteric programming language by User:Rdococ and intended inverse to Table. The original pitch was that everything is a function, much like in the lambda calculus. (Apparently, I had not heard of the lambda calculus at the time.)
Table is basically a language for describing recursive data structures extended slightly to make it Turing-complete. Tautologos is sort of its inverse - a language for describing functions first and foremost, with the ability to solve its own halting problem.
== Syntax ==
There is no distinction between statements and expressions. An expression can be:
* A variable name x
* A local variable definition x := y
* A variable assignment x = y
* A function definition fn (x, y, z...) {}
* A function call f(x, y, z...)
* A sequence of expressions expr; expr; expr
== Semantics ==
Undefined variables are treated as global. Control flow is typical, except for the lack of control structures. Function call arguments are evaluated left to right. Variable definitions are not hoisted. A sequence of expressions returns its last value. The only values are functions.
A limited form of pattern matching is available where you can check the extensional equality of two functions by giving them the same parameter names in a function definition. All functions that perform the same side effects and return the same values (or lack thereof) when given the same inputs are considered equal.
If a variable is assigned a function that performs a pattern match, only the cases where those two arguments are equal are reassigned. You can use this to iteratively modify functions.
== Examples ==
=== Church numerals ===
0 = fn(f, x) {x};
succ = fn(n) {fn (f, x) {f(n(f, x))}};
=== Comparing for equality ===
true = fn(x, y) {x};
false = fn(x, y) {y};
not = fn(b) {b(false, true)};
eq = fn(x, y) {false};
eq = fn(x, x) {true};
=== Solving the halting problem ===
forever = fn() {forever()};
halts = fn(program) {not(eq(program, forever))};
paradox = fn() {halts(paradox)(forever, fn() {false})()};
== Trivia ==
* Tautologos is Greek for "repeating what is said."
Category:Languages
Category:Functional_paradigm
Category:Uncomputable
Category:2016
Tautology

Tautology is a programming language in which all of the programs and input evaluate to true. It is not Turing complete.
== Implementation ==
It is implemented in C++:
 #include <iostream>
 using namespace std;
 int main()
 {char x[65535];
 while(1){cout << "> ";cin >> x;cout << "True\n";} //Takes an input and outputs true
 return 0;}
Category:Joke languagesCategory:Unusable for programmingCategory:ImplementedCategory:2010Category: Languages
Tautologylang

Tautologylang is an esoteric programming language created by the creator of Tautologylang.
Tautologylang programs operate on the data structure operated on by Tautologylang programs.
==Syntax & Semantics==
Tautologylang's syntax is a carbon copy of the syntax used by Tautologylang.
==Example programs==
===Hello, World!===
(The hello world program in Tautologylang is identical to the hello world program in Tautologylang)
===Self-interpreter===
(The Tautologylang self-interpreter is equivalent to the self-interpreter program of Tautologylang)
==Implementations==
The reference implementation of Tautologylang can be used by using the reference implementation of Tautologylang.
Category:2022
Category:Joke languages
Taworvor

Taworvor is a stack-based, semi-verbose looking programming language by User:Feuermonster. 
== Language Reference ==
Will hopefully be done as part of ESOSC.
You can have a look at the draft: ESOSC-2015-D7.
== Examples ==
(Taken from the "test-suite"):
PROCEDURE TESTS.LIST
 REM
 Tests list built-ins.
 ^END
 
 [1 2 3]%[1 2];
 [D1.0 2 3]~3;
 [2 5 0]^2;
 [2 5 0]_[5 0];
 [5 6 7]1!6;
 5([5];
END
== External resources ==
* Github Repository
Tbf

tbf is a language that can be used to write Brainfuck programs in a simpler way. Programs written in tbf are compiled to Brainfuck, where they then can be compiled using any BF compiler.
==Syntax==
tbf includes the following constructs:
General:
* Everything is case insensitive (“hello” is the same as “Hello” as “HELLO” etc)
* Every command has to end with a ”;”
* You can do comments by using ”%” to start a comment. The comment will end at the end of the line (as in Bash for example).
* All new identifiers (variables) will be automatically allocated and initialized as zero.
Basic commands: 
* “moveto <identifier>;” moves the tape at the place designed by <identifier>
* “inc;” increment the current position
* “dec;” decrement the current position
* “put;” output the current position as a character on the screen
* “get;” read a character from keyboard into the current position
* “zero;” set the current position to zero
* “print;” output the string that starts at the current position (yes tbf has strings. I'll get into more detail later)
* “Add <identifier>” adds the value stored at <identifier> to the current cell. Be carefull, there still might be a bug that makes your program go into an infinite loop when you add an identifier to itself. I meant to fix it, nut I am not sure if I ever did. 
* “Sub <identifier>” similar to add, but does subtraction
* “Store <identifier>” store the value that is designated by <identifier> at a the current position
* “Retrieve <identifier>” restore the value of an <identifier> from the current cell
Identifier can consist of the following: 
* names of variables in the form [A-Z a-z _][A-Z a-z _ 1-9]*
* integer literals (e.g 10, 11, -1234 etc)
* single characters in ' '
* Strings in ” ”
* “new” this identifier always indicates a newly produced value
* ”.” to current position
* ”&<identifier>” yes this works to, take a c-guess what it does
More complex constructs: 
* “While <test> do <expr>” Loops. When you enter the loop the tape will point to identifier that was used in the test
* “Begin <expr>;[<expr>;…] end” blocks of code, used to group several instructions
* “declare <identifier> as <identifier>” this introduces an alias for a previously used identifier
Tests: 
* “isneg <identifier>” tests whether an identifier is negative 
* “ispos <identifier>” tests whether an identifier is positive 
* ”<identifier>” tests for zero
== Example Programs ==
===Hello World===
 moveto "Hello World!\n";
 print;
(Yes, strings are this simple) 
 
===Output all chars from 255 backwards===
 while 255 do begin
 put;
 dec;
 end 
 
===Cat program===
 moveto new;
 inc;
 while . do begin
 get;
 put;
 end
 
===Multiplication of two numbers as a macro===
 define mult(a,b) as begin
 zero;
 moveto hlp;
 add a;
 while hlp do begin
 dec;
 moveto mult;
 add b;
 end
 end
 moveto new;
 mult(10,9);
 put;
==See also==
* ClearBF
== External resources ==
* 
Category:Brainfuck
Category:Compilers
Category:High-level
Category:Languages
Tc2

tc2 is a turing complete esolang with only two instructions. It was designed by User:Tommyaweosme.
== Commands ==
 a - move command pointer one
 b - execute command
The command pointer can go through these Brainfuck commands.
+-<>.,[]
== Turing-completeness proof ==
 + b
 - ab
 < aab
 > aaab
 . aaaab
 , aaaaab
 [ aaaaaab
 ] aaaaaaab
Techno

Techno is a sort of one-instruction language designed by Keymaker, published in 2020.
The functionality of the sole instruction is defined by the given program in form of two expressions, location and value. To the memory location (memory is unbounded array beginning from index 0, with unbounded non-negative cells, all initially 0 except for a finite portion initialized by the given program) yielded by the first expression is set the value yielded by the second expression. Then the value in memory location 0 is increased by one. A step is completed. This is repeated infinitely unless the program halts (there are three conditions on which the program may halt successfully; if subtraction yields a value less than 0, if attempting to divide or modulo by 0).
==Computational class==
The language is shown Turing-complete via I/D machine translation (see linked page for more details).
==Example program==
Here is a translation of the I/D machine program IDIIDD into Techno:
 [0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1]<((
 [[0]%6*6+0+2])*([1]+38))+(([[0]%6*6+1+2])*(1))+(([[0]%6*6+2+2])*([1]+38))+(([[0]
 %6*6+3+2])*([1]+38))+(([[0]%6*6+4+2])*(1))+(([[0]%6*6+5+2])*(1))><(([[0]%6*6+0+2
 ])*([[1]+38]+1))+(([[0]%6*6+1+2])*([[1]+38]))+(([[0]%6*6+2+2])*([[1]+38]+1))+(([
 [0]%6*6+3+2])*([[1]+38]+1))+(([[0]%6*6+4+2])*([[1]+38]))+(([[0]%6*6+5+2])*([[1]+
 38]))>
==Ambient Techno==
There is a variant of the language that is in every way identical except for the automatic increasing of memory location 0 at the end of a step. This variant is Turing-complete likewise, as is shown with a Minsky machine translation (see linked page). On the Talk:Techno page there is an alternative Turing-completeness proof utilizing Tip.
==External resources==
* Techno page (detailed explanations of the language and the I/D machine and Minsky Machine translations, translator programs, interpreter in Python)
Category: Turing complete
Category: Turing tarpits
Category: Low-level
Category: OISC
Category: Languages
Category: No IO
Category: Implemented
Category: 2020
Teg

Teg is an esolang based on strings invented by User:A. It has condensability as well as minimalism and legibility in mind. Normally, it is used to code golf, but it might be used in other circumstances. (By the way, it is a Text derivative.) What differs between this and other esolangs is:
* Alphanumerical characters are automatically printed (including quotation marks)
* There are readable and straightforward if statements, for and while loops(at least better than Keg)
* A few commands should be remembered
* And so on...
==Simple documentation==
[]:evaluate operator. Note that this prevents a block of Teg code to be printed.
a?b:c:If a is not 0, return b. Otherwise, return c.
a?b:If a is not 0, return b.
f(i:end){block}:For loop. Sequentially set i into values from 0 to end while executing block. For example: if end is 5, i will be set to 0, 1, 2, 3, 4, and 5.
f(i:begin,end){block}:Also a for loop. Like the one above, sets i into values from begin to end.
f(i:begin,end,step){block}:Yet another variation of the for loop. Sets i into values from begin to end with a step. For example: if begin=0 and end=8 and step=2, i will be set to 0, 2, 4, 6, and 8. Another example: if begin=8 and end=0 and step=-2, i will be set to 8, 6, 4, 2, and 0.
=: define a variable(or possibly a macro).
==: check if equal
!=: check if not equal
>: greater than
<: less than
>=: greater than or equal
<=: less than or equal
!: bitwise NOT
&: bitwise AND
|: bitwise OR
+: add
-: subtract
*: multiply
/: divide
%: find the remainder
^: to the power of
:x:: input a variable(macro?) x
`x`: switch between integer and character variables
==Examples==
===99 bottles of beer===
This non-cheating version is a lot shorter than the cheating version of Keg.
b= bottle[i!=1?s] of beer
f(i:99,1){[i][b] on the wall,
[i][b].
Take one down, pass it around,
i?[i-1]:no more[b] on the wall.}
===Hello, world!===
Hello, World!
===Quine===
Q
===Cat program===
w(1){:q:[q]}
===FizzBuzz program===
f(i:z){!i%3?!i%5?FizzBuzz:Fizz:!i%5?Buzz:[i]
}
===Fibonacci sequence===
a=1;b=1;w(1){[a] a=a+b;t=a;a=b;b=t}
===Deadfish interpreter===
c(i);w(1){>>:i:i=="d"?[a=a-1]:i=="i"?[a=a+1]:i=="o"?[a]:i=="s"?[a=a*a]}
===Factorial===
:c:f(i:c,1){a=a*i}[a]
===Truth-machine===
:c:c?w(1){1}:0
Category:2019
Category:Languages
Category:Unimplemented
Teleport

Teleport is a 2-dimensional esoteric language created by User:Infinitehexagon that changes direction in 2 areas; left and right(the default direction is right) and uses a portal to change lines.
Category:2023Category:Languages
==Syntax==
All programs start at > and end with v. Here is an example;
>(your program)v
A program does not have to start with >, but it has to start at the top left of the program.
If a program does not end with a v, then the program is infinitely running until it is halted with a 3.
==Portals==
Portals are labeled with certain characters with the same ID, such as an uppercase and lowercase character being a portal.
Different portals cant have the same characters used or the same character at the different location will go to the first receiver portal.
===Letter Portals===
a and A have the same ID, which the lowercase is the transmitter portal and uppercase is the receiver portal.
 
 A111b 
>B a 
==Instruction==
Instruction	Description
1 	increment the nearest portal's accumulator by 1
2 	decrement the nearest portal's accumulator by 1
3 	Halt the program and output the nearest portal's accumulator when accumulator is 0
4 	Input a decimal value into a portal's accumulator
5 	Square the value of a portal's accumulator
6 	Change the direction (default is right)
==Cat program (5x2)==
Ab---
>B43a
==Truth machine (4x1)==
4B3b
==Hello world==
A111111111111111111111111111113b-----
||-----------------------------------
||-----------------------------------
||-----------------------------------
||-----------------------------------
||-----------------------------------
||-----------------------------------
||-----------------------------------
||-----------------------------------
dE1113v-------------------f------C6--
DeBA11111113----------------------c--
>111552222222223a--------------------
Tellurium

Tellurium is an esoteric, tape-based programming language invented in 2016 by User:M654 with code-golf challenges in mind.
== History ==
Tellurium was originally called Brainfish, and was supposed to be a combination of brainf*ck and Deadfish. It was later renamed Tellurium.
== Instructions ==
Tellurium currently has the following commands:
Command	Meaning
> 	Move one cell up the tape
< 	Move one cell down the tape
e 	Move ten cells up the tape
E 	Move ten cells down the tape
h 	Move 100 cells up the tape
H 	Move 100 cells down the tape
+ 	Add one to the selected cell
- 	Subtract one from the selected cell
/ 	Add ten to the selected cell
\ 	Subtract ten from the selected cell
" 	Add 100 to the selected cell
' 	Subtract 100 from the selected cell
^ 	Output the selected cell's value
! 	Convert the selected cell's value to an ASCII character and output it
% 	Converts a character in the selected sell to an ASCII value
a 	Takes the selected cell and the next cell and adds them together into the selected cell
s 	Takes the selected cell and the next cell and subtracts them into the selected cell
m 	Takes the selected cell and the next cell and multiplies them into the selected cell
d 	Takes the selected cell and the next cell and divides them into the selected cell
i 	Read input and store it in the selected cell
µ 	Read a string until the ~ command and store it in the selected cell
~ 	End a µ-command
& 	Enters string manipulation mode
. 	Exits the program/exits string manipulation mode
r 	Reverses the selected cell's value (string manipulation mode)
u 	Makes the selected cell's value uppercase (string manipulation mode)
l 	Makes the selected cell's value lowercase (string manipulation mode)
==Turing-completeness==
Tellurium is Turing-complete, as Tellurium's commands can mimic brainf*ck's.
Brainf*ck	Tellurium
+ 	+
- 	-
> 	>
< 	<
, 	!
. 	i
[ 	{
] 	}
== Examples ==
===Hello, world!===
 µHello, world!~^
===Cat program===
 i!
=== Simple calculator ===
 i>i<a!
== Interpreters ==
=== Python ===
The original Tellurium interpreter written in Python is available at GitHub here.
Category:Languages
Category:Cell-based
Category:Implemented
Category:2016
Category:Turing complete
Category:Brainfuck derivatives
TempoVar

In this programming language TempoVar, there is only one variable and one flag. It also supports backtracking and executing commands on future tempos.
Commands:
* period: This command steps to the next tempo.
* number,colon,command: This is a do execution of commands in a future tempo. The number (which must be a integer at least 1) is the number of tempo steps until it is executed. It is executed right on the tempo, and if multiple commands are waiting on a tempo, it is a queue (first in first out) that executes in order all during same step.
* zero or more commands in curly braces: This counts as one unit so can be used where a command is used.
* percent,command: This sets the value of variable to that command.
* at: The at sign executes the command stored in the variable.
* plus,command: Makes a backtrack point (similar to MAYBE in backtracking INTERCAL, the choice point is added to stack, which contains the entire program state). The command executes now (after the choice-point is added to stack), but not on backtracking.
* minus,command: Makes another backtrack point but the default is not execute command, and it executes on backtracking.
* less: This is a GO BACK to the recent backtrack point, and now it is stale. If it is stale it discards instead.
* greater: This discards the recent backtrack point regardless of stale or not.
* number,asterisk,command: This will execute the command the number multiples of times.
* left parenthesis,command: Input one bit and execute command if bit is set.
* zero,right parenthesis: Output bit 0.
* one,right parenthesis: Output bit 1.
* slash: Toggle the flag.
* question mark,command: Execute command if flag is set.
* semicolon: Comment until end of line.
* uppercase letters,command: Define a command letter to be included when using lowercase letters. Each letter can only be defined once, and only at the outer level of the program.
* underscore,command: Prepends command to the beginning of value of variable.
Example of cat program:
 %{?/(/?1)/?0)@}@
Example to copy a flag to a later tempo-step:
 ?1:{?//}/?1:{?/}/
Example to count up in unary:
 E{0)0)1)0)0)0)0)1)} ; exclamation mark
 L{0)0)0)0)1)0)1)0)} ; line feed
 %{_el@}@
Category:Languages
Category:Unimplemented
Category:2007
Temporal

Temporal is a stack-based time-travel language by User:Plokmijnuhby (we don't appear to have one yet, and it's not like they're hard to design). It is hoped that it will be easier to demonstrate the computability of this language than other time-travelling languages like TwoDucks and TRAVEL 33.
When I refer to "a timestep", I don't mean any actual unit of time, I'm pretending that each instruction takes one timestep to run; this language cannot accurately tell the time, due to the time distortions caused by the wormholes used. In the event of a paradox, the distortions will become so great the code will run forever, so please try not to do that.
You'll also notice I haven't included usable input - many languages don't have this anyway, and it's just a bit confusing with time travel.
== Syntax ==
The syntax for this language is the same as Underload, but with two additional commands. The language is stack based, like Underload.
Command	Meaning
~ 	Swap the top two elements of the stack.
: 	Duplicate the top element of the stack.
! 	Discard the top element of the stack.
* 	Concatenate the top two elements of the stack.
(x) 	Push everything between the brackets onto the stack.
a 	Enclose the top element in brackets.
^ 	Pop the stack and add the popped element to the next part of the code (and execute it).
S 	Pop the stack and output the popped element.
< 	The "shove" instruction, not included in Underload. Pop two elements, where the first is an element with n elements (so (a(bc)d) has 3 elements) and push the second popped element on top of the stack n timesteps ago.
> 	The "grab" instruction, not included in Underload. Pop one element with n elements (as described above). Pop an element from the stack n timesteps in the future, then in the present push that element onto the stack. Kind of the inverse of <.
== Examples ==
=== Bootstrap ===
 (12)<
The program always tries to avoid runtime errors, so this does not produce an error. The element is shoved from the end of the < two steps back to just before the (12) command starts. We have no idea what the element is, we just know we can shove it.
=== Paradox ===
 (1)~()~(123456)*<
If the program shoves to 6 timesteps ago, the shoved element appears just after the (1) is pushed and is then swapped so the (1) is on top. A () is pushed - it will become the value to be shoved - and then the (1) has 6 elements appended to it. The () is then shoved back 7 timesteps - but wait, it was only supposed to go back 6 timesteps! If it goes back more than 6, it will appear before the (1) is pushed, so it will end up on top instead. Then when (123456) is appended to it, it will still only have 6 elements, leading to it being sent back only 6 timesteps. In other words, if it is sent back 6 steps, it is sent back 7 steps and vice versa.