nyuuzyou/wikis huggingface dataset:
Triplet

Triplet is (yet another) joke fork of Brainfuck, with the instructions changed into binary triplets.
==Commands==
Brainfuck	Triplet 	Description
> 	001 	Move the pointer to the right
< 	100 	Move the pointer to the left
111 	Increment the memory cell under the pointer	
000 	Decrement the memory cell under the pointer	
. 	010 	Output the character signified by the cell at the pointer
, 	101 	Input a character and store it in the cell at the pointer
[ 	110 	Jump past the matching ] if the cell under the pointer is 0
] 	011 	Jump back to the matching [
==Hello, world! program==
Note that in most interpreters, the spaces are not necessary.
 001 111 111 111 111 111 111 111 111 111 110 100 111 111 111 111 111 111 111 111 001 000 011 100
 010 001 111 111 111 111 111 111 111 110 100 111 111 111 111 001 000 011 100 111 010 111 111 111
 111 111 111 111 010 010 111 111 111 010 001 001 001 111 111 111 111 111 111 111 111 110 100 111
 111 111 111 001 000 011 100 010 001 001 001 111 111 111 111 111 111 111 111 111 111 110 100 111
 111 111 111 111 111 111 111 111 001 000 011 100 000 000 000 010 100 100 100 100 010 111 111 111
 010 000 000 000 000 000 000 010 000 000 000 000 000 000 000 000 010 001 001 111 010
==Triplet-to-brainfuck converter in Python==
 import re
 def tripletToBrainfuck(code):
 cmds = {"001": ">", "100": "<", "111": "+", "000": "-", "010": ".", "101": ",", "110": "[", "011": "]"}
 return [cmds[s] for s in re.findall("...", re.sub("[^01]", "", code))]
==Note==
This page was forked from Ook!.
Category:Brainfuck equivalents
Category:Languages
Category:Cell-based
Category:Joke languages
Category:Turing complete
Category:Implemented
Category:Low-level
Category:2001
TripletNOR

This is an esolang created by User:I am islptng.
Inspired by the game Turing Complete.
It let us make computers only with NAND at first.
According to De Morgan's laws, we can start with NOR, too.
=Rules=
It is based on a binary memory.
Use in for input, out for output, and pc for program counter. .num and .char comes after in or out.
The memory provides 0x,1x,2x,etc. use a hexadecimal number for the address.
A hexadecimal number without *x will be a constant value.
0x**+# means a #-length binary list that starts with the address **.
0x0x**+# means the bit that the 0x**+# shows.
[val]plus means the value of [val] +1.
The only command is:
 {[val1],[val2],[dest]}
It does:
For every bits of val1 and val2,
do NOR and save it into dest.
dest mustn't be a constant value.
When the length of val1 and val2 is different,
the shorter one starts to loop: for example
val1 = 110010101111
val2 = 10110101
 110010101111
 NOR 101101011011
 ^^^^ LOOP
 000000000000
I'm not sure if this is a Turing-Tarpit.
=Programs=
==Hello World==
 {48656c6c6f20576f726c6421,0,0x00+96}
 {0x00+96,0,out.char}
I haven't tested it yet because there is no interpreter. I'm trying to make it.
Category:Languages
Triski

Triski is a language inspired by SKI calculus, along with the I/O system from Hot.
== Combinators ==
 s x y z = x z (y z) # only in first row
 k x y = x # only in second row
 i x = x # only in third row
 d x = x
 p x y = x | y # if next input bit = 0, remove y, otherwise, remove x
 z x = x # add '0' to output string
 o x = x # add '1' to output string
 v x = # set x as this row's value
 a x = # set x = the value of the (the number of variables/combinators in this row mod 3 + 1)-th row
 # if the row isn't assigned a value, x = x
Once a row is empty or doesn't have enough variables, the initial copy is added to that row. Example:
 s (s s) s s s
 d d d
 o z o o o z
 ->
 s s s (s s) s
 d d
 z o o o z
 ->
 s (s s) (s (s s)) s
 d d d d
 o o o z
 ->
 s s s (s (s s) s)
 d d d
 o o z
 etc.
If multiple z and o are executed at the same time on different lines, the execution order is 1st line -> 2nd line -> 3rd line.
The output string is cut into crumbs (groups of 2 bits). If a crumb starts with 1, the final bit is outputted. If it starts with a 0, outputting is halted.
== Example programs ==
Truth-machine
 p (v z) (v o) a i v (s i i) s i i (s i i)
 d d d d d d d d o z
 v i a l o l l o d d a m m m
Hello, world!
 o
 z o z z o z z z z o o z z o z o z o o z o o z z z o o z o o z z z o o z o o o o z z o z o o z z z z o z z z z z z o o o z o o o z o o z o o o o z o o o z z o z z o o z o o z z z o o z z o z z z z o z z z z o 
 d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d z
== SKI Translation ==
 d a k a i ...
 v k
 v i
... is any SKI formula padded with ds. The formula has to be a multiple of 3 long, so S(SKI)(SKS) would become d d s (s k i) (s k s).
Trite

Trite is a simple, single data string esoteric language. Drawing inspiration from the simple language of BCT, it executes commands altering its own execution string. It has no means of i/o other then its initial state and its final state. The only valid commands are hexadecimal digits. When execution flow is reversed, so are the 'next' and 'previous' commands. Trite was created by User:Hiant, Fading Entity on Wednesday, November 17, 2010.
==Language Overview==
 There are sixteen commands:
 0/0000---Append the next command to the end of the program.
 1/0001---Invert the second bit of the next command.
 2/0010---Invert the third bit of the next command.
 3/0011---Append previous command to the end of the program.
 4/0100---Invert the last bit of the previous command.
 5/0101---Reverse execution flow.
 6/0110---Delete the previous command.
 7/0111---End Program
 Commands starting of the form 1--- can not be altered.
 Commands 8..F are the 1--- forms of 0..7
==Example Programs==
===Hello World===
Outputs 'Hello World!\366' in hexadecimal.
 (SYST)-->548656c6c6f20576f726c6421F6
 (SYST)-->DNE0
 (0101)-->5|4|8|6|5|6|C|6|C|6|F|2|0|5|7|6|F|7|2|6|C|6|4|2|1|F|6
 (0110)--<5|4|8|6|5|6|C|6|C|6|F|2|0|5|7|6|F|7|2|6|C|6|4|2|1|F|6
 (1111)--<4|8|6|5|6|C|6|C|6|F|2|0|5|7|6|F|7|2|6|C|6|4|2|1|F|6
 (SYST)-->END1
 (SYST)-->4|8|6|5|6|C|6|C|6|F|2|0|5|7|6|F|7|2|6|C|6|4|2|1|F|6
===Example Execution===
 (SYST)-->171717171752
 (SYST)-->DNE0
 (0001)-->1|7|1|7|1|7|1|7|1|7|5|2
 (0011)-->1|3|1|7|1|7|1|7|1|7|5|2
 (0001)-->1|3|1|7|1|7|1|7|1|7|5|2|1
 (0011)-->1|3|1|3|1|7|1|7|1|7|5|2|1
 (0001)-->1|3|1|3|1|7|1|7|1|7|5|2|1|1
 (0011)-->1|3|1|3|1|3|1|7|1|7|5|2|1|1
 (0001)-->1|3|1|3|1|3|1|7|1|7|5|2|1|1|1
 (0011)-->1|3|1|3|1|3|1|3|1|7|5|2|1|1|1
 (0001)-->1|3|1|3|1|3|1|3|1|7|5|2|1|1|1|1
 (0011)-->1|3|1|3|1|3|1|3|1|3|5|2|1|1|1|1
 (0101)-->1|3|1|3|1|3|1|3|1|3|5|2|1|1|1|1|1
 (0011)--<1|3|1|3|1|3|1|3|1|3|5|2|1|1|1|1|1
 (0001)--<1|3|1|3|1|3|1|3|1|3|5|2|1|1|1|1|1|5
 (0111)--<1|3|1|3|1|3|1|7|1|3|5|2|1|1|1|1|1|5
 (SYST)-->END1
 (SYST)-->1|3|1|3|1|3|1|7|1|3|5|2|1|1|1|1|1|5
It is unknown if Trite is Turing Complete, or if a single useful program is possible.
Category:2010
Category:Languages
Category:Unknown computational class
Category:Usability unknown
Category:Unimplemented
Category:Self-modifying
Trithemius

Trithemius is an in-development esoteric programming language by User:Wound theology, who under a different account, designed the joke language Brainfuck² in 2017. Trithemius aims to simulate the look and feel of medieval and early modern grimoires, or books of magic. It is named for Johannes Trithemius, Benedictine polymath and occultist, who is considered one of the forefathers of modern cryptography.
== Introduction ==
== Syntax ==
Comments are opened with [In margin: and closed with a single left bracket ].
Category:Works-in-progress
Trivial trivial brainfuck substitution

Trivial trivial brainfuck substitution is the trivial Trivial brainfuck substitution. Using the notation from the trivial brainfuck substitution page, the trivial trivial brainfuck substitution is given by TrivialBrainfuckSubstitution(">", "<", "+", "-", ".", ",", "[", "]"), making it trivially equivalent to brainfuck.
== Language definition ==
Since Trivial trivial brainfuck substitution is trivially equivalent to brainfuck, this section can be trivially substituted for brainfuck's entire wiki page.
Category:Joke languagesCategory:Brainfuck equivalentsCategory:LanguagesCategory:2024Category:Turing complete
Trml

Trml is a term-rewriting matrioshka language discovered by User:Orby in May of 2020.
==Purpose==
Trml is used to describe the syntax and semantics of term-rewriting languages. It provides a formal language in which a term-rewriting language can be described. Many esoteric programming languages may be described as term-rewriting languages, such as Underload, Unlambda, and Clementine.
==Description==
A Trml description is divided into statements. There are two types of statements. Term statements describe the structure of a term. Rule statements describe rewrite rules. Rule statements contain a colon to delineate between the pattern to be matched and the pattern to which it is rewritten. Term statements do not contain colons. Each statement is terminated by a semicolon. Term meta-variables are referenced by one or more characters contained within parentheses. All white space in a Trml description is ignored. Rewrite rules are applied from left to right and from first appearing to last appearing, deterministically.
===Term statements===
The following term statements declare the characters k and s as terms.
 k;
 s;
The following term statement uses the meta-variables (a) and (b) to state for all terms (a) and (b), `(a)(b) is also term.
 `(a)(b);
Notice the character ` has no special meaning in Trml. We could use any character here, but we choose ` because it is commonly used for application. This means that the following strings are terms
 `sk
 ``skk
 `s`kk
among many others. This is distinct from the statement
 `(a)(a)
which would require the term (a) to appear twice identically.
===Rule statements===
The rule statement
 ``k(a)(b):(a);
says to rewrite ``k followed by terms (a) and (b) to the term (a). For example, the expression ``ksk would be rewritten to s. This is how the K combinator works in SK calculus. We could express the S combinator of SK calculus as
 ```s(a)(b)(c):``(a)(c)`(b)(c);
In that case, the expression ```sskk would be rewritten to ``sk`kk. Notice we can distinguish between term statements and rule statements by the presence of a colon.
===Complete example===
The SK calculus could be described in Trml as
 s;k;`(a)(b);``k(a)(b):(a);```s(a)(b)(c):``(a)(c)`(b)(c);
===Matrioshka language===
Trml is a matrioshka language. That is, it is possible to program in the object language described by a Trml definition. The use of the $ character denotes the end of the meta-description and the beginning of the object language program. We could express the SK calculus program ```skkk as
 s;k;`(a)(b);``k(a)(b):(a);```s(a)(b)(c):``(a)(c)`(b)(c);$```skkk
and the interpreter would output
 k
==See also==
* Thue is a matrioshka language that uses a non-deterministic string-rewriting paradigm.
Category:Meta-languages
Category:2020
Category:Turing complete
Category:Unimplemented
Category:Low-level
Category:Languages
Troll Online

Troll Online is a programming language builded in c#. It can connect to internet. Documentation, interpreter and the source are in this github repository: https://github.com/LegionMammal978/Troll-Online
==Examples==
Hello world
hello world!!¨ç]a
↓ùp👌a
Connect to google
l},ºa<k¿https://www.google.com¿xd¿get
↓ùp👌a
Read files
♫↕!C:\file.txtcsisa
↓ùp👌a
Category:Languages
Category:2019
Troupe

