nyuuzyou/wikis huggingface dataset:
Thief, Police and the Building extended

Thief, Police and the Building extended is an esolang invented by User:None1, it is an extension to Thief, Police and the Building.
==Extra commands==
 He time-travels backwards i scenes
Make the instruction pointer move backwards i instructions.
 He time-travels forwards i scenes
Make the instruction pointer move forwards i instructions.
 He time-travels backwards i scenes if he steals c
Make the instruction pointer move backwards i instructions if there is a character c in the thief's bag.
 He time-travels forwards i scenes if he steals c
Make the instruction pointer move forwards i instructions if there is a character c in the thief's bag.
 The police have come, but he escapes
Prints everything in the thief's bag in the order he steals, but doesn't clear the thief's bag or terminate the program.
 The thief goes to an unknown place and steals
Read a character from user input and put it into the thief's bag, this command does not change the thief's position.
==Examples==
===Truth Machine===
 A thief on G/F
 Set SoE -> 3F/s
 Set SoS -> 1F/s
 top: G-th floor
 btm: G-th floor
 G/F 0
 The thief goes to an unknown place and steals
 The police have come, but he escapes
 He time-travels backwards 1 scenes if he steals 1
 The police have come
==See also==
* Thief, Police and the Building
Category:Languages
Category:2024
Category:Unimplemented
Category:Pseudonatural
Thing

thing is a esolang based on the Collatz function. the program has this format:
 number , list of numbers , string
this is how it works:
* the first number is n
* the string is w
* then for each number on the list. lets call one of the numbers k:
:* apply the collatz function f to n, k times(this is u)
:* then check. make a string d where each two digits in u is converted to a ascii char, and see if d is in w
* if it is it will set w to d
* set n to u
* if no number can be found that satisfies the program halts
Category:Languages
Third Party Contractor Accused Of A Robbery

=TPCAOAR...=
...is a 2D esoteric language with only two commands ( and &)
----
 : Just increments the TOS
----
&, though is a whole different story, and actually uses the value of the TOS (modulo 8)
Value	Action
0 	changes itself to the second-to-top thing on the stack
1 	rotates direction counter-clockwise (ie. if facing North, goes West; facing West, goes South; etc.)
2 	outputs char((TOS - 2) / 8)
3 	multiplies ((TOS - 3) / 8)
4 	pops this value; turns clockwise if the new TOS is nonzero, then pops that
6 	clears the stack
7 	appends 0 to the stack after turning this into a zero
The program only terminates if the stack contains "911"
-Super Mario Man (talk)
Category:Languages Category:Stack-based Category:Unimplemented Category:Output only Category:Two-dimensional languages Category:Turning tarpits
This=That 2.0

==Language Overview==
This=That 2.0 is an extension of This=That invented by User:A that adds some other special values including arrays of numbers that a variable takes. For example:
 #x=1->4
sets #x to the numbers 1, 2, 3, and 4. While:
 #x=1->
sets #x to all positive integers. Also:
 #x=1,5,-84
sets #x to the numbers 1, 5, and -84. These can be used in loops like this:
 #x=1->4
 if loop a=#x~~3
 #x:~~3=0
 if loop a=end
This sets the array of numbers (x) to 1, 2, 3, 4. Because at least one value of x suffices to the condition, the if loop runs. #x:~~3=0 sets all values equal to 3 in #x to 0, so the new value of #x is 1, 2, 0, 4. The # symbol must precede all array names. The delete value can be used to remove values from an array. In the following:
 #x=1->4
 if loop a=#x~~3
 #x:~~3=delete
 if loop a=end
