nyuuzyou/wikis huggingface dataset:
Tomagotcha!

Tomagotcha! is a set of semantics describing the construction of an interpreter for a "pseudo-esolang" whose only "instruction" is the mere execution of its interpreter.
=="Language" overview==
A Tomagotcha! interpreter's behavior is dependent upon what time it is when the program is executed. Upon invocation, the hours, minutes, and seconds of the current 12-hour time are obtained and summed. The resultant value's corresponding ASCII character must then be written to the interpreter's "memory" (the mechanics of which are the implementer's prerogative) such that it may be recalled upon subsequent runs. In this manner, a Tomagotcha! "program" accrues sequentially over the course of repeated invocations.
However, if it is the case upon execution that a given Tomagotcha! interpreter has not been invoked within the last four hours, the whole of its memory is recalled and evaluated as a program under the rules of the host language, thereby achieving computation, the "class" of which is simply inherited from the parent language except in extremely rare (read: as yet undiscovered) circumstances.
Finally, if the child program was evaluated without error, the interpreter discards its memory and terminates. Otherwise and alas, it must intentionally destroy itself. Thus, a conforming Tomagotcha! interpreter must be diligently interacted with at least six times daily in order to perform meaningful work.
==Reference implementation==
Though not strictly required, a Tomagotcha! interpreter is advised to perform the elegant optimization of keeping its brain in its tail. 
 #!/usr/bin/env ruby
 
 if (t = Time.now) - File.mtime($0) > 14400
 eval DATA.read rescue `rm #$0` and exit
 exit IO.write($0, `head -n #{DATA.lineno - 1} #$0`)
 end
 
 `echo -n '#{eval(t.strftime '%H+%M+%S').chr}' >> #$0`
 
 __END__
Tome

Tome is a tanspiled language that aims to use syntax as close to natural English as possible. It transpiles into Javascript and is typically run via a web browser.
== Hello World ==
Show "Hello, World!".
== Looping over an array ==
Set food as ["pie", "cake", "muffins"].
For every item in food do:
Show "Mmm, I'd love some " + item + " right now!".
End.
== Fibonnaci ==
Set var1 as 1.
Set var2 as 1.
Show "The first number is " + var2.
Count until x reaches 5:
 Set nextnum as var1 + var2.
 Set var1 as var2.
 Set var2 as nextnum.
 Show "The next number of the fibonnaci sequence is " + nextnum.
End.
== External resources ==
* Tome GitHub repository
Category:Languages Category:Implemented Category:Pseudonatural
Tommyaweosme unary

:This article is not detailed enough and needs to be expanded. Please help us by [ adding some more information].
tommyaweosme unary (or just tommyaweosme) is like unary but it uses repitions of the image below:
uniform background causes the program to make your web browser burst into flames
while non-uniform causes the browser to load this page a LOT slower and burst into flames!
Category:Joke languagesCategory:ConceptsCategory:2024Category:LanguagesCategory:Non-textualCategory:Brainfuck derivatives
Too

Too is a 2-bit tape-based esoteric programing language by User:ChuckEsoteric08
==Specification==
At the start of the program number is inputed and if it's a number from 0 to 3 set current cell to it. The code runs forever.
==Architecture==
Cells are 2-bit and wrapping.
==Commands==
Command	Description
> 	Move the cell pointer one step to the right
< 	Move the cell pointer one step to the left
+ 	Increment the current cell by one, wrapping around if exceeding the maximum of 3
- 	Decrement the current cell by one, wrapping around if descending below the minimum of 0
o 	If the current cell contains 3, execute the next five commands
x 	Execute the command x until the current cell contains 0, or until the pointer will be out of the valid bounds
==Computational class==
Turing-complete because because it is possible to simulate Cyclic Tag with initial queue of 1:
;	<>|+|>
0	<>o|>+><|<|>
1	<>o|>+++|<|>
Input should be 3.
==Examples==
===Incrementing===
Queries the user for an input and continuously increments the same:
 +