Troupe is an esoteric programming language designed by Chris Pressey on June 25, 2012, in Winnipeg, Manitoba, Canada.
The name of the language varies by region; it is Troupe in the UK, Canada, and Australia, and Trope in the USA. (By what name it is known in other regions of the world is not specified.)
It is based on the behaviour (in the USA: behavior) of a troupe of hedgehogs as they traverse a territory in which are placed faery rings and hills.
==Computational Class==
The specification argues that Troupe is Turing-complete by showing that the various parts of a Troupe system map quite directly to the parts of a Turing machine.
==External resources==
* Troupe repository on git.catseye.tc
Category:Languages
Category:Turing complete
Category:Unimplemented
Category:2012
Trow

= Trow =
Trow is an output-only esoteric language designed to generate randomized sentences using different kinds of sentence structures and lists. Multiple lists with different items (strings) can be defined. You can plug these lists in your sentences, which selects a random item from the list and generates a randomized output.
== Examples ==
=== Simple Hello World Program ===
 - Hello world!
Possible Outputs: 
 Hello world!
=== Randomized Hello World Program ===
 [words]
 "world"
 "programmers"
 "guys"
 "friends"
 - Hello <words>!
Possible Outputs:
 Hello world!
 Hello programmers!
 Hello guys!
 Hello friends!