Instead of 3 being changed to 0, it is deleted, leaving #x set to 1, 2, 4.
Comments can be used and are enclosed in square brackets [].
==Programs==
===Infinite prime number generator===
 #a=2-> [sets array a to all integers greater than or equal to 2.]
 b=2 [sets b to 2]
 while loop x=b>1 [starts a while loop called x that runs as long as b is greater than 1 (this 
 runs infinitely because b will never decrease its value below 2)]
 #c=#a times b [sets array c to the value of array a times the value of b]
 #a:~~#c=delete [deletes all values in array a that are also in array c]
 b=b plus 1 [increases b by 1]
 #a:<b=print [prints the values of array a less than the value of b]
 #a:<b=delete [deletes the values of array a less than the value of b]
 while loop x=end [ends while loop x]
==Computational Class==
It is Turing-complete, because This=That is Turing-complete. Additionally, an array can be used for the 3 variables, and even more.
==See also==
*This=That
*This=That 3.0
Category:Languages 
Category:2009
Category:Unimplemented
Category:Turing complete
This=That 3.0

This=That 3.0 extends This=That 2.0 and This=That. It adds some special features, such as recursion and functions. For example:
 function MyFunction=param,param2
starts a function called Myfunction, with params "param" and "param2".
Params can be deleted(as nothing).
 end function Myfunction
ends a function called Myfunction.
To call:
 start function Myfunction
And also:
 a=1->100
 for loop x=a
starts a for loop with the array range of a. a becomes the current number every time executed.
 end for loop x
ends a for loop called x.
==Programs==
99 bottles of beer(for loop)
Actually, that is unformatted...
 function NN=
 a=print
 b=print
 a=print
 c=print
 d=print
 a minus 1=print
 b=print
 end function NN
 a=99->0
 b= bottles of beer on the wall.
 c= bottles of beer.
 d=Take one down. pass it around,
 for loop f=a
 start function NN
 end for loop f
==See also==
*This=That
*This=That 2.0
Category:Languages
Category:2018
Category:Unimplemented
Category:Turing complete
ThisIsNotARealLanguage

User:Maxsteele2
It's NOT like this:
 NOT A CODE
 DON'T PRINT "Hello, World!"
