nyuuzyou/wikis huggingface dataset:
Tiangou

Tiangou is a derivative and wimpmode of Cerberus. It only has 1 line, which is a list of commands separated by spaces. All the commands correspond to one in Cerberus.
==Commands==
 p | Push 1 to stack
 q | Push -1 to stack
 i | Push input to stack
 o | Pop and print top of stack
 - | Pop A and B, push A-B
 ! | Pop A. If positive, push A!, else push -((-A)!)
 " | Swap top 2 items
 : | Duplicate top item
 < | Pop A, set current IP location as A-marker
 > | Pop A, jump to A-marker (no-op if undefined)
==Example program: Truth-machine==
 i p < : : o >
==Translation to Cerberus==
 ..-.--
 p -> .---.-
 ..-.--
 ..-.--
 q -> .-...-
 ..-.--
 ..-..--.-.---
 i -> .---.--.--..-
 ..-..-.--...-
 .-...-
 o -> ..-.--
 ..-.--
 .--.--
 - -> .-...-
 .--.--
 ..-..-
 ! -> .---.-
 ..-..-
 ..-
 " -> .--
 .--
 ..-..--.--.--
 : -> .---.-..-...-
 ..-..-..--.--
 ...-.---.--.--
 < -> .--...-..-...-
 ..---.-..--.--
 ..-..-.-----.-..--.--
 > -> .---.--..-...-..-...-
 ..-..--...-.---.--.--
Category:Languages Category:Unknown computational class Category:Stack-based Category:Unimplemented Category:2020
Tic Tac Toe

Tic Tac Toe is an esoteric programming language created by User:JWinslow23 in 2013. This takes the form of Tic-Tac-Toe games.
==Introduction==
The Tic-Tac-Toe board is labelled as follows.
 a1|a2|a3
 --+--+--
 b1|b2|b3
 --+--+--
 c1|c2|c3
For example, c3 means move in the bottom right corner.
You can designate yourself as X or O, but it must stay that way throughout the whole program.
The commands are as follows (functions are the same as in BF):
 + | - | >
 ---+---+---
 < |NOP| [
 ---+---+---
 ] | , | .
Any square you go on that wins is a NOP (e.g. if you go on a1 and you went on b2 and c3, the cell will not be incremented).
==Syntax==
At the start of every program is a declaration of who you are playing as (X or O).
 I will play as X/O.
Next is a declaration of a game (they must be numbered from 1 on up, and in the right order). There can be as many games as needed.
 Game 1:
Then, the game is played. X always goes first, X and O must alternate moves, and you designate a square being played on by saying:
 X/O went on name_of_square.
When you win a game without declaring a new one, any more moves made afterwards will result in an error.
==Example programs==
===Infinite loop===
 I will play as X.
 
 Game 1:
 X went on a1.
 O went on a3.
 X went on b3.
 O went on b1.
 X went on c1.
 O went on a2.
 X went on b2.
This corresponds to +[] in BF.
===Cat program===
 I will play as X.
 
 Game 1:
 X went on c2.
 O went on a1.
 X went on b3.
 O went on b2.
 X went on c3.
 O went on c1.
 X went on a3.
 
 Game 2:
 X went on c2.
 O went on b2.
 X went on c1.
 O went on b3.
 X went on c3.
This corresponds to ,[.,] in BF, and requires two games to be played.
==Interpreter==
* Common Lisp implementation of the Tic Tac Toe programming language.
Category:LanguagesCategory:Brainfuck derivativesCategory:ImplementedCategory:Cell-basedCategory:Turing completeCategory:ThematicCategory:2013
Tick