=== Multiple Lists ===
 [days]
 "saturday"
 "sunday"
 [seasons]
 "winter"
 "summer"
 - Today is <days>, a beautiful <seasons> morning!
Possible Outputs:
 Today is saturday, a beautiful summer morning!
 Today is sunday, a beautiful winter morning!
 Today is saturday, a beautiful winter morning!
 Today is sunday, a beautiful summer morning!
=== Multiple Outputs === 
 [food]
 "pizza"
 "burger"
 - I love eating <food>s!
 - <food>s are bad for our health!
Example Output:
 I love eating burgers!
 pizzas are bad for our health!
= Syntax =
=== Comments ===
Comments are ignored when the program is ran. Comments can be defined using #. Similar to python.
Example:
 # this piece of code will be ignored!
=== Lists ===
Lists can be defined using square brackets and their items can be only be strings enclosed in double quotes. These lists can be indexed in output statements.
Example:
 [subjects]
 "mathematics"
 "physics"
 "chemistry"
 "art"
=== Print ===
To throw outputs in the console, we use a hyphen (-). Anything after the hyphen is printed in the console. Random items from specific lists can be included in these outputs using <listname>.
Example:
 [emotions]
 "happy"
 "sad"
 "angry"
 - Hey, this statement will be printed in the console! This statement does not include random items from lists!
 - I am so <emotions>. # In the output, <emotions> is replaced with a random item from the list.