It's not like that, for this is not a real language. So fuck off.
==Implementation==
A — theoretical — implementation in the Common Lisp programming language shall be supplied. In the case of a successful interpretation, one of several messages will selected in an aleatory manner and printed to the standard output. A failure in the code evaluation will cause an error to be signaled.
By adding further entries to the +SUCCESS-MESSAGES+ sequence the behavior may be extended.
 (declaim (type (vector string *) +SUCCESS-MESSAGES+))
 
 (defparameter +SUCCESS-MESSAGES+
 (coerce
 '("Hello, World!"
 "..."
 "Really?"
 "ThisIsNotARealLanguage"
 "egaugnaLlaeRAtoNsIsihT"
 "René Magritte disagrees!"
 "But this may be a real pipe."
 "It is Not Even DOOM Music.")
 '(vector string *))
 "A vector of the possible messages to randomly print in the case of a
 successful ThisIsNotARealLanguage program's interpretation.")
 
 (defun interpret-ThisIsNotARealLanguage (code)
 "Interprets the piece of ThisIsNotARealLanguage code and returns no
 value."
 (declare (type string code))
 (if (string= code "NOT A CODE
 DON'T PRINT \"Hello, World!\"")
 (format T "~&~a"
 (aref +SUCCESS-MESSAGES+ (random (length +SUCCESS-MESSAGES+))))
 (error "The code ~s was even less valid than expected." code))
 (values))
 
 (setf *random-state* (make-random-state T))
An exemplary invocation, expected to succeed, constitutes the following:
 (interpret-ThisIsNotARealLanguage "NOT A CODE
 DON'T PRINT \"Hello, World!\"")
Category:Languages
Category:Joke languages
Category:Implemented
Category:Zero-dimensional
This esolang is not a push-down automata

This esolang is not a push-down automata (or TEISNPDA or simple TEI) is, unlike its name, a push-down automata. It is invented by User:None1.
==Memory model==
It uses only a stack that can contain nonnegative numbers of any size.
==Commands==
 Command table
Command	Meaning
0~9 	Push corresponding number onto the stack
+ 	Pop a and b, push b+a
- 	Pop a and b, push b-a
* 	Pop a and b, push b*a
, 	Reads an integer and push it onto stack
. 	Pop a and output as decimal, followed by a space
? 	Reads a character and push its ASCII value onto the stack
! 	Pop a and output as ASCII
Other characters (including whitespaces and line feeds) push their ASCII values onto the stack.
==Examples==
===Hello World===
 H!e!l!l!o! !W!o!r!l!d!184*+!
===Nope. interpreter===
 N!o!p!e!159*+!
===One time cat===
 ?!
===A+B Problem===
 ,,+.
======
 4.
===Polyglot===
 4.@
==Usefulness==
The language is pretty useless if you ask me, but you can feed a suffix arithmetic expression with only addition, subtraction and multiplication and one-digit numbers to this language to compute it.
==External Resources==
* Interpreters for This esolang is not a push-down automata in C#, Java and Python.
Category:Languages
Category:Total
Category:2023
Category:Implemented
This esoteric programming language has one of the longest titles, and yet it only has one command, which is such a shame, but there is no way to undo it so we may as well stick with it

This esoteric programming language has one of the longest titles, and yet it only has one command, which is such a shame, but there is no way to undo it so we may as well stick with it is a joke esoteric programming language. The only command is "sus", which loads up Among Us on your device.
Category:LanguagesCategory:Joke languages Category:Sus
Category:OISC
This machine is a server. DO NOT POWER IT DOWN!!

This machine is a server. DO NOT POWER IT DOWN!! is a esolang create by User:Yayimhere where there are 2 things: servers, and computers
== syntax ==
 syntax
command 	description
a is a server. DO NOT POWER IT DOWN!! 	create a server a
a is a computer. the code is 1289 	create computer a
computer a is a part of the server b. DO NOT DISCONNECT!!!!!!	connect computer a to server b
a is connected to b's hotspot 	connects computer a to computer b
disconnect a from b 	disconnect a from b
connect a to the internet 	connect a to the internet connecting anything that its connected to, to the internet
a uses piracy software from frostwire lol 	give computer a a virus(this virus will be called: pirate bay version 2.a). this virus will infect anything its connected to. a server with a virus can't provide nor connect to internet
a has antivirus that acts on b, c... 	computer a will not spread the virus b, c ect. EVERYTHING!!!!! will do it for every virus
do n lines until a is true 	do the n lines below until condition a is true
do n lines if a is true 	do the n lines below if condition a is true
mildly reset computer 	delete all viruses and anti virus software from the
goto line n 	self explanatory
a is incognito 	even when connected viruses and internet and stuff won't spread to a
YOU TURNED THE COMPUTER OFF YOU BITCH!!!!111!1!!!1!! 	halt
the conditions:
* number of infected n in a is the number of things that are infected is more than n connected to server a(or a computer)
* number of connected n in a is the number of things that are connected to the internet is more than n connected to server a
* a nor b do expression a nor expression b
* NOT[a] not of expression a
Category:Languages Category:Pseudonatural Category:Object-oriented paradigm Category:Unknown computational class Category:No IO Category:Low-level Category:Thematic
ThonkLang

ThonkLang is an esoteric programming language that uses emojis for control flow and features a unique "1 is true, everything else is false" boolean system. It combines functional programming concepts with emoji-based syntax to create a playful yet capable programming environment.
==Computational model==
ThonkLang is based on a functional programming model with lambda expressions, control flow statements, and loops. It features a unique boolean system where 1 is considered true and any other value is considered false.
==Etymology==
The language's name combines "Thonk" (internet slang for the thinking face emoji 🤔) with "Lang" (short for language). This references the language's primary control flow operator 🤔, which serves as the if-statement keyword.
==Language description==
ThonkLang programs consist of expressions that can include:
* Lambda function definitions
* If-else statements using 🤔 (if) and 😅 (else)
* While and for loops
* Basic arithmetic operations (+, -, *, /)
* Variable assignments
* Function calls
===Control Flow===
The language uses emoji-based control flow:
* 🤔 serves as the "if" keyword
* 😅 serves as the "else" keyword
* Any expression that evaluates to 1 is considered true
* Any other value is considered false
===Functions===
Functions are defined using the lambda syntax:
 lambda name,param1,param2: { body }
==Sample programs==
===Truth Machine===
The following implements a truth machine in ThonkLang:
 truth = lambda n: {
 🤔 n {
 # If input is 1, enter infinite loop
 while 1 {
 print(1);
 };
 } 😅 {
 # If input is 0, print once and terminate
 print(0);
 };
 };
===Prime Number Checker===
This program checks if a number is prime:
 is_divisible = lambda n,d: 🤔 n - ((n/d) * d) + 1 1 😅 0;
 
 is_prime = lambda n: {
 result = 1;
 🤔 n 0 😅 {
 for i in range(n-2) {
 d = i + 2;
 🤔 is_divisible(n,d) {
 result = 0;
 } 😅 {
 result = result;
 };
 };
 };
 result
 };
===Prime Number Generator===
This program finds all prime numbers up to a given value:
 find_primes = lambda n: {
 for i in range(n-1) {
 num = i + 2;
 🤔 is_prime(num) {
 print(num);
 } 😅 0;
 };
 };
==Computational class==
ThonkLang is Turing-complete, supporting:
* Conditional branching (through 🤔/😅)
* Loops (while and for)
* Variable assignment
* Function definitions and calls
* Basic arithmetic operations
==Implementation==
ThonkLang is implemented in Python using the Lark parser generator. The implementation consists of:
* A lexer/parser for the language grammar
* An interpreter that executes the parsed syntax tree
* Support for nested scopes and variable binding
* Built-in functions for basic I/O operations
==External resources==
* Thonklang implementation
Category:Languages
Category:Implemented
Category:2024
Category:Turing complete
Threaded INTERCAL

Threaded INTERCAL is an extension of INTERCAL by Malcolm Ryan to include threads. 
* Multiple COME FROM statements with the same label cause the program to fork separate threads at each COME FROM. 
* The code base is shared, so that abstaining and reinstating lines of code from one thread will affect all other threads. 
* Synchronisation is achieved using new DO ... ONCE and DO ... AGAIN tags.
==External resources==
* 
Category:Languages
Category:Implemented
Category:Low-level
Category:1998
Threader

Threader is a 2d programming language that uses threads.
= Code to see if you can guess how it works =
 S:B>
 \\A:
 ##v##
 #>^ #
 >$ <
 #>v #
 ##^##
 \\B:
 ##v##
 # 0 #
 > B <
 # 1 #
 ##^##
Category:Languages Category:Two-dimensional languages
Threads

Threads is an Esolang. It is multithreaded.
 Code
Symbols	Info
a 	add one to the counter
s 	subtract one from the counter
o 	default: output the counter, dotted: output the following string or s for the variable
i 	default: input into the counter, dotted: input into the string variable
( 	start loop default: infinite, dotted: following number or c for the counter (can not be dotted)
) 	end loop (can be dotted)
t 	make a thread to run the dotted code in (t.[a]), can also have a thread id (t0.[a])
[ 	start code block default: run normal, dotted: run with arguments* (can not be dotted)
] 	end a code block (can be dotted)
q 	compile the current thread default: compiles to a.out, dotted: compiles to #
c 	comment (c.”this is a comment”)
* that are not in the compiler command
 Arguments
Symbols	Info
[blank]	run the code normally
v 	verbose (Created new thread! Added 1 to the counter!)
o 	outputs to o.out (can be changed in the configuration file)
i 	set the string to the current value of the file i.out
c 	each code bloCk is a value on a staCk
e 	extends the logic set using rules from e.out
Hello World:
 o."Hello, World!"
Cat:
 (i."" o.s)
XKCD Random Number:
 t.[a a a a o] c."speed thread"
Fork Bomb:
 (t.[t]) c."your computer will not survive this"
Compiler Example:
 ./threadsc.sh -voice hello.thr
Block Example:
 [o.”Balls”].o
Category:Languages Category:2024 Category:Concurrent programming
Thue++

Thue, but with RegEx (EMCAscript).
Capture groups exist, and can be accessed by the replacement text with $number.
= Examples =
Variables:
 (var (\w*)="([^"]*)".*)\2::=$1$3
Thue Interpreter:
 ((\n|^)(\S+):{2}=(\S*)(\n.*\n|\n):{2}=\n.*)\3::=$1$4
= Implementation =
https://jsfiddle.net/1kbpuyxj/13/
Category:LanguagesCategory:ImplementedCategory:Turing_completeCategory:String-rewriting_paradigmCategory:Nondeterministic
Thue-Mirr

Thue-Mirr is a 2D programming language with the following commands:
* \ / - Mirrors
* x - Output X coordinate of tile
* y - Output Y coordinate of tile
* 0 1 2 3 4 5 6 7 8 9 - Output a constant value
The initial configuration is the program tiled infinitely.
When a mirror is hit, the direction program flow is changed, and then the mirror might be flipped. It is flipped if the number of bits set in the number of times a mirror has previously been hit (not counting this one) is an odd number, otherwise it is not flipped.
==External resources==
* Interpreter in Python3 with some examples.
Category:LanguagesCategory:2019Category:ImplementedCategory:Two-dimensional languagesCategory:Unknown computational class
Thue/Turn based battle game

:
made by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
 {input}::=:::
 attackE::={inputted}
 heal::=PP{inputted}
 {inputted}::=A{sayAttack};
 {sayAttack}::=~ ENEMY ATTACKS! 
 PA;::={infoplayer<{printplayer}}
 {printplayer}::=~ PLAYER HP: 
 {printenemy}::=~ ENEMY HP: 
 P{infoplayer<}::={infoplayer<{printstar}}P
 {printstar}::=~*
 ({infoplayer<}::=({bringer>}
 {bringer>})::={win}
 {bringer>}P::=P{bringer>}
 {bringer>}E::={infoenemy>{printenemy}}E
 {infoenemy>}E::=E{infoenemy>{printstar}}
 {infoenemy>})::={check?<})
 P{check?<})::={tie}
 E{check?<}::=E{check<}
 E{check<}::={check<}E
 ({check<}::={lose}
 P{check<}::=P{input}
 {win}::=~ ENEMY HP: 0 You Win!
 {lose}::=~ You Lose
 ::=
 (PPPPP{input}EEEEEEEE)
ThueLike

ThueLike is a esolang created by User:Mario0Fan. Its supposed to be more like a programming language, but it has 1 thing in common with Thue. The commands are run in a random order. To achieve this effect easily, the original interpreter for ThueLike is written in Thue.
== Functions ==
ThueLike is designed to be simple to understand, but hard to actually do things in it.
If theres something in the code that is not a function, it will be considered as output.
===Logic Gates===
Function	Description 	Example	
_xy 	And gate. Will turn into a 1 if both x and y are 1. It can be blocked by a < if y is 1. 	_11 = 1
_10 = 0	
=xy 	XNOR gate. Similar to And gate. If x is equal to y, it will turn into a 1. If not, it will turn into a 0. It can be blocked by a < if y is 1.	=00 = 1
=11 = 1
=10 = 0	
-xy 	Or gate. Will turn into a 1 if at least one of the inputs is a 1. It can be blocked by a < if y is 1. 	-10 = 1
-11 = 1	
!x 	Not gate. If x is 0, it will turn into a 1, else if x is 1, it will turn into a 0. It can be blocked by a < if x is 1. 	!1 = 0 	0 = 1
===If statements===
Function	Description
x> 	Truth machine. If x is 1, it will keep putting 1 to its right unless the truth machine is stopped by a < function.
===Other===
Function	Description 	Example
^ 	This function will turn into what the user has typed in. 	user input: cat
^ = cat
4Bx 	This converts x (a 4 bit binary number) into a decimal and then turns into the result of the conversion. 	4B1111 = 15
< 	Mover. Moves left. It can walk on 1's, but if it will walk on a truth machine, it will destroy the truth machine. 	11< = 1<1
1>< = <
? 	Random bit. Will turn into a random bit. 	? = 1
? = 0
() 	Delay. This function will be destroyed if a bit touches it. Good for making delays between logic gates and truth machines.	1() = 1
()1 = 1
1()1 = 11
==Examples==
===Truth machine===
For more details, go here
 ^>
====Randomized truth machine====
This will randomly pick between 1 and 0.
 ?>
=====Even more randomized truth machine=====
Featuring alot of brackets to add a delay between the logic gates and the truth machine.
 _-??-_??_??()()()()()()()()()()()()()()()()()()()()()()()()()()>
===Hello world===
This program prints "Hello World!".
 Hello World!
===Random number generator===
This program generates a random number between 0-15.
 4B????
==See also==
* Thue
* Original ThueLike interpreter.
Category:2022 Category:Nondeterministic Category:Implemented
Thue Symbol Sorting Theorem

Safalra's Special Thue Symbol Sorting Theorem (SSTSST) and Safalra's General Thue Symbol Sorting Theorem (SGTSST) place a lower bound on the speed of symbol sorting in Thue in terms of the number of string replacements made - namely that sorting is Omega(n^2), where n is the number of symbols to sort.
==Terminology==
* Bounded sorting - Sorting a number of items, each with bounded length
* Symbol sorting - Sorting a number of items, each of which is a single symbol 
* Permutation symbol sorting - Sorting a number of items, each of which is a single symbol, using rules whose right-hand sides are permutations of their left-hand sides
Because a Thue program can only deal with a finite number of symbols, there are a finite number of possible items whose length is less than a fixed value. This means that bounded sorting can be converted into symbol sorting in Theta(n) time by converting each item into a single symbol.
==The theorems==
* Safalra's Special Thue Symbol Sorting Theorem - Permutation symbol sorting of n items runs in Omega(n^2) time
* Safalra's General Thue Symbol Sorting Theorem - Symbol sorting of n items runs in Omega(n^2) time
The proofs are complex and are not provided here.
==External resources==
* Sorting In Thue - contains a proof of Safalra's Special Thue Symbol Sorting Theorem
Category:Proofs
Thulani machine

Thulani machine is a Computational model created by User:Yayimhere. its name is from one of his middle names
== how it works ==
the Thulani machine has a single register which is numerical.
it has a single instruction:
apply Collatz function to the register n times increment by k and if it the register becomes equal to 1 it will jump to line u
where n, k, and u are command arguments
== computational class ==
its not known but i'm pretty sure its turing complete since the Collatz function is turing complete
Category:Computational models Category:Unknown computational class Category:Low-level
Thyrd

Thyrd is an experimental, reflective, visual programming language and environment invented by Phil Mercurio in 2010.
In Thyrd, both data and code are stored in cells situated in nested two-dimensional grids. The user interface animates the transition from a cell to its subordinate or superordinate grid to help keep the user oriented in the hierarchical grid structure. All operations the user can perform to edit the structure are implemented as operators in the Thyrd language, thus a Thyrd program can inspect and modify itself or other programs in the same space.
Thyrd is a member of the Forth family of languages. Thyrd is a postfix concatenative language most similar to Joy in that it uses quotation and combinators to implement iteration and recursion. The environment provides a viewer that animates the stacks of a Thyrd program and allows the program to be stepped both forwards and backwards.
The primary view of Thyrdspace is a 2D grid of text and icons. A view may be overlaid with a panel consisting of arbitrary widgets editing the contents of individual cells or an entire grid. A Thyrd application can be constructed in which all of the code and data are hidden behind panels and revealed only at the user's request.
== External links ==
* Official site
* Presentation (YouTube)
Category:Languages Category:2010 Category:Stack-based Category:Implemented