nyuuzyou/wikis huggingface dataset:
TEPCS

TEPCS (Tilde, Exclamation Point, Caret, Semicolon) is an incomplete programming language created by User:Cortex at around midnight, November 4, 2018. Its file extention is .~~~, and only four unique characters (other than inputs) are used:
* ~, used in command names, the tally determines the command type
* !, used to terminate commands
* ^, used to separate the command name from the input(s)
* ;, used to indicate a variable as opposed to a string where necessary (~^;x;! would print the value of variable x) (inputs are strings by default)
==Examples==
Hello World program:
 ~~~!
 ~^Hello, World!!
99 Bottles of Beer:
 ~~~!
 ~~^bot^99!
 ~~~~~^s^98!
 ~^;bot; bottles of beer on the wall, ;bot; bottles of beer!
 ~^Take one down, pass it around,!
 ~~~~^bot^1^-!
 ~^;bot; bottles of beer on the wall!
 ~~~~~^e^0!
 ~^1 bottle of beer on the wall, 1 bottle of beer!
 ~^Take one down, pass it around, no bottles of beer on the wall!
Factorial:
 ~~~!
 ~~^n^5!
 ~~^factorial^1!
 ~~~~~^s^;n;!
 ~~~~^factorial^n^*!
 ~~~~^n^1^-!
 ~~~~~^e^;n;!
 ~^result = ;factorial;!
==List of commands==
Command 	Description
~~~! 	Starts the program.
~^x! 	If x is a string, prints it verbatim; otherwise, if x is a variable of the form ;variableName;, the variable value will be printed.
~~^x^y! 	Declares the variable x and initializes it to the value y.
~~~~^x^y^z!	Performs the binary operation z using x as its left operand and y as its right one. z may be any of the four operators + (addition), - (subtraction), * (multiplication), and / (division). x may be a variable.
~~~~~^x^y! 	Designates the start or end of a loop, depending on the value of x: If x equals s, the command starts the loop; if x resolves to e, the loop body end is demarcated. Between the loop start and end an arbitrary quantity of commands may be present for repeated execution. For a loop start command the input y must be an integer which determines the number of repetitions; for the loop end the input is ignored.
;^!x 	Marks the content x as a comment, thus ignoring input.
==External resources==
* Common Lisp implementation of the TEPCS programming language.
Category:2018 Category:Languages Category:High-level Category:Output only
TESTLANG

TESTLANG is an esolang created by User:Ractangle with one purpose. Testing stuff
==Syntax==
===Words===
Word	Action
out 	Prints a word next to it
note	Will ignore a word next to it
in 	Gets user input
push	Pushes a value to the stack
op 	Does an operation
end 	Ends the program
===Sub-words===
Sub-word	Action 	Used by
in 	Pushes the input to the stack 	push
char 	Prints a charecter 	out
out 	Prints the first element on the stack and it gets poped	push
plus 	Adds the two elements together 	op
==Examples==
===Cat program===
 in push in push out end
===A+B Problem===
 in push in in push in op plus push out end
===Hello, world!===
 out Hello, out char 9 out world! end
==Interpriter==
Github Repo
Category:Languages Category:Total Category:Unusable for programming Category:Implemented Category:Stack-based
TF2LANG