==Interpreter==
* Common Lisp implementation of the Trow programming language.
Category:Languages
Category:Output only
Category:2021
Category:Total
Category:Implemented
Trueclone

trueclone is an esoteric language designed to make Spaghetti code.
== trueclone ==
* uses goto statements.
* doesn't have comments.
* uses a tape, in which every cell is signed and is 16-bit long.
* doesn't support spaces.
* the only symbols trueclone supports are: 0, 1
== Syntax ==
A line will look something like this:
 <instruction><parameter>
Example:
 sub00000001
The parameter is optional and depends on the instruction. The value of a parameter should always be a binary number.
Also, you can put multiple instructions in a line, like this:
 leftleftleftleftadd0000000000000001sub0000000000000001
Oh and instructions should always be in upper-case
 LEFTLEFTLEFTLEFTADD0000000000000001SUB0000000000000001
== Instructions ==
Instruction	Parameter use	Description
ADD 	yes 	Adds to the current cell the value of the parameter
SUB 	yes 	Substracts from the current cell the value of the parameter
SET 	yes 	Sets the value of the current cell to the value of the parameter
LEFT 	no 	Moves the pointer to the right cell
RIGHT 	no 	Moves the pointer to the left cell
IN 	no 	Gets an input character and stores in the current cell its ASCII code
OUT 	no 	Outputs the ASCII character associated with the current cell value
JUMP 	yes 	Jumps to the character specified by the parameter
JINZ 	yes 	Jumps to the character specified by the parameter if the current cell value is not zero
JITS 	yes 	Jumps to the character specified by the parameter if the current cell value is zero
JINN 	yes 	Jumps to the character specified by the parameter if the current cell value is below zero
JITN 	yes 	Jumps to the character specified by the parameter if the current cell value is above zero
== Turing complete proof ==
Turing complete means that this program can calculate everything that a Turing machine can calculate.
The proof is that the following characters are the equivalent of the brainfuck instructions (which are Turing complete).
 ADD0000000000000001 equivalent of '+'
 SUB0000000000000001 equivalent of '-'
 JNZ can be used as '[ ]'
 LEFT equivalent of '>'
 RIGHT equivalent of '<'
