nyuuzyou/wikis huggingface dataset:
Turing-machine

Turing-machine is invented by User:A.
==Syntax==
All of the rules look like this:
 currentCondition currentSymbol : nextCondition tapeHeadMoveDirection newSymbol
like:
 Q1:E<0
If the condition (state) is Q, and the number (symbol) on the tape is 1, the change the condition into E, change the tape into 0, and move left. 
The four available conditions are:
Condition	Remarks
Q 	 
E 	 
O 	 
F 	Represents the final state; when this condition is encountered the Turing-machine halts.
Numbers are:
Symbol	Remarks
0 	By default the tape's initial symbol.
1 	 
They are on the tape, which is written onto it in input.
When the Turing-machine halts, it prints the tape.
Directions are:
Direction	Effect
< 	Move the tape head one cell to the left.
> 	Move the tape head one cell to the right.
- 	Do not move the tape head at all.
==Examples==
===Truth-machine (Beta version)===
 Q1:E>1
 Q0:O>0
 E0:E>1
 O0:F<0
To make it print 1 forever, it changes the whole tape into 1s.
But, that still proves that is has halting, decision, repetition, input, and output.
===3-state Busy Beaver===
This is explained on Turing Machine.
See the pastebin website to see the code (because of technical limitations):
This 3-state busy beaver program generates six 1-bits on the tape:
 Q0:E>1
 Q1:O<1
 E0:Q<1
 E1:E>1
 O0:E<1
 O1:F>1
==Computational class==
A Turing-machine program trivially describes a Turing machine, but with very few states and symbols, and not one of the combinations known to be sufficient for Turing completeness. It is therefore not clear if it can simulate all of them, which is the deciding criterion. (Note that universal Turing machines include the initial tape as part of the setup to simulate other Turing machines, so it's not trivial to show that it is not Turing-complete, either. I don't know if anyone has proved it.)
==Interpreter==
* Common Lisp implementation of the Turing-machine programming language.
Category:Languages
Category:Unknown computational class
Category:2018
Category:Implemented
TuringLang