Description
Tick is a esolang created in 2017. It has only 4 commands and an infinite memory tape. It is made to also ignore non-command characters. It is an incomplete TrivialBrainfuckSubstitution.
Commands
Command	Description
> 	Move the selector to the next cell
< 	Move the selector to the previous cell
+ 	Increment the memory cell at the selector. Truncate overflow: 255+1=0
* 	Add the ASCII value of memory cell at the selector to the output stream
Hello world!
The following is a hello world program in Tick
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *+++++++++++++++++++++++++++++*+++++++**+++*>+++++++++++++++++++++++++++
 +++++*<++++++++*>+++++++++++++++++++++++++++++++++++++++++++++++++++++++
 ++++++++++++++++++++++++*+++*>++++++++++++++++++++++++++++++++++++++++++
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*>++++
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 ++++++++++++++++++++++++*>+++++++++++++++++++++++++++++++++*
Interpreter
As it is a Trivial Brainfuck Substitution the interpreter is equally trivial.
 #!/usr/bin/ruby
 eval 'm=Hash.new(p=0);'+ARGF.read.gsub(
 /./,
 '>' => 'p+=1;',
 '<' => 'p-=1;',
 '+' => 'm[p]+=1;',
 '*' => 'putc m[p];')
==Interpreter==
* Common Lisp implementation of the Tick programming language.
Category:LanguagesCategory:Cell-basedCategory:2017Category:Implemented
Tictactoe

tictactoe uses tictactoe
 moves are reperesented as a number:
 123
 456
 789
 and you can never place a thing where something is there
 so you should try to do something else
== rules ==
 if you win, 1
 if you lose, 0
 if you tie, 0.5
 base 3
== how to do stuff ==
 brainf
 000: +
 001: -
 010: >
 011: <
 100: .
 101: ,
 110: [
 111: ]
 these are from the winning and losing sequences
== the easy way ==
 000: + 176849176849176849
 001: - 17684917684914283
 010: > 17684914283176849
 011: < 1768491428314283
 100: . 14283176849176849
 101: , 1428317684914283
 110: [ 1428314283176849
 111: ] 142831428314283
== examples ==
=== add ===
 1428317684914283176849142831768491428317684914283142831428317684917684917684914283176849142831428317684917684917684917684914283176849142831428314283
Category:Languages Category:Brainfuck derivatives Category:Cell-based
Tildehyph

Tildehyph or ~- is a turing complete programming language created by User:Tygrak using only two symbols - the tilde ~ and the hyphen -.
==Language overview==
Tildehyph uses multiple commands most of which have a large amount of modes giving it a lot of potential. Code can include whitespace and comments using // but it isnt required.
A single command is made up of the command, two hyphens, a number of arguments separated by three hyphens and ended by four hyphens. For example ~--~---~------- creates a variable called "~" with a value of 1. Values are inputted as binary numbers ~ is used as a 1 and - as a 0, but they cant end or begin with hyphens. This makes input of exact values slow, because often you have to create a smaller value and then add another value to it. Values can be printed as characters.
The list of all commands and modes of the commands is available at Tildehyphs github repository, you can also find the interpreter there.
==Examples==
I cant add examples, because 3 tildes in a row create a signiture (~~‍~~), instead you can find them on the github repository.
Commented brainfuck interpreter proving Tildehyphs Turing-completeness.
Tile/Update Log

==2.2 (12/19/24)==
* Added rectangle selection with right-clicking and dragging, as well as cut, copy, paste, fill and deleting selections.
* Left clicking and dragging now draws multiple tiles
* Margin was made a little larger
* Middle-click copies a tile's contents
* Context menu on grid rebound to ALT + right click
* Added an option to change the step increment
* Rewrote the save codes system to be more compressed (old codes still work though)
* "Export code" and "Import code" renamed to "load" and "save" respectively
==2.1 (7/25/24)==
* Added stepping
* Removed the hyperlink to version 1.3.1
* Fixed a bug involving the jump instruction
* Minor tweaks
==2.0 (5/3/23)==
* Rewrote interpreter
* Rewrote editor using canvas instead of table
* Added Keybinds
* New URL (old URL redirects)
* URL parameter "code" changed to "c"
* Move all tiles on grid in any direction
* Import code now prompts instead of reading from input box
* Moved update log to its own page
* Added checkbox to disable leave confirmation
* Slight save code optimization
==1.3.1 (12/8/22)==
* Fixed a bug where subtract would enter negative values instead of underflowing
==1.3 (12/4/22)==
* Added Resizing either top left or bottom right corners of the grid (to allow moving the tiles around)
* Changed resizing symbol from an asterisk to a comma for convenience
* Added relative resizing (a 5x5 grid resized by "+3,-2" will become 8x3)
==1.2 (11/23/22)==
* Added URL save code support (?code=[CODE HERE])
* fixed grid resizing so it won't clear the grid
* Added leave confirmation
==1.1 (10/28/22)==
* Added Save Codes
==1.0 (10/12/22)==
first release
Tiltedc