== Examples ==
=== Cat program ===
The following implements an infinitely repeating cat program:
 INOUTJINZ0
=== Truth-machine ===
A truth-machine is implemented in this program:
 INOUTSUB110000JITS0000000001000010ADD110000OUTJUMP0000000000101011
==Interpreter==
* Common Lisp implementation of the trueclone programming language.
Category:Implemented Category:2020 Category:Languages Category:Cell-based Category:Turing complete Category:Turing tarpits Category:Low-level
Truer machine

Truer machine is an esolang created by Infinitehexagon specifically designed to implement a truth machine.
Category:LanguagesCategory:2024
== Instructions ==
 Caption text
Command	Description
i 	Input string value
o 	Output "true" indefinitely if the input / secret input is 1. Else output the string value inputted by the user.
0 	Skip the next command.
' 	Halt program.
1 	increment the secret input by 1
== Programs ==
===Cat program===
 io'
===Truth machine===
 io
===Infinite loop===
 1o
===NOT gate(?)===
 i111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
 1111111111111111111111111111111111111111111111111111111o'1
===Hello world program===
 
 111111111111111111111111111111111111111111111111111111111111111111111111o11111111111111111111111111111o1111111o111111111111111111 
 
 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 
 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111o111o11111111111111 
 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 111111111111111111111111111111111o
Truffle

This language is dedicated to User:Truttle1.
Truffle is a language by User:PixelatedStarfish that does not use goto statements or any statement that descends from a goto. Any operation that moves a pointer is prohibited, which makes branching hard and parsing harder. It may not be Turing complete, but that’s part of the fun.
Code is written entirely on one line. That is the only way to write code. The program state is defined as a single number of arbitrary length. This number is mutated to another number according to operations defined in the program state.
==Mutations==
A number is mutated such that a number n is first divided by 1.618 (an approximation of the golden ratio) then n is set to itself mod u where u is the floor of the maximum value in the range of a 64 bit floating point number. This keeps mutations varied and in a reasonable range.
==The Stack==
Surprise! To determine which stack operation to do next let m be the value of the last mutation and let n be the cardinality of the set of all stack operations, or the number of operations to use. The next stack operation is equal to m mod n.
A value on the stack is in the range of 0 to 255. 255 plus 1 is 0 and 0 minus 1 is 255. Bytes are what you get. The stack starts empty.
===Operation Codes===
 0 - Push 0 onto the stack.
 1 - Pop and output as a character.
 2 - Increment top.
 3 - Decrement top.
 4 - Double top and push.
 5 - Half top and push floor.
 6 - If top is 0 do last op, otherwise do op 0. 
 7 - Empty stack.
 8 - Push top value (duplicate).
 9 - Swap top and second from top.
 10 - Push random value onto the stack.