TuringLang is an esoteric programming language inspired by the Turing Machine created by User:AGO061. It uses a modern syntax to simulate Turing Machine behavior, making it compact yet challenging to read and interpret.
It provides features for tape manipulation, head positioning and state transitions with a customizable alphabet.
The original reference for the language can be found here
== Core Concepts ==
=== The Tape ===
The tape is a sequence of cells storing symbols from an alphabet (default: 0 and 1).
* The tape is initialized with the TAPE command.
* Users can modify its contents with additional commands like CUT and ELONGATE.
=== The Head ===
The head interacts with the tape by:
* Reading a cell's value.
* Writing to a cell.
* Moving left, right, or staying in place.
The head's starting position can be explicitly set.
=== The States ===
The states define the machine's behavior. For each symbol on the tape:
* The machine checks the symbol.
* Performs an action (write/move).
* Transitions to the next state or halts.
There are 2 important rules for states:
* There must be one and only one H state (HALT).
* There must be one and only one initial state.
== TuringLang Commands ==
=== Tape and Alphabet Initialization ===
* ALPHABET [<SYMBOL0><SYMBOL1><SYMBOL2>...] Set a custom alphabet for the tape.
* TAPE [<SYMBOL0><SYMBOL1><SYMBOL2>...] Initialize the tape with the specified symbols.
=== Head Positioning ===
* HEAD <N> Set the head position to the Nth cell (0-indexed).
* HEAD ^ Align the head visually using the ^ symbol.
=== State Definitions ===
* <STATENAME> <CHECK><WRITE><MOVE><NEXTSTATE>... <INITIAL?> Define states for the machine's operation.
=== Machine Execution ===
* RUN Execute the machine until a halt state or error occurs.
=== Tape Manipulation ===
* CUT START END Remove the tape contents between indices START and END (exclusive).
* CUT <CHARACTER> Remove the specified CHARACTER from the sides of the tape.
* ELONGATE [R/L] <CHARACTER> <LENGTH> Add CHARACTER symbols to the left (L) or right (R) of the tape.
=== Other Commands ===
* WIPE Clear all states in the machine.
* READ Output the current contents of the tape.
* # Add comments in your code.
== Interpreters ==
=== Python (Original) ===
The Python TuringLang interpreter is the original interpreter for TuringLang, developed alongside the language by User: AGO061.
== Additional Notes ==
=== Possible Changes ===
Unfortunately TuringLang is still in its early days (First release: Dec 15, 2024) which means there might be changes to the machine and tape functions (the core logic of the machine is already as it should be, so there's no need to change it currently). The Original Python interpreter will remain up-to-date with the possible new changes.
Category:Languages Category:2024 Category:Cell-based Category:Implemented
Turing (Iamcalledbob)

==Syntax==
Turing is designed to have a very lightweight, readable, intuitive syntax. Here is the entire Hello World! program in Turing with syntax highlighting:
 put "Hello World!"
Turing avoids semicolons and braces, using implicit end markers for most language constructs instead, and allows declarations anywhere. Here is a complete program defining and using the traditional recursive function to calculate a factorial.
 % Accepts a number and calculates its factorial
 fun factorial (n)
 if n = 0
 result 1
 else
 result n * factorial (n - 1)
 
 fun loop()
 get n
 if n < 0
 put "The factorial of ", n, " is ", factorial (n)
 result n
 else
 result loop()
 
 loop()
Category:Languages
Category:2018
Category:Unimplemented
Turing Completer

Turing Completer is a theoretical language capable of generating a Turing Completeness Proof for any language. There are 2 variations for this language, one which could theoretically be implemented (Potential Completer) and one which is impossible to implement (Omnipotent Completer). It was created by user:Bertrahm.
== General Overview ==
Both forms of the Turing Completer only have one instruction which is
 Generate Proof For <Language Name>
In the case of the Potential Completer, it would have to be provided information about the language via a Program Argument containing the path to a file containing the languages information.
== Potential Completer ==
The Potential Completer would only be able to generate a Turing Completeness Proof for languages in which it is actually possible. For this it would require a set of the language's instructions, their behaviour and syntax along other rules.
Implementing this would theoretically be possible, although it would be hard.
== Omnipotent Completer ==
The Omnipotent Completer would be impossible to implement for 2 main reasons:
# It would only require a language's commonly adapted name to generate a Turing Completeness Proof
# It would be able to create proof that would always work for languages where it would be impossible like Anarchysm.
The second point makes the Omnipotent Completer paradoxical, since it would be able to generate proof that would always work for a language like Anarchysm, where the language "does what it wants".
== Computational Class ==
Perhaps surprisingly, Turing Completer is itself Turing Complete. Simply consider the class of languages defined like "Brainfuck except [ first computes <some Turing Machine> and skips the loop unless it halts in an accepting state".
Category:Languages Category:Unimplemented Category:Concepts Category: Turing complete
Turing Paint

Turing Paint is a visual esoteric programming language in which programs are represented using images. Six colors can be used: black, white, red, green, yellow, and blue. It is designed to be easy to learn and images can be created using any graphics editor. Programs can be hand-drawn without the need for any pixel fine-tuning. Programs can be run directly on the Turing Paint website.
==Computational class==
Turing Paint is Turing-complete.
==External resources==
* Turing Paint website
Category:Languages
Category:Implemented
Category:Two-dimensional languages
Category:Non-textual
Category:Turing complete
Category:Turing tarpits
Category:2020
Turing Script

Turing Script is an esoteric programming language by User:SuperJedi224. Execution is built around a single universal Turing machine that has been augmented with additional input capabilities. A program consists of a main script and a collection of turing machine programs and predefined data tapes, each in a separate file located in the same directory. (Data tapes and turing machine programs may be placed in subdirectories of the main directory, but in that case, the main script must specifically import those subdirectories before they can be used)
==External resources==
*Specifications
*Example Programs
Category:Turing complete
Category:Languages
Category:2015
Category:Unimplemented
Turing Tumble

Turing Tumble is a mechanical computer created by Paul Boswell in 2017, operated by marbles. It is targeted for education, but with a big enough board could allow to build any contraption and is Turing Complete.
Marbles move down the board by gravity, controlled by 6 types of parts you can add to the board. When a marble hits the bottom, a new marble from the top is released. Two types of marbles can be released, blue or red.
Part 	Function
ramp 	moves the marble left or right
crossover 	allows marble to keep moving
interceptor	stops the program
bit 	toggle between left and right state and sends marbles in alternating directions, operates like a T flip-flop
gear bit 	bit that can be connected with gears, this component makes it Turing complete
gear 	connects gear bits
==External resources==
* Turing Tumble kickstarter page with video explanation 
* Emulator in JavaScript 
Category:Languages
Category:Implemented
Category:Cell-based
Category:Non-textual
Category:Two-dimensional languages
Category:Low-level
Category:Turing complete
Category:2017
Turing machine

A Turing machine is an imaginary machine devised by Alan Turing which performs computations. It consists of a finite-state automaton (often called its "control mechanism" or program) hooked up to an unbounded tape which can be moved to the left and right, from which symbols can be read, and onto which symbols can be written.
A universal Turing machine is a Turing machine which can be given a description of any arbitrary Turing machine encoded in some form, initialized on its tape, and the finite state machine operates on the description in such a way that the described machine is simulated. Universal machines are named for the fact that they can compute any computable sequence.
Turing machines are computationally significant because, while many systems of computation have been shown to be able to solve only a subset of computation problems that a given Turing machine can solve, no system of computation has ever been shown to be able to solve a computation problem that a Turing machine cannot.
In addition, no well-defined algorithm has yet been devised that a universal Turing machine is demonstrably incapable of executing. This has led to the Church-Turing thesis, which states (roughly) that Turing machines are mechanical embodiments of (what we think of intuitively as) effectively computable algorithms. That is to say, a Turing machine can make any sort of calculation that it is possible to precisely define an algorithm for.
Since the invention of Turing machines in Alan Turing's paper, many other systems have been shown to be equivalent to them. (In fact, several of these systems, such as the lambda calculus, combinatory logic, and Post canonical systems, predate the Turing machine.) In this way, Turing machines define a computational class of equivalent systems; these systems are termed Turing-complete.
For all these reasons, it is often an interesting and/or valuable task to show that an esoteric programming language is (or is not) equivalent to a Turing machine.
==External resources==
* See Turing machine on Wikipedia
* Turing Machine Language - A Turing Machine interpreter in python
* Visual Turing Machine - animated Turing machine simulator
* On Computable Numbers, With an Application to the Entscheidungsproblem - the paper in which Turing introduces his machine
* Boolos, G. and Jeffrey, R., Computability and Logic, 2nd ed., Cambridge: Cambridge University Press, 1980.
* Online Turing Machine Simulator
* Another simulator
Category:Computational models
* Yet another simulator
* Turing Machine Simulation Language
Turing number

THIS IS A WORK IN PROGRESS. IT WILL NEVER END BEING ONE, AS INFINITE THINGS CAN BE SAID ABOUT IT.
A Turing number is the concept of numbering the operations of a a machine like aTuring machine, but doesnt read any data. For example, a Turing machine that moves Left and writes a 0, in System Number 1, will be called 18. The author hopes that this page WILL NOT have billions of derivatives, like Brainfuck. Evidently, it is Turing-complete. Even more importantly, every language is its derivative!
It is called Turing number not because it was developed by Turing, but because it is related to Turing machines. Actually, they where created by User:Singingbanana, but you understand that Singingbanana number does not sound good!
===System Number 1===
Left is 1, Right is 2. Erase is 3. Writing a zero is 8, meanwhile writing a one is 9. This system was the first made up, just to illustrate the concept. A trivial definition in a language is:
L -> 1
R -> 2
O -> 8
Z -> 9
The program you just saw is written in a standard format for all Turing numbers, which you can call TNDL, or TNML. The author prefers to call it Subset, but he does not know why.
===Subset/TNDL/TNML===
Subset is very simple. We assign a 'meaning' to one these: L, R, O and Z. They mean: Left, Right, One(Write one) and Zero(Write Zero). The arrow mean 'is equal to'.
===System Number 2===
More intuitive that System Number 1, this may help beginners to understand Turing Machines.
L -> >
R -> <
O -> 0
Z -> 1
===System Number 3===
Just plain simple.
L -> 1
R -> 2
O -> 3
Z -> 4
===System Number 4===
This requires an addition to the Turing number rules. A command can be equivalent to a couple of commands smashed together.
LO -> 1
RO -> 2
Category: Computational models
Category: 2018
Turkey

Turkey is a derivative of Chicken. It was created by User:ResU in 2021.
==Commands==
Opcode 	Description
1 	Prints "turkey".
2-27 	Prints the (opcode-1)th letter.
28 	Prints a space.
29 	Asks for input and stores it to 43.
30-39 	Prints the (opcode-30)th number.
40 	Is an if statement.
41 	Is an equals sign.
42 	Is an infinite loop. Another 42 will close the loop.
43 	Is the only variable.
44-infinity	Is (opcode-44).
==Examples==
===Hello, world!===
turkey turkey turkey turkey turkey turkey turkey turkey turkey
turkey turkey turkey turkey turkey turkey
turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey
turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey
turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey
turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey
turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey
turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey
turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey
turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey turkey
turkey turkey turkey turkey
===Quine===
turkey
===Truth machine===
The opcodes for the truth machine are shown below.
29
40
43
41
44
30
40
43
41
45
42
31
42
==Implementations==
This Turkey Interpreter Is A work in progress.
Category:2021
Category:Languages
Category:Unknown computational class
Category:Implemented
Turning tarpit

A turning tarpit is a form of Turing tarpit in which there is a sequence of commands, modeled as a rotating wheel. In a turning tarpit, language commands do not directly manipulate data, but instead affect the command wheel(s), by changing their rotation or executing the current command.
== Overview of the Genre ==
The earliest example of a turning tarpit in the world of esoteric programming languages is probably reMorse (1998). Whirl (2004) embraces the technique most explicitly, styling itself as "dizzy programming". Fortuna (2005 or earlier) is probably the first turning tarpit to use the image of a wheel. Wunnel (2011) applies the turning tarpit technique to the problem of designing a 1L, and expands on the idea by using a two-dimensional torus of instructions instead of a one-dimensional wheel. Braincrash (2011) is a brainfuck equivalent. Jolverine (2012) is a conscious attempt to expand the turning tarpit genre by introducing a new feature: modifying the order of instructions on the wheel during execution. Advance The Wheel! (2022) expands the genre in a different way, by having control flow commands affect the wheel position rather than the instruction pointer.
==See also==
* All Turning tarpits on this wiki
* Laughing my ⁫ off, turning but not tarpit.
Category:Concepts
Turnip

Turnip is a programming language for the 2D terminal-based Turing machine sim, Turnip. Turnip code defines the starting configuration of a machine, possible states and operations performed before switching states. Many operations can be done, inspired by Turing Kara.
== Programming Turnip ==
A .turnip file starts with a grid representing the initial state of the sim.
A grid is made up of only 0s 1s and .s (representing a blank cell).
e.g.
 ......
 .0101.
 .1100.
 ......
That is followed by the start state and start coordinates in the form 
state(x, y). Coordinates on the grid start with (0,0) in the top left, which 
will be familiar if you have worked with screen coordinates. i.e.
 012 x
 0...
 1...
 2...
 y
=== Simple Example ===
The logic for each state comes last. To explain this we will work through a 
simple demo machine that simply goes right flipping every 0 to a 1 and every
1 to a 0, stopping when it sees a ..
 flipper {0 1>flipper|1 0>flipper|. _}
flipper is the name of this state. Inside {} we have the responses to each 
possible output, 0, 1 or ., separated by |. Let's break down the first
response 0 1>flipper. We start with the input 0, then the actions, 1 (to 
write a 1), and > (to shift right once). Then we end with flipper, the 
new state of the machine.
In the third response there are no actions and we end on the state _, which
represents the HALT state.
Category:Languages Category:Two-dimensional languages Category:Implemented
Turth-machine

Turth-machine is a simple pseudo-code programming language created by User:A.
==Syntax==
Ask for <variable> 	Accept then store input into <variable>.
If the <thing A> <condition> <thing B> 	Compares <thing A> with <thing B>. A bullet point and indentation must be added.
is 	A condition keyword meaning "equals", i.e. used in the previous statement in the <condition> slot.
Output <value/variable> 	Print either a value or a variable to the console.
Whereas if <thing A> <condition> <thing B>	Compares <thing A> and <thing B> if the last if statement is false. A bullet point and indentation must be added.
Repeat <value> 	Repeat anything in the loop value times. Same bullet point and indent.
infinitely 	A value that is infinite in size.
==Examples==
===Truth-machine===
 Ask for input
 If the input is 0
 Output 0
 Whereas if input is 1
 Repeat infinitely
 Output 1
===Hello World===
 Output "Hello World"
===Cat===
 Ask for input
 Output input
===Cat until no input===
Never halts, just stops asking for input if you enter a blank input. Note the space at the end of line 3.
 Repeat infinitely
 Ask for input
 If the input is 
 Repeat infinitely
 If the 1 is 2
 Output 0
 Output input
Category:LanguagesCategory:2018Category:High-levelCategory:UnimplementedCategory:Pseudonatural
TurtleDigits

TurtleDigits is an esoteric programming language that is built on top of turtle. It only uses the digits 1-9 for commands.
== Commands ==
Usually commands take the next number as an argument
* 1 - Move forward (up)
* 2 - Move backward (down)
* 3 - Move left
* 4 - Move right
* 5 - Turn an amount of degrees
* 6 - Toggle pen off/on (does not require arguments)
* 7 - Change the color
* 8 - Shuffle the next commands
* 9 - Repeat the next commands amount of times (requires 2 arguments)
=== Color values ===
* 0 - Black
* 1 - Red
* 2 - Green
* 3 - Blue
* 4 - Yellow
* 5 - Magenta
* 6 - Cyan
* 7 - Orange
* 8 - Brown
* 9 - Pink
== Examples ==
=== Hello World ===
13 21 41 11 23 H
6 41 6 Letter space
13 41 6 21 6 31 22 41 E
6 41 6
13 23 41 L
6 41 6 
13 23 41 L
6 42 6 
13 31 23 41 31 O
6 44 6 Word space
13 23 41 11 21 41 13 23 W
6 41 6 
13 41 23 31 O
6 42 6
13 41 21 31 56 929 54 42 32 56 925 952 985 58 R
6 42 6
22 13 23 41 L
6 41 6
13 59 924 41 59 924 42 59 924 41 D
==== Output ====
=== Circle ===
11 59 944 979
=== Random curve generator ===
84 1234 969 999
==== Output(s) ====
== Interpreters ==
* In Python by NikiTricky
Category:2022
Category:Graphical_Output
Category:Output only
Category:Implemented
Category:High-level
Turtle just want to dig

Turtle just want to dig is a esolang based on how when User:Yayimhere(the creator of the esolang) was sitting with his turtle and it just began digging.
== how it works ==
the program is a grid set up like this:
 ñ
 ===
 # #
heres how it works:
* ñ is the turtle and moves to the right and digs when it can deleting the ground it digs. when it hits the edge of the program it turns 180 degrees. A program can have multiple turtles and if they collided they turn 180 degrees. After the turtle has dug a single row it moves back up to the surface
* = is the ground. the turtle moves over it. its the top layer of the ground. If there is a non diggable ground underneath if wont be dug
* # is non diggable ground. if its underneath The turtle when it digs it cant dig down into that space
* õ is a bug. If the turtle is above it it checks:
:* if there is a space left of the bug the bug moves to that space
:* if there is a space to the right of the bug it moves to that space
:* if there are no spaces to the left or right the turtle moves down into it destroying it
:* if there are space to the both left and right AND the below space is a space it will move down into it
:* however if there is not an space to move into, the bug will be deleted
* > is a right. when the turtle lands on dis it moves right until it gets to another hole(where there are only empties up to above ground), then it goes to above ground. it halts if there are none
it will halt if it gets out of bounds. so the above example becomes:
 
 = =
 # #
 ñ
The program halts if the turtle goes to a row or column that there are no commands on
== extension ==
there is two extensions. the first one is the binary extension
=== binary extension ===
this extension will output the binary version of the grid every iteration. a conversion happens like this:
* first print the first row in binary and a newline
* then the second
* and so on
a 1 will be there if the space is anything else than a space. a 0 is just a space. so the example program will print:
 100
 111
 101
at the start of the program. and the halting iteration will print:
 000
 101
 101
 010 
=== the printing extension ===
this extension will print any char the turtle lands on thats not a command. that char will also be ignored.
== examples ==
infinite loop also an oscillator:
 ñ
 ==
 ##
or and expanding one which is also a Looping counter starting at 3 counting the number of spaces
 ñ
 ===
 # #
 õ
 
Category:Languages Category:Thematic Category:Two-dimensional languages