===Conditional execution===
If the user enters the value of three, advances to the dextral cell, sets it to two, returns to the original cell, and increments it by one in order to reach the value zero, thus disabling these actions in the subsequent cycles.
 o>++<+
==Interpreter==
* Common Lisp implementation of the Too programming language.
Category:Languages Category:Turing complete Category:Turing tarpits Category:2023 Category:Implemented
Too Many Variables!

Too Many Variables! is an esolang created by squareroot12621, but you can only assign variables.
Like, seriously, that's all you can do.
== Documentation ==
In Too Many Variables!, lines have to look like this:
 <number>=<number><operation><number>
Here, <operation> can be one of +-*/—the standard four operations. However, the <number>s are different from normal numbers, since they can have leading zeroes.
Here's a chart showing how the different number formats work:
Format 	Regex 	Description 	Description
Format 	Regex 	Assignment 	Accessing
Number with no leading zeroes	[1-9]\d* 	Variable 	Variable
Number with 1 leading zero 	0[1-9]\d*	Literal number 	Literal number
000 	000 	Literal number 0 	Literal number 0
0 	0 	Print chr(<number>) 	Return ord(input()[0])
00 	00 	Change line number; if outside program area, halt	Get line number
Anything else 	0\d+) 	Invalid—throws an error 	Invalid—throws an error
This is pretty much the entire language.
== Examples ==
Print Hello, World!:
 1=098+09
 0=063+09
 0=1-06
 0=1+01
 0=1+01
 0=1+04
 0=035+09
 0=023+09
 0=078+09
 0=1+04
 0=1+07
 0=1+01
 0=1-07
 0=024+09
== Interpreters ==
; Python interpreter (Github)
: Note: This interpreter requires at least Python 3 to run.
Category:Languages Category:Implemented
Top-based turning