Tiltedc is C but tilted.
It should be 100% C code, but the text shall be interpreted vertically, from top to bottom and left to right. It is technically a Weirdlang.
==Advantages==
* Programming feels like a side-scroller game, this adds even more enjoyment to programming.
* May use screen space more efficiently (when using a horizontal-mounted monitor).
* While coding, you feel as if you were in your own little matrix, which may boosts your self-esteem.
* It looks cool (could almost be used as a wallpaper).
==Disadvantages==
* Most modern text editors are not specialized in editing vertically.
* Slower compilation (more steps inbetween, because file formats are not optimized to handle Tiltedc).
* Generally, the files end up being larger to their C counterpart (the same reason as above).
* The programmer has to be accustomed in reading text vertically in order to be efficient.
==Examples==
===Hello World===
i{ }
n pr
t re
 it
m nu
a tr
i fn
n ( 
( "0
v H;
o e
i l
d l
) o
 ,
 
 W
 o
 r
 l
 d
 !
 \
 n
 "
 )
 ;
==Implementation==
* Utility written in C (GitHub)
==See also==
* Column
==External resources==
* Wikipedia:C
Category:Languages
Time

Time is an esolang invented by User:None1 and inspired by rand.Next(), the behavior of this esolang depends on how many times you run it.
==Execution==
When run, Time gets the number of times you run before this run (for example, 0 for the first run).
Then, it executes the number in Brainfoctal.
==No-code esolang==
Since the behavior of Time does not depend on the source code, it is a no-code esolang.
==Examples==
===Hello World===
Any text can go here
It works when current run is the 228855768768422936408264393456423041692937029376710995071693817276469283765324982920591645725406th run.
==Intepreters==
Stores the times run at a file called A.
def bf(code):
 s=[]
 matches={}
 tape=[0]*1000000
 for i,j in enumerate(code):
 if j=='7':
 s.append(i)
 if j=='0':
 m=s.pop()
 matches[m]=i
 matches[i]=m
 cp=0
 p=0
 while cp<len(code):
 if code[cp]=='3':
 tape[p]=(tape[p]+1)%256
 if code[cp]=='4':
 tape[p]=(tape[p]-1)%256
 if code[cp]=='6':
 c=sys.stdin.read(1)
 tape[p]=(ord(c) if c else 0)%256
 if code[cp]=='5':
 print(chr(tape[p]),end=)
 if code[cp]=='2':
 p-=1
 if code[cp]=='1':
 p+=1
 if code[cp]=='7':
 if not tape[p]:
 cp=matches[cp]
 if code[cp]=='0':
 if tape[p]:
 cp=matches[cp]
 cp+=1
try:
 a=open("A")
except FileNotFoundError:
 with open("A","x") as f:
 f.write("0")
 a=open("A")
a=int(a.read())
bf(oct('a')[2:])
open("A","w").write(int(a+1))
Category:Languages
Category:Joke languages
Category:Brainfuck equivalents
Category:Implemented
Category:2023
Category:Unknown computational class
Category:No-code esolang
TimeWaste

TimeWaste is an esolang that was created by User:Nathi1235.
It's a python3 based programming language with one minor twist...
certain keywords can only be executed at certain times
==Keyword-Timetable==
Keyword	Time
while 	00:00 - 01:00
for 	01:00 - 02:00
print 	02:00 - 03:00
input 	03:00 - 04:00
if 	04:00 - 05:00
import 	05:00 - 06:00
These Keywords can only be executed at the corresponding time.
==Example==
===Hello World===
 print("Hello World!")