Category:2023
Category:Joke_languages
Category:Languages
Category:Object-oriented_paradigm
Category:Turing_complete
Category:Unimplemented
Category:Pseudonatural
TF2LANG is a language created by cocosbeans and cakedon in 2023 as an inside joke. TF2LANG is a language which replaces keywords with quotes from the Team Fortress 2 movies and can compile to actual languages simply by substitution. Quotes used in TF2LANG were cherry-picked to make some sense given context. This page is a WIP.
Quote 	JavaScript Equivalent 	Source 	Author
GIMME THAT 	require() (NodeJS) 	Meet the Spy 	cakedon
HAVE A PLAN TO KILL EVERYONE YOU MEET 	, 	Meet the Sniper 	cocosbeans
IT COSTS $400,000 TO FIRE THIS WEAPON FOR TWELVE SECONDS	delete 	Meet the Heavy 	cocosbeans
I TELEPORTED BREAD 	while 	Expiration Date 	cakedon
MINUS WE'RE NOT BREAD 	 	 	
Expiration Date 	cocosbeans 	 	
OKAY BYE BYE THEN 	] 	Expiration Date 	cocosbeans
PUT DISPENSER HERE 	log() 	Voice Line, Heavy 	cocosbeans
SCOUT IT'S PAULING 	[ 	Expiration Date 	cocosbeans
SIX 	 	 	
Expiration Date 	cocosbeans 	 	
STAND BACK SON 	static (C#) 	Meet the Spy 	cakedon
SYNCHRONIZE YOUR DEATH WATCHES 	let 	Expiration Date 	cocosbeans
THAT AIN'T RIGHT 	finally 	Voice Line, Engineer	cocosbeans
THE ADMINISTRATOR 	console (or Console in C#)	- 	cakedon
THE SPY HAS ALREADY BREACHED OUR DEFENSES 	void (C#) 	Meet the Spy 	cakedon
USE A GUN 	try 	Meet the Engineer 	cocosbeans
USE MORE GUN 	catch 	Meet the Engineer 	cocosbeans
WE'RE NOT DYING WE'RE GOING TO LIVE FOREVER 	const 	Expiration Date 	cakedon
WHAT THE HELL IS THAT 	= 	Expiration Date 	cocosbeans
YO WHATS UP 	(Beginning of code) 	Meet the Scout 	cocosbeans
YOU KNOW, CLASSY ONES 	class 	Expiration Date 	cocosbeans
YOU LEFT SEVEN WITNESSES, GUYS 	Expiration Date 	cocosbeans
THCA

, or Ternary Hybrid Computer Architecture, is a computer architecture that operates on a hybrid of Balanced Ternary and Unbalanced Ternary.
== Terminology ==
Trit: The ternary equivalent of a bit.
Tryte: The ternary equivalent of a byte, composed of 9 trits.
Trybble: The ternary equivalent of a nybble, composed of 5 trits.
T: True
U: Unknown
F: False
== Operations ==
=== Balanced operations ===
THIS PROGRAMMING LANGUAGE IS LITERALLY ALL NUMBERS

Author: User:Earthrulerr You can access a editor at here. TPLN consists of only numbers in its tags. TPLN is 1231 but with only numbers! Every statement must begin with 0 followed by the statement.
== HOW TO USE ==
0 must be used at the start of each statement.
1 followed by 101 (a) to 126 (z)
10 prints a new line to console.
20 prints a space to console.
-0 text comment.
111 clears console/restart.
2 # # # + #
-2 # # # - #
4 # # # * #
-4 # # # / #
6 # # # to the power of #
8 # input variable (1,2,3,4,5,6,7,8,9,10) = input. Single line only.
9 # prints value of variable (1,2,3,4,5,6,7,8,9,10) to console.
== EXAMPLES ==
0 1 108 105 112 112 115 1 0 20 0 1 123 115 118 112 104 1 Output: hello world
Category:2022
Category:Joke_languages
Category:Languages
Category:Total
Category:Thematic
Category:Implemented
THRAT

THRAT is a Brainfuck-derived esoteric programming language devised by Mate Varga in 2004. It uses two instructions to select from a table of ten operations, in the style of ReMorse. 
Like Brainfuck, THRAT has a memory block (4096 bytes by default) and a memory pointer that points to a single byte in the block.
The ten operations are the eight from Brainfuck plus two more: 
#	Description
0	Halt program execution
1	Increment the memory cell under the pointer
2	Decrement the memory cell under the pointer
3	Move the pointer to the right
4	Move the pointer to the left
5	Jump past the matching 6 if the cell under the pointer is 0
6	Jump back to the matching 5
7	Output the value of the cell under the pointer as a number
8	Output the character signified by the cell at the pointer
9	Input a character and store it in the cell at the pointer
There is an operation pointer which points to a single operation (initially the first). The ; instruction increments the operation pointer by 1, and the : instruction executes the operation which is currently pointed at.
==Computational class==
The THRAT commands are a proper superset of Brainfuck's, with no special restriction on the execution of arbitrary commands at arbitrary points; the THRAT specification also does not preclude having an unbounded store (either a block of infinite size, or a block which grows when the bounds are exceeded.) So THRAT is in the same computational class as Brainfuck. Brainfuck is Turing-complete, so THRAT is Turing-complete as well.
==See also==
* ReMorse
* Whirl
==External resources==
* 
Category:Languages
Category:Implemented
Category:Brainfuck derivatives
Category:2004
Category:Turning tarpits
Category:Turing tarpits
Category:Turing complete
Category:Cell-based
THROW THIS TO THAT

==Creator and Name==
THROW THIS TO THAT is an esoteric language created by the User:Esolang1. This language is heavily based on FROM HERE TO THERE, with the exception of not being able to handle files. So, you can expect to see some similarities with the language FROM HERE TO THERE in this page. (E1-0003)
==Code==
===Syntax===
Each line of the source code should have a code with the following syntax:
 THROW A TO B
Similar to FROM HERE TO THERE, A and B can be a value, a line, a variable, or a special value marked below.
===Special Values For Part: A===
 "IN" Getting input and storing it.
 "X" Execute the rest if the code with variable sent.
 a string Storing values to a variable, or printing out to OUT.
 an integer Storing values to a variable, or printing out to OUT.
 a float Storing values to a variable, or printing out to OUT.
 a boolean Storing boolean to a variable, or printing out to OUT.
 a variable Changing values, or printing out to OUT.
 a condition Creating conditional statements, such as if or else if.
===Special Values For Part: B===
 "OUT" Printing out A.
 "LINE" Move to the code in line A.
 a variable Declaring and initializing a variable.
 a variable expression Changing the value of a variable. (Mentioned below.)
 an integer Go to the line (inputted integer) with the value A.
===Variables===
Variable names are restricted to only use lowercase letters. This is because most of the code will be uppercase.
Declaring a variable with the name "a" and initializing with the value "b" looks like this:
 THROW "b" TO a
Like FROM HERE TO THERE, use reverse-operation notation to perform math on variables.
This code adds 3 to the variable a:
 THROW a TO a - 3
Subtract 3:
 THROW a TO a + 3
Multiply by 3:
 THROW a TO a / 3
Divide by 3:
 THROW a TO a * 3
==I/O==
Inputs and outputs are usable with the IN and OUT codes.
Getting an input and storing to variable a:
 THROW IN TO a
Printing the variable a:
 THROW a TO OUT
Or shorter:
 THROW IN TO OUT
==Examples==
===Hello, World!===
 THROW "Hello, World!" TO OUT
===Truth-machine===
 THROW IN TO a
 THROW a == 0 TO 6
 THROW a == 1 TO 4
 THROW "1" TO OUT
 THROW 4 TO LINE
 THROW "0" TO OUT
===Infinite cat===
 THROW IN TO OUT
 THROW 1 TO LINE
===Collatz sequence===
 THROW IN TO A
 THROW A TO OUT
 THROW A % 2 != 0 TO 5
 THROW A TO A * 2
 THROW 8 TO LINE
 THROW A TO A / 3
 THROW A TO A - 1
 THROW A TO OUT
 THROW A != 1 TO 3
==See also==
* FROM HERE TO THERE
Category:2022
Category:Languages
Category:Unimplemented
Category:OISC
TIB and STIB

A tib is half of a bit. A stib is a negative half of a bit.
A tib can have square root of 2 values. A stib has half the number of values that a tib has. A tib and a stib together can have only one value (one value = no information).
An idea would be if a programming language could be made using these new data types.
Category:Ideas
Category:Data Types and Structures
TISC

TISC (i.e. Two Instruction Set Computer) is a computer architecture invented by User:A that provides 2 instructions (but only one should appear in a practical source code). This tries to build a Von-Neumann architectured computer that is as simple as possible. (Yes, it contains all of the 5 units: input device, output device, control unit, arithematic unit, and memory unit.)
==Syntax==
As the overview says, it only provides two instructions:
* INC xx (opcode 1)
This flips the bytecode on address xx. Addresses are represented as 7 bits, and the opcode will be represented as 1 bit. (Special notes: the address starts at 0! The addresses count as one address; when this is triggered as an address, it increments the address instead with overflow mapping to 0.)
* JMP xx (opcode 0)
This sets the control flow to the address xx. (Please note that the source code is in the memory.) Jumping to an undefined address halts the program. Branching to an address results in branching to the previous opcode.
If any other opcode appears in the source code instead of INC, the execution will run inside an infinite loop, eventually breaking the computer...
Note that all addresses are inputted at the start of the program(as intgers; -1 does not set the address to anything, and no input results in nothing. This takes input as bytes.) In every step of the execution, all addresses will be outputted (which seems a bit annoying). No output will occur when the execution halts.
==Examples==
===Looping in order to increment the address on 13 two times===
INC 13
INC 9
INC 1
===Truth-machine===
This takes integer input to the first byte. When the input is 0, it branches to 0 and halts. When the input is 1, it loops forever.
JMP 0
Category:Languages
Category:2019
Category:Unimplemented
Category:Unknown computational class
TLIJMMWTRAMCBICHWTPITCSIBCTII

TLIJMMWTRAMCBICHWTPITCSIBCTII (This Language Is Just Minsky Machine With Twenty Registers And More Commands, But I Choose Hard Way To Prove It Turing Complete So I Wrote Bitwise Cyclic Tag Interpreter In It) is an esolang by User:ChuckEsoteric08.
==Specification==
TLIJMMWTRAMCBICHWTPITCSIBCTII has 20 registers. Indexes starts at zero.
 inc(x,y) - increment register x by y
 dec(x,y,z) - if register x is bigger than y decrement it by y, else goto z
 mul(x,y) - multiply register x by y
 div(x,y,z) - if register x is divisible by y, then divide it by y, else goto z
 inp(x) - set register x to user input. Unindentified behavior if input is not an integer
 out(x) - output register x's current value
 copy(x,y) - copy value of register x to register y
==BCT interpreter itself==
Program is inputed first, then data. They are encoded as follows: string is reversed and 1 is appended before the string.
 inc(5,1)
 inp(0)
 copy(0,1)
 inp(2)
 div(0,10,7)
 mul(0,10)
 dec(4,1,8)
 inc(3,1)
 out(2)
 dec(0,2,17)
 inc(0,2)
 div(0,10,21)
 div(2,10,14)
 dec(4,1,8)
 dec(2,1,63)
 div(2,10,63)
 dec(4,1,8)
 dec(2,2,63)
 inc(2,2)
 copy(1,0)
 dec(4,1,8)
 dec(0,2,60)
 inc(0,1)
 div(0,10,63)
 div(0,10,37)
 dec(2,2,35)
 inc(2,2)
 div(2,10,30)
 mul(5,10)
 dec(4,1,25)
 dec(2,1,63)
 div(2,10,63)
 mul(5,10)
 inc(5,1)
 dec(4,1,25)
 mul(2,10)
 dec(4,1,50)
 dec(0,1,63)
 dec(2,2,48)
 inc(2,2)
 div(2,10,43)
 mul(5,10)
 dec(4,1,25)
 dec(2,1,63)
 div(2,10,63)
 mul(5,10)
 inc(5,1)
 dec(4,1,38)
 mul(2,10)
 inc(2,1)
 dec(5,2,8)
 inc(5,2)
 div(5,10,55)
 mul(2,10)
 dec(4,1,50)
 dec(5,1,63)
 div(5,10,63)
 mul(2,10)
 inc(2,1)
 dec(4,1,50)
 dec(3,1,25)
 inc(3,1)
 dec(4,1,38)
==Examples==
===Cat Program===
An infinitely repeating numeric cat program shall be adduced:
 inp(0)
 out(0)
 dec(1,0,0)
===Truth-Machine===
The following program furnishes a truth-machine implementation:
 inp(0)
 dec(0,0,4)
 out(0)
 dec(0,1,2)
 out(0)
==Interpreter==
* Common Lisp implementation of the TLIJMMWTRAMCBICHWTPITCSIBCTII programming language.
Category:Languages Category:Turing complete Category:2023 Category:Implemented
TLOWScript

TLOWScript is a programming language designed to meet the following criteria:
* All programs in TLOWScript must start with This is TLOWScript, otherwise the implementation will output NotTLOWException followed by a line break, then exit.
* All non-alphanumeric/whitespace characters are ignored by the TLOWScript implementation.
* Contains an integer datatype of at least 64 bits.
* Ability to multiply, add, subtract and integer divide two values and store the output somewhere.
* Storage of at least 3 values.
* Ability to copy values from one variable/register to another variable/register without affecting anything else.
* Ability to print any integer storable by the integer datatype.
* Ability to print any alphanumeric character.
* Contains arbitrary conditionals or equivalent
* Contains some form of goto/loop/recursion
* Everything in the interpreter except for the main function definition, reading a command line argument, and reading the file must be accomplished in 10 lines or less.
These criteria were created by User:hanss314 for his ongoing TLOW (: Ten Lines Of Wisdom) competition, to be found on Discord here. Contestants were required to submit an interpreter for TLOWScript, which was then tested before a voting process started among all members of the Discord server the competition was/is run on. The implementation of TLOWScript submitted by the user Milo Jacquet won and was therefore crowned TLOWScript.
==External links==
* Arch Linux package containing all varieties of TLOWScript
* The winning implementation on GitLab
Category:Languages 
Category:Output only 
Category:Implemented
Category:2018
TLWNN

The Language With No Name is a programming language devised by User:Smjg. It has no name because names are not used in the language. In spite of this, "TLWNN" is frequently used as a placeholder for a name when talking about this language.
TLWNN is a dynamically typed stack-based language. It has two stacks: the main stack and the auxiliary stack. In the absence of names, all data and procedures are accessed through these stacks.
The only numeric type is the arbitrary-precision rational number. Characters are represented by their Unicode codepoints, and strings are represented by continued fractions.
TLWNN has a runtime library of arithmetical and other procedures. These procedures have, like TLWNN and everything else in it, no names.
== Instructions ==
Instruction	Description
! 	Pops the top object from the main stack and performs a type-dependent action: executes a procedure; outputs a number as a string according to the continued fraction representation; pops the elements of a packed stack onto the auxiliary stack.
< 	Moves the top object from the auxiliary stack to the main stack.
> 	Moves the top object from the main stack to the auxiliary stack.
* 	Duplicates the object at the top of the main stack.
\ 	Swaps the top objects of the main and auxiliary stacks.
& 	Packs the auxiliary stack into a single object on the main stack.
@ 	Discards the top object from the main stack.
[...] 	Creates a procedure consisting of the instructions within the square brackets, and pushes it to the main stack.
In addition, numeric literals (which may be integers or rationals in m/n notation) can be embedded in the code, which are simply pushed to the main stack.
Any letters in the code are comments.
== Code examples ==
The following is an example of how to write the "Hello, world!" program in TLWNN.
 72! 101! 108*!! 111! 44! 32! 119! 111! 114! 108! 100! 33! 10!
This more complicated program, which outputs a number of asterisks specified by the programmer, illustrates how to implement a loop.
 !<<<@@>
 Output 100 asterisks
 [42!
 \*\>1>! decrement the counter
 *\[]<<<*>>\1>! check for termination
 *! now do it again ]
 *!
In order to loop, a procedure needs a copy of itself to duplicate and then call again; the instances of *! just inside and just outside the closing square bracket take care of this. The complexity is due to the need to move various objects around the stacks in order to do the counting.
Note also how TLWNN's comment syntax accommodates interesting possibilities: the line Output 100 asterisks does nothing but pushes the number 100 to the stack, but at the same time it explains the purpose of the program.
== Computational class ==
TLWNN can simulate a Universal Register Machine, which is basically BF with a fixed number of unbounded memory cells. Since URM is known to be Turing complete , so is TLWNN.
== External link ==
* TLWNN - The Language With No Name
Category:Languages
Category:Stack-based
Category:Turing complete
Category:2006
Category:Implemented
TMCB

TMCB is a functional programming language created by revcompgeek on April 26, 2008. TMCB stands for Too Many Curly Brackets due to the fact that it uses them for almost everything.
==Statements==
Statements in TMCB are enclosed by {} and are either function calls or expressions.
==Functions==
All function calls in TMCB are of the form {name}{params} where name is the name of the function to be called, and params is a semi-colon separated list of parameters to the function. Function definitions take the form {{name}{params}{code}}
==Variables==
All variable names are specified in the form {name}, where name is an identifier starting with anything except for "'{} and digits 0-9. If curly brackets are added to the end of a name, the value inside is used as an array subscript for strings. Example:
The following are legal function/variable names
 {_cat}
 {Fibonacci(2)}
 {Hello, World!}
 {misleading array[2]}
 {array subscript{{3}}}
And the following are illegal.
 {95 blah}
 {hi {}}
 {= fjr 89}
Variable and functions may not have the same name.
==Expressions==
All values must be included inside {}. Variable assignments are of the form {name}={value or name}, where value is either a number or a string enclosed in double or single quotes. {} are also used for enclosing parts of an expression. Valid operators are +-*/%^!&|<> Example: {{45}+{10}}/{5} should equal 11
==Built-in functions==
 {} - a NOP function. Can be used to place comments in your code.
 {add} - adds all of its parameters together.
 {mul} - multiplies all of its parameters together
 {print} - prints its parameters to stdout
 {input num} - returns a number from stdin
 {input char} - returns a char from stdin
 {type} - returns 0 if type is function, 1 if type is number, 2 if type is string array
 {char} - casts its parameters to chars and returns a char array
 {int} - casts its parameter to an int
 {exists} - returns a 1 if its parameter exists (must be a name), and a 0 if not
 {while} - while its first parameter is true, evaluates the rest of its parameters in order
 {break} - breaks out of a while loop
 {if} - does its second parameter only if the first one is true
 {else} - this must be placed immediately after an if's closing bracket, executes its parameter only if the attached if did not
 {exit} - exits with its parameter as the return code (if it has one)
==Examples==
Here are just a few quick examples of how things are done.
===Hello World===
 {{print}{{"Hello, World!"}}}
===Cat program===
Copies input to output until ASCII 26 (EOF)
 {{c}={input char}{}}{{while}{{{c}!={26}};{print}{{c}};{{c}={input char}{}}}}
TMIDL

TMIDL (Turing Machine Instruction Description Language) is a language that describes Turing machine programs, with additional commands (extensions) for video output, registers and 2D operations.
== Core interpreter directives == 
Directive 	Description 	Example
%tmidl <version> 	Program header. This must be the first line in any TMIDL program. 	%tmidl 1.1
%tapesize <size> 	Defines the tape size. 	%tapesize 512
%states <state-list> 	Defines all state characters used by the program. 	%states ABCDE
%symbols <symbol-list> 	Defines all symbol characters used by the program. 	%symbols 01234
>%tape 	The value to initialize the tape to. The rest of the tape is blank.	%tape 001221020102343
%halt <halt-characters>	Defines the characters that halt the program. Defaults to #. 	%halt H!
%include <extension> 	Includes an extension. Read #Extensions for a list of extensions. 	%include registers
%pos <number> 	Defines the initial position of the head. Defaults to 0. 	%pos 5
== Syntax ==
Each instruction has two parts, the condition and action. Extensions may have their own syntax, as explained later.
 A57LC
 ||||\------------> next state
 |||\-------------> direction to move head: Left or Right
 ||\--------------> symbol to write (- for none, / for blank)
 |\---------------> read symbol condition (- any, / blank)
 \----------------> state condition
Comments are made using ~. 
== Extensions ==
The following extensions can be used with the %include directive. 
=== Registers ===
=== TMIDL-2D ===
=== Video ===
TM (I am islptng)

TM is an esolang created by islptng.
All programs begin with
 #™=n
Which initialises the interpreter with the given version.
There is also an option:
 #use-escape
Escape 	Character
(trademark) 	™
(copyright) 	©
(registered) 	®
(tai-chi) 	☯
(bismillah-ar-rahman-ar-raheem)	﷽
(chinese-she) 	蛇
(chinese-an) 	唵
(circled-nine) 	⑨
The lines begins with '#' is removed before it is interpreted as a ™ program.
==Examples==
I don't want to write them anymore.