==Errors==
There are a small number of errors in this language:
 Error
 The generic error case for all possible errors.
 Stack Overflow 
 The stack is too large for memory.
 Empty Pop
 Popping from an empty stack.
 Ranging Error
 This mutation is outside the range of 64 bits.
An error message looks like this:
 Stack Overflow 
 Attempted op 8
 Top of Stack: 255
 Mutation: [Current mutation]
Category:Languages 
Category:2022
Category:Usability unknown
Category:Stack-based
TrumpScript

From the Github repository: "TrumpScript is a language based on the illustrious Donald Trump. As the undeniably best presidential candidate in the 2016 language, we found that the current field of programming languages does not include any that Trump's glorious golden combover would approve of.
TrumpScript is our solution to this. It's the programming language Trump would approve of. Just like he is making America great again, we hope our efforts will make programming great again."
==External resources==
Github repository
Category:2016 Category:Joke languages Category:Implemented Category:Pseudonatural
Category: Languages
Truth

(This is the first draft, sorry for the bad style)
Truth is an esoteric programming language created by Sam Savitz in 2006. Truth is a new paradigm in programming languages. Each cycle causes each cell (To be defined later) to execute it's value. Each cell can hold one bit A cell must be defined, a cell defenition prototype is below.
[<[Cell ]Number>:](optional, but useful) [(initial|i): (0|1)] [(0|1)(0|1)(0|1)(0|1)] [reference1] [reference2]
eg:
6: initial: 0 1110 -2 -1
All cells execute simultaneously when they are called. The cell above is the fifth cell in a program. before any executions have occured, it's value is zero. On each execution this cell takes the value of the cell number 4 and 5 (6-2, 6-1) and takes the nand of them (this is because of the 1110, this means that if both references are 0 then make you value 1; if the first it 0, and the second 1, then make your value 1, if the first is 1 and the second 0 then make the value 1; if they are both 1, then make the vaue 0. above, I explained what happens in each case in the order they are represented by the code.
Any part of the definition can be ommited or replaced with a question mark, but then that which it would would determine will have undefined behavoir.
==IO==
One can enable basic IO by making special cells. The current system is as follows:
cell 0: if this cell is 1, finish this execution and then halt.
cell 1: if this cell is 1, then output the value in cell 2.
cell 3: if this cell is 1, then take one bit of input and write it to cell 4.
==Example program==
This program takes one bit of input and outputs its opposite:
0: i: 0 0011 +5
1: i: 0 0011 +4
2: 1100 +2
3: i: 1 0000
4:
5: i: 1
This program will only last for two execution cycles
these are the values it goes through:
cell | 0 | 1 | 2 | 3 | 4 | 5 
init | 0 | 0 | ? | 1 | X | 1 (? means undefined and unimportant, X = input) (the 1 in cell 3 tells it to input X into 4)
next | 1 | 1 |~X | 0 | ? | ? (the 1 in cells 0 and 1 say to halt, but first output the ~X (opposite of X) in cell 2)
One may make an anti-wimpmode by self-restricting themselves to only two specially picked Turing complete operators.
It is believed that Truth is turing complete
There is no interpreter yet.
Category:Languages
Category:Unimplemented
Category:2006
Truth Machine (language)

Truth Machine is an esolang created by User:ResU in 2021.
==Commands==
Cmd 	Description
input(a) 	Gets user input.
if a=0: 	Self-explanatory.
print(0) 	Self-explanatory.
stop 	Self-explanatory.
if a=1: 	Self-explanatory.
print(1) infinity	Self-explanatory.
==Examples==
===Truth-machine===
input(a)
if a=0:
print(0)
stop
if a=1:
print(1) infinity
==Interpreter in Python==
def stop():
 break
def print_infinity_ones():
 while True:
 print(1)
Category:Languages Category:Unusable for programming Category:2021