The program looks exactly the same as in python, but it will only print if the current time is between 2am and 3am.
Else it will wait until 2am.
===Cat Program===
 text = input()
 print(text)
The Cat program will at least take 23 hours to complete.
==Interpreter==
Python3 Interpreter
Category:Languages Category:Turing complete Category:2023
Time Out

Time Out is a language by User:Rottytooth where every meaningful action occurs between the lines of code. It tries to do for the Web what Folders did for Windows.
==Concept==
Time Out is not written in textual code but in the amount of time that another interpreted language takes to run a line of code. Time Out programs are usually written in a "Sleep" language, a language built on JavaScript with only a sleep command. As it runs, the Time Out interpreter cycles through its command list. Whatever command the interpreter lands on when the time out has ended is executed. 
Time Out runs in the browser. When Time Out is not running in the active tab, in most browsers it tends to run too slow and so "miss" the intended command, which also throws off the timing for the rest of the program. The only reliable way to ensure a Time Out program runs correctly is to set it to your active tab, and sit and wait, watching the commands being processed one by one. If you bring up another tab, or even another application, it will likely fail.
The speed is set to 30ms/command by default, and can be adjusted according to the speed of the machine and patience of the programmer.
==Language Overview==
Each line of code is in this format:
 timeOut.Set(###); 
The parameter for Set is the number of commands to skip over. The speed at which Time Out cycles through commands can be set, but defaults to 30ms for each command. Time Out's cycle is 200 commands (so ordinarily this is 6 seconds to go all the way around the list), although many are currently unassigned. Underneath, Time Out is a stack-based language with commands borrowed from Forth, etc.
The first 106 commands simply add useful literals to the stack. These are followed by operators and then commands like DUP, SWAP, EMIT, etc.
Every Time Out program ends with:
 timeOut.Set(forever);
==Examples==
===Hello World===
 timeOut.Set(87); // !
 timeOut.Set(132); // d
 timeOut.Set(8); // l
 timeOut.Set(6); // r
 timeOut.Set(197); // o
 timeOut.Set(34); // W
 timeOut.Set(4); // space
 timeOut.Set(4); // ,
 timeOut.Set(158); // o
 timeOut.Set(197); // l
 timeOut.Set(200); // l
 timeOut.Set(193); // e
 timeOut.Set(29); // H
 timeOut.Set(59); // CONCAT
 timeOut.Set(200); // CONCAT
 timeOut.Set(200); // CONCAT
 timeOut.Set(200); // CONCAT
 timeOut.Set(200); // CONCAT
 timeOut.Set(200); // CONCAT
 timeOut.Set(200); // CONCAT
 timeOut.Set(200); // CONCAT
 timeOut.Set(200); // CONCAT
 timeOut.Set(200); // CONCAT
 timeOut.Set(200); // CONCAT
 timeOut.Set(200); // CONCAT
 timeOut.Set(8); // EMIT
 timeOut.Set(forever);
200 is a complete cycle -- the first 200 goes from the first "l" to the second, the others cycle through repetitions of CONCAT
==External resources==
* Time Out interpreter
* interpreter source code
Category:Languages
Category:2015
Category:Stack-based
Category:Non-textual
Category:Implemented
Timefuck

Timefuck is an esoteric language based on brainfuck and TwoDucks, made by Alternative678 in December 2009.
==Commands==
Characters that aren't commands do nothing. Because 'v' is a command, replace it with w or u in comments.
*'+-<>.' do the same things as in brainfuck.
*'(f)' does f if the current cell is not 0.
*'|' is a label for time traveling.
*'^fv' does f in the temporal and spacial context of the last label.
==Examples==
 |+.(^-v)
This program demonstrates Timefuck's handling of the grandfather paradox. Using the many-worlds view of space-time, this program simply arrives at the . with the current cell 0 even though that value hasn't been created yet.
==Turing-completeness==
Any brainfuck program can be converted to Timefuck by replacing '[foo]' with '|(^foov)'.
:In Progress
==BF to TF Converter in Python (Golfed)==
 print(input().replace("[","|(^").replace("]","v)"))
Category:Low-level Category:Languages Category:Unimplemented Category:Uncomputable Category:Brainfuck derivatives Category:Cell-based Category:Output only Category:2009
Timelang

You have to wait to code
== Idea ==
time mod 8 determines what thing gets ran
 time%8 do
 0 add one to current cell
 1 sub one to current cell
 2 move one cell left
 3 move one cell right
 4 input to cell
 5 output from cell
 6 start while cell != 0
 7 end while cell != 0
that was time%8 to do table
== Syntax ==
you wait by specifying wait times
 0
 5
 3
 5
 3
 5
that was 123 program
Category:Languages Category:Cell-based Category:Brainfuck derivatives Category:Low-level Category:Turing complete Category:Unimplemented
Timeline of golfing languages

What follows is an attempt at a timeline of golfing languages. This timeline was mentioned from @lirtosiast, and User:A (the creator of this page) does not take credit for this timeline. None of these languages have been mentioned in the main timeline of esoteric programming languages, and it would make the page hard to read if these were added.
Any competitive golfing language should be mentioned here; uncompetitive golfing languages (such as a language that you recently created/a language that can not be golfed well) should not be mentioned here until its developer fixes that language.
== 2007 ==
The first golfing language was GolfScript. It was not suitable for code golf (e.g. abs was "abs", not even 1 byte). Once GolfScript was made, people on CGCC found there were significant improvements to be made.
== 2014 ==
And so aditsu wrote CJam.
isaacg (an experienced golfer) took years to develop Pyth, and it became dominant due to its prefix syntax.
== 2015 ==
After this, the next improvement was Jelly, which @Dennis probably came up with because he knew APL/J and CJam.
== 2017 ==
@tomtheisen came up with Stax; this introduced the string compression concept that is widely used in modern golfing languages.
== Since 2015 ==
Since then all competitive languages have had syntax based on solid principles, with tons of builtins that are generally well thought out.
== See also ==
* Timeline of esoteric programming languages
== External links ==
* List of golfing languages
Timesig

Timesig is a work in progress esoteric language by User:upbeatsarcastic.
== Premise ==
Timesig programs read like musical scores. The program pointer is called the BAR, the program tape is called the STAVE.
== Features ==
=== The STAVE ===
A Timesig program can never be infinite in length.
=== The BAR ===
The BAR acts as the program pointer. It reads from left to right across the source bars, which are defined like so:
 STAVE 32 | TEMPO 120
 %crescendo%
 $|4/4 e g f# b-f|a-a c-b-a-g d b:||
=== Commands ===
Timesig has 13 commands, one for each musical note and 1 repeat for loops.
 a
==See also==
Musical notes, another esolang based on music.
Timesplitter

Timesplitter is a esolang that has mutiple timeline which is unaviodable.
==Overview==
The code consists of some unordered notes. Here is the structure of each notes:
<condition 0> <condition 1> ... <action>
When more than 1 condition are met, random one will be choiced.
The memory stores by mes.
==me==
Every me has a clock that stores a integer and increase it every step, and a integer register that write-only to myself and read-only to other mes.
When the program start, it will create a me who has clock0 and register0 (or 0:0, clock:register), that me's time will go forward. Which means that me will create another me 1:0 on the timeline, the time will go on 1:0 too. For example:
 0:0 > 1:0 > 2:0 > 3:0 ...
(> shows the direction of time.)
==Cross-timeline note==
When a me do split. While time going, the me will also split another me that goes backward. For example:
Code:
 When 2 set 3
 When 3 split
World:
 0:0 > 1:0 > 2:3 > 3:3 > 4:3 > 5:3
 5:3 < 4:3 < 3:3 <┘
And we can get me's register now.
Code:
 When 2 set 3
 When 3 split
 When 4 set reg me{1}
World:
 0:0 > 1:0 > 2:3 > 3:3 >4:NaN>5:NaN
 5:0 < 4:0 < 3:3 <┘
When 4 set reg me{1} means if the clock is 4, then set my register to the register which is a me that has clock 1. That's why we got a me 4:0 (there's a 1:0) and a me 4:NaN (there's no 1:x)
==All the keywords==
Keyword 	Description
when <int> 	This condition met when someone's clock coincident with the param
see <selector> 	This condition met when there's at least 1 object coincident with the selector
see <me_selector> have <expression>	This special case will detect the register value of matched me, when there's more than one matched, it will OR the results up.
set <expression> 	This action will set the register to the expression
split 	This action will split another timeline which goes opposite
suicide 	This action will make the me suicide, and his/her timeline will shutdown
reclock <expression> 	This action will set the clock to the expression
add <a> 	Return a+b
sub <a> 	Return a-b
mul <a> 	Return a*b
div <a> 	Return a/b (the anwser is floored)
input 	This action will change the register value to the input immediately
nxtIN 	This action will move the input pointer for one char, the movement depends in logic order
output 	This action will output the register of the executor in global time order
Category:Works-in-Progress
Timing

Timing is a timing-based Brainfuck+2-derivative created by User:Evylah. It's very similar to Titled and Brainfuck+2.
== Code execution ==
In Titled, the programs are written inside of the file name. In Timing, the state of the program won't change between two different executions. Timing can only run one instruction at a time. Technically Timing has no syntax because you cannot type any instructions.
== Code writing ==
Running a Timing program can be very difficult. When run, the program will first retrieve the stored state of the last execution, then take the current unix timestamp and modulo it by 13. This will give a number from 1 to 12. It will then check for the number, run the instruction accordingly, and store the program state (memory, output and memory pointer), for the next time used.
== Instructions ==
unix timestamp % 13	Brainfuck+2 command	Function
1 	+ 	Increments the active cell by one.
2 	- 	Decrements the active cell by one.
3 	> 	Increments the memory pointer by one.
4 	< 	Decrements the memory pointer by one.
5 	[ 	If the active cell is 0, jump to the corresponding ]
6 	] 	If the active cell is not 0, jump to the corresponding [
7 	. 	Output the active cell as a Unicode character.
8 	: 	Output the active cell as a number.
9 	, 	Take a character as user input and store its Unicode value in the active cell.
10 	; 	Take a numerical user input and store it in the active cell.
11 	' 	Toggle overflow mode. When on (which is by default), numbers behave like standard brainfuck, wrapping on 0 and 255. When off, numbers can be any integer.
12 	r 	This one is not part of Brainfuck+2. This resets the program state.
The [ and ] commands will keep executing inside them. The loop body gets defined once [ gets hit, then when ] is hit everything inside will run. This means (I think) nested loops aren't supported, sadly.
TinyBF

tinyBF is a brainfuck equivalent with only 4 characters. It's a variant of RISBF and was created by Michael Gianfreda, Nov. 6, 2014. tinyBF programs are smaller than RISBF's. The motivation for creating tinyBF was to have four 2-bit commands in one byte of program memory.
Command	Description
= 	Switch direction (- ↔ +) (default: +)
+ 	Change data in selected direction. BF equivalents: - +
> 	Change cell in selected direction. BF equivalents: < >
| 	Jump in selected direction. BF equivalents: ] [
==Output==
Since switching the direction twice doesn't change anything, we can use this as the output function: ==.
==Input== 
The brainfuck endless loop [] can be used as input function: |=| if switch is positive, =|=| if switch is negative.
==Examples==
===Hello World===
 ++++++++|>++++|>++>+++>+++>+=>>>>+|=>+>+>=+=>>+|=>|>+|=>>==>=+++==
 =+++++++====+++==>>===>+==>===+++===++++++==++++++++===>>+==>++==
===Reverse input===
 +|>|=|=|>+=|+===>+|
==External resources==
* 
* Common Lisp implementation of the tinyBF programming language.
Category:Languages
Category:Cell-based
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Turing complete
Category:2014
Category:Low-level
Category:Implemented