Top-based turning is an esoteric programming language invented by User:A influenced by The Waterfall Model and Befunge.
==The language==
Imagine a cube with 6 faces. There is a clock on each face. Yes, that is how Top-based turning stores data. Not as you will probably expect, the clock does not have 3 hands. Instead, it only has 1 hand and can only show 4 times: Up-time (pointing to ↑) represented by 0, right-time (pointing to →) represented by 1, down-time (pointing to ↓) represented by 2, and left-time (pointing to ←) represented by 3. Note that every execution of a command results in an increment of the clock hand (similar to The Waterfall Model's waterclocks, but not decrementing) and 4 maps down to 0.
===Original state===
The cube is set to values in this net:
 0
 000
 0
 0
(where the bolded number is the bottom of the cube)
===Command execution===
A program in Top-based turning starts at a specific location in the program (usually line 1, column 1). This is the process that a program is executed:
* Execute the cell pointer by the instruction pointer in the program
* Automatically rotate the clock hand on the top face of the cube clockwise.
* Send program flow as 1 cell to the direction that the clock hand is pointing to.
===Case-sensitiveness===
By the way, note that Top-based turning is not case-sensitive.
==Commands==
*:stop the program
::input 2 numbers. Load the top face of the cube into the specified location in the code (inputting x and y specifies a line x and column y location).
;:Similar to :, yet it loads a specified place in the program into the top of the face.
^:Flip the cube up
v:Flip the cube down
<:Flip the cube left
>:Flip the cube right
a:If top is 0 then < else > (<:> afterwards)
b:>:<
c:^:v
d:v:^
e:^:>
f:>:^
g:>:v
h:v:>
i:v:<
j:<:v
k:<:^
l:^:<
,:input x, set the top face of the cube as x.
.:output the top face of the cube.
Any other character is a no-op.
==Example program==
Writing useful programs in Top-based turning is very difficult. Thus, these example programs are useless programs. (Maybe you could try Hello, world! programs or Cat programs if you want to experience it firsthand.)
===Outputs "3"===
The program flow starts at the bolded letter.
 *zz
 .z<
===Counter from 0 to 4===
 ..
 ..
==Computational class==
It seems that it is Turing-complete, but there is no proof for it. (What is does have is an infinite tape, conditional switching, looping, and input/output (I/O is unnecessary anyway).)
Category:Languages
Category:2019
Category:Unknown computational class
Category:Two-dimensional languages
Category:Cell-based
Category:Unimplemented
Category:Self-modifying
Topaz

Topaz is an esoteric programming language created by Kiwitrader (talk) 03:25, 13 August 2016 (UTC)
its syntax is relatively simple:
every program starts with main function declaration:
 main {
 ; code
 }
endwiths are snippets of other files:
for example:
in new.tpz:
 puts Hello world
 puts end
and in main.tpz, which the interpreter auto-runs:
 main {
 endwith new
 puts hello
 }
would output:
 hello
 Hello world
 end
add, sub, mul, div, and mod do what you expect, they store the answer in their own names.
echo is like a single line cat.
pause... waits for input.
input> gets input and stores it in answer.
comments are semicolons.
to output a variable, use outvar.
make a list by using:
 list name
append by using addto.
 addto name value
Topple

Topple is developed in C. The entire language is made up of single characters.
Topple (conditionally) ignores whitespace, which means you can cram everything into one line. Good luck with that though.
==Overview==
Command	Description 	Example 	Output
. 	Tells the program to “admit” a given character
*Does not ignore whitespace 	a.b.c. 	None
@ 	Outputs all admitted characters and clears them 	a.b.c. @ 	abc
& 	Outputs all admitted characters without clearing them 	a.b.c. & 	abc
: 	Outputs and clears an admitted character at a given index
*Does not ignore whitespace 	a.b.c. 0: 	a
; 	Takes admitted character from a given index and copies it.
*Does not ignore whitespace 	a.b.c. 0;. @	abca
= 	Defines variables
*Does not ignore whitespace 	a=1 	None
^ 	Calls variables
*Does not ignore whitespace 	a=1 a^. @ 	1
! 	Takes user input 	!. @ 	Whatever the user inputs
? 	Compares two values and returns ‘1’ if the two are the same or ‘0’ if the two are not the same. The two values are then deleted.	a.b.?. @ 	0
# 	Returns a random number between 0 and 9 	#. @ 	0-9
< 	FOR Loop, loops based on a given amount (last admitted data, deleted upon use) 	3.<a.@> 	aaa
( 	IF Statement, conditionally runs code based on a given character (last admitted data, deleted upon use) 	1.(a.@) 	a
+ 	Increments an admitted character at a given index
*Does not ignore whitespace 	1.2.3. 0+@ 	124
- 	Decrements an admitted character at a given index
*Does not ignore whitespace 	1.2.3. 0-@ 	122
* 	Quits the program 	 	
==Special Characters==
Character	Description
\ 	New Line (\n)
Topple is still in development. A file containing the source code will be provided in the near future, along with multiple examples of the syntax and how to use the language.
Topsy Turvy

Topsy Turvy operates on an array of cells, each initially set to an undefined value. A data pointer initially points to the cell in the centre of the array.
Operation	Behaviour
< 	Decrement the data pointer
> 	Increment the data pointer
- 	Decrement the cell pointed to by the data pointer
+ 	Increment the cell pointed to by the data pointer
, 	Read a character into the cell pointed to by the data pointer
. 	Output the character in the cell pointed to by the data pointer
] 	If the cell pointed to by the data pointer is zero, jump back to the matching [
[ 	If the cell pointed to by the data pointer is nonzero, jump forward to the matching ]
^ 	Change data polarity. Swaps the behavior of < with > and - with +
v 	Change program polarity. The direction of program execution is reversed
Category:Languages
Category:Brainfuck derivatives
Category:Cell-based
Category:Low-level
Category:Unimplemented
Total BF

Total BF is a WIP total (fully defined, always terminating) version of brainfuck abandoned by User:Tailcalled. It will obviously not be Turing-complete.
== Effect system ==
Total BF will have some sort of effect system, which will limit the programs that can be written.
Current ideas for effects documented (hopefully self-expanatory):
 + :: [$#n+1]
 - :: [$#n+255]
 > :: [$n, #n]
 < :: [#n, $n]
 . :: [$#n]
 , :: [$#m] -- note, m, not n
A loop will then require an instruction along the lines of any of the following:
 a :: [$#n+x] where x != 0
or
 b :: [$n+x, #n] where x != 0
or possibly others.
Category:Total
Category:Languages
Category:Brainfuck derivatives
Total LISTP

Total LISTP, pronounced "to-tal listp", is an esoteric LISP-like programming language that always halts (which makes it usable on a total Turing machine). This description is work-in-progress and open to ideas.
== Syntax ==
Brackets, curly brackets, and parentheses may all be used as parentheses are in normal LISP, as long as they are properly matched. Semicolons and commas are treated as whitespace. Comments start with hashtag/pound/number sign #.
== Semantics ==
Uses term-rewriting. Symbols have LISP-1 semantics. Definition overloading using argument count. No macros as known in other LISPs. There are no "multiple values", lists can be returned instead.
* {def <expr1> <expr2>} # define a variable or function
examples:
 {def a 3} # a = 3 (a variable is like a 0-argument function)
 {def (a x) (+ 1 x)} # the old definition of a is overrided with this new one
* {def+ <expr1> <expr2>} # overload a definition of a variable or function
examples:
 {def b 1}
 {def+ {b x} (+ b x)} # b is overloaded as a variable 1 and also a function that adds b (the variable) to x
* {fun [<sym>...] <expr>} # like lambda
* {dotimes [<sym> <expr>] <expr>}
* {repeat <expr> <expr>}
* {dolist <expr:list> <expr>} # linear lists only
* (display <expr>)
* (read-char)
* (emit-char)
* (read)
* (eval <expr>)
* {do <expr> ...}
* (/ x y) # x divided by y, if y is 0, then returns 0
* (* x y) # x multiplied by y
* (+ x y) # x added to y
* (- x y) # difference of x and y
* (sum <expr> ...) # sum of expressions (addition)
* (product <expr> ...) # product of expressions (multiplication)
== Examples ==
=== Hello world ===
 [display "hello world"]
=== 99 bottles ===
 (def bottles
 {fun [n]
 {do
 {cond {(= n 0) (display "No more bottles")}
 {(= n 1) (display "One bottle")}
 {else (display n) (display " bottles")}}
 (display " of beer")}})
 {dotimes [n 99]
 {if (> n 0)
 {do
 (bottles n) (display " on the wall") (newline)
 (bottles n) (newline)
 (display "Take one down, pass it around") (newline)
 (bottles (1- n)) (display " on the wall") (newline)
 (newline))}}}
=== Total cat ===
Halting cat program. Takes the number of characters to repeat and then repeats that many characters.
 [repeat (read)
 (display {or (read-char)
 (halt)})]
Category:Total
Category:Unimplemented
Category:High-level
Category:2022
Category:Languages
Totally Accurate Malbolge

Totally Accurate Malbolge (TAMalbolge) is a joke language created by Braden Best (User:Bradenbest). TAMalbolge is a derivative of malbolge, but much simpler and easier to program in. 
== Usage ==
There is only one valid program:
(=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc
Which prints "Hello World!"
The language, due to its simplicity, can be mastered in as little as two minutes.
== Exception Handling ==
Exceptions do not exist in TAMalbolge, but errors are helpfully reported in a detailed and concise manner:
 (=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8db
 Too many arguments
 
 (=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8d
 Not enough arguments
 
 (=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:"8dc
 Segmentation Fault.
 
 (=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(;'8dc
 � � � � � � � � � � � � � � � � � � � � � � 
 
 (=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS/@-ejc(:'8dc
 ^A^A^A^A^A^A^A^A^A^A^A^A^A^A^A^A^A^A^A^A^A^A^@
Taking the feedback from these errors, one can easily conclude that the correct program is:
 (=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc
 Hello World!
=== Bugs ===
Some errors may break certain interpreters. For example, typing this:
 (=<`#9]~6ZY32Vx/4Rs+0No-&Jk)"Fh}|Bcy?`=*z]Kw%oG4UUS/@-ejc(:8dc
Causes "^A" to be repeated in an infinite loop in most interpreters.
== Implementations ==
The official interpreter, written in python by Braden Best.
Category:Languages
Category:Joke languages
Category:Implemented
Totrandom

== Brief Introduction ==
Totrandom is a totally random joke language.
The program contains only a number and anything other than a number will be concerned as a SYNTAX ERROR.
The number means the length of the output, and the program will output a random string of the length. Each character in the string is chosen from \x00 to \xFF.
== Example Programs ==
=== Hello, World! ===
This program has a chance of 1/25613 (about 0.00000 00000 00000 00000 00000 00000 04930 38065) of getting the output Hello, World!.
13
=== Quine ===
This program has a chance of 1/256 (about 0.00390 625) of getting the output 1, which makes it a quine.
1
Or this program with a chance of 1/32768 (about 0.00003 05175 78125) of getting the output 2[LF] or 2[EOF], which makes it a quine.
2
== Interpreter ==
=== C++ ===
#include <bits/stdc++.h>
using namespace std;
#define int long long
int x;
signed main(){
	srand(time(0));
	cin >> x;
	for(int i = 1; i <= x; i++)
		cout << (char)(rand() % 256);
	return 0;
}
Category:Languages Category:Joke languages Category:Implemented Category:Unusable for programming Category:Total Category:Output only
Tq

tq is a language invented by User:A in 2019, but it wasn't yet in shape until 2020. The language idea was based on Jo King's Raku Quine. It was created so that you can index the list while you are defining your list!
== Etymology ==
It was named as tq, because the quine in tq is like this:
etq'etq'
The name is an acronym, standing for "tail quote".
== Syntax ==
A program in the language is a list without a separator, although a separator would indeed be neccecary if two items are ambiguous without separation. An example program is:
'Hello, World!'1
Look, there isn't any separator between the string and the number. In this program you defined a list:
['Hello, World!',1]
And then every item is outputted implicitly at the end without a separator.
Hello, World!1
Pretty easy, huh?
== Tutorial ==
tq is an infix language. That means the operators go between the operands. Here is an example:
1+1," ",2-2
This outputs 2 0. In fact tq supports a lot of operators: +-*/%&|=>, all of which you have met before in other languages. The thing that needs to be noted is that the = does not mean assignment; it means equality comparison.
Most of tq's operators are mathematical: _ means negation, ! means factorial (NOT logical NOT).
== Operator reference ==
Instruction	Action
. 	Index inside the array. E.g. .4 indexes the 4th item in the array. Note that indexing starts at 1.
q 	"quote" the string, similar to Python's repr().
e 	"Evaluate" the string under tq syntax.
f 	"Find" the first occurence of the string in the main list, returns -1 if failed.
~ 	Reverse the list given as operand.
== Implementation ==
* Official tq implementation
Category:2019
Category:Languages
Category:Stubs
Trail

Trail is a programming language that plays like an adventure/game. It compiles to zeroes and ones, which is compiled into words. It is written in JavaScript, and uses these four commands: ">", "<", "ˇ" and ")". 
It is also an attempt to be as small as possible, currently being 452 bytes big (nearly 2x bigger than Brainfuck's compiler but not fully 2x).
Trail is meant to be programmed in a grid, which where you make code out of a trail using the arrows on keyboard and the spacebar, hence the name Trail.
== Overview ==
Trail is a language that takes a sequence of commands to translate to binary by replacing every less-than sign with 1, greater-sign with 0, every caron (ˇ) as an ignore (to prevent collisions, more on that later) and every closing parenthesis as a space to separate binary. Trail will then convert the binary to a normal string.
More on collisions, Trail errors when ">" and "<" collide with each other. Why? Just to make it more challenging, which is why the down arrow is used as an ignore to prevent collisions.
== Running & Usage ==
Trail can currently be run only by the Trail GUI and the Trail API.
Here are some Trail examples:
Number One:
 > > ˇ
 < < <
 ˇ >
69:
 > > ˇ
 < > > ˇ
 < )
 > > > ˇ
 < < >
amogus:
 > > ˇ
 < > > ˇ
 < > > > ˇ
 < < >
Hello, World:
 > ˇ 
 < < > ˇ 
 < < < ) > > ˇ 
 < < > ˇ 
 < > ) > > ˇ 
 < > > ˇ 
 < < ) > > ˇ 
 < > > ˇ 
 < < ) > > ˇ 
 < > > > > ) > ˇ 
 < > > ˇ 
 < < ) > ˇ 
 < < < < < ) > ˇ 
 < > ˇ 
 < > > > ) > > ˇ 
 < > > > > ) > > > ˇ 
 < < > ˇ 
 < ) > > ˇ 
 < > > ˇ 
 < < ) > > ˇ 
 < < > ˇ 
 < < ) > ˇ 
 < < < < >
== GitHub ==
The GitHub repo is at https://github.com/Unzor/Trail, and the official page is at https://unzor.github.io/Trail.
Category:Languages Category:Implemented Category:Turing complete Category:Low-level
Train

Train is a two-dimensional esoteric programming language created by User:kiken.
==Overview==
Train consists of a single train (the instruction pointer) that is moving across a track. It is constantly moving forwards, and once the train is no longer on the track, it is derailed and the program halts - note that if a train comes across a 90° turn, then it won't turn and will also be derailed. The trail begins at the top-left corner of the program.
Memory in Train is an two-dimensional grid of bits that is unbounded in the up and right direction. At the bottom of the memory grid, there is an eight-bit-long tape named smoke chamber that is used for output. The memory pointer by default, the pointer is at the bottom left of the memory grid, in the smoke chamber.
===Carriages===
A carriage in Train is represented with a single and can hold a single unbounded number. A carriage comes at the start of a program and signifies that the train should have a carriage (a train can only hold one carriage).
===Stations===
Stations in Train consist of squares and appear to the side of the track. If the train encounters a station, the station will be executed. Stations look like this when the adjacent rail is horizonal:
 [ code ]
and this when the adjacent rail is vertical:
^
code, but vertical
v
The code in the stations are read from left to right and can be unbounded. The instructions depend on the train's direction. 
====Instructions when train facing left====
Instruction	Description
 	Flip the bit at the memory pointer
 	Move the memory pointer according to the train's direction
====Instructions when train facing right====
Instruction	Description
 	Set the cell at the memory pointer to the OR gate of this cell and the one above it
 	Output the smoke chamber as ASCII
====Instructions when train facing up====
Instruction	Description
 	Output the smoke chamber as decimal
 	Set the cell at the pointer to the AND gate of this cell and the one above it
====Instructions when train facing down====
Instruction	Description
 	Output the number on the train's carriage as ASCII
 	Increment the number on the train's carriage if the cell at the pointer is 0, else decrement.
===Rail===
Self-explanatory.
Rails in Train consists of the following:
Rail type	Description
 	Horizontal
 	Vertical
 	Turn (also acts as a diagonal track)
 	Turn (also acts as a diagonal track)
 	Junction - if cell at pointer is 0, then train goes vertical, else go horizontal
There is also a special rail - - which gets input and places it's ASCII value in the carriage.
==Examples==
===Infinite loop===
-------\
 / |
 | |
 \----/
This example also shows how a diagonal track can merge onto a horizontal or vertical track.
===Cat program===
--^---\
 / |^
 | |
 | |!
 | |
 | |v
 \----/
Category:Languages Category:Unknown computational class Category:Two-dimensional languages Category:2024 Category:Unimplemented Category:Thematic