nyuuzyou/wikis huggingface dataset:
Temporal logic

Temporal logic is a system of logic that deals with logic as a function of time. Variables can be true sometimes but not always, and you can define when this happens, and you can tell it whether or not to do so, et cetera.
== Paths ==
Temporal logic can be either linear or branching. In linear temporal logic, the state of the program is a definite timeline. In branching temporal logic, on the other hand, state follows a tree.
== Operators ==
Operator	Meaning
xUy 	Until: x holds until y doesn't anymore (and may hold after)
xRy 	Release: ???
Nx 	Next: x must hold at the next state
Fx 	Future: x must hold sometime in the future
Gx 	Global: x must hold for the entirety of the subsequent path (like future, but forever)
Ax 	All: Behaves like Global for ALL paths (x must hold on all paths from the current state).
Ex 	Exists: x holds on at least one path from the current state
Tenglish/commands

print - prints
 download - downloads a file
 make new variable called a - makes new variable
 a is b - sets a to b
 if else - if else
 while - while
 random number between a and b - random number from a to b
 a is b c d - sets a to bcd, where c is an operation. see operations at tenglish/operations
 user input - input
 make new file called a - makes new file
 make new folder called b - makes new folder
 put a into b - puts file a into folder b
 i love wikipedia - ends the program, because when you lie, everything stops
TenneC

Tenne-C is a joke language based on the concept of translating C-isms into hillbilly-speak. For instance arguments are known as feuds. Programming in Tenne-C involves lots of bad puns.
==External resources==
* http://www.netfunny.com/rhf/jokes/88q3/0tenny.html
Category:Languages Category:Joke languages Category:Thematic Category:Pseudonatural
Ternareso

Ternareso is an esoteric language taking inspiration from Brainfuck, but focussing on nested ternary statements to implement control flow and looping.
The name is a portmanteau of Ternary and Esoteric.
The Java interpreter and in depth README can be found on github
==Concept==
The language can be described as a single Ternary with the form 
 <preamble>?success:failure
The preamble is a list of operations as defined below, and the success/failure paths are themselves Ternaries. The ?success:failure section can be omitted to create a simple list of actions in the preamble.
A Ternary is executed by first running the preamble. If the Ternary is a test Ternary (i.e. it has the optional ?success:failure section), then the ? operator indicates testing if the state of the current address on the tape is 0. If the value is 0, the success Ternary is executed, else the failure Ternary is executed.
The program state is represented by an array of integers - the tape - and the current address on the tape. The tape doubles in length when attempting to move beyond the right-hand side, and negative addresses are not supported.
Operators
+ - Increment the value at the current memory address.
- - Decrement the value at the current memory address.
< - Move the pointer one address to the left.
> - Move the pointer one address to the right.
\ - Return 1 level. A single \ indicates that the current ternary will be re-executed, multiple slashes will iterate up the tree. If there are more slashes than layers, the program will exit.
All other characters (barring ? and :) are ignored.
==Examples==
Hello World:
 H++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 e>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 l>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 l>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 o>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 >++++++++++++++++++++++++++++++++
 W>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 o>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 r>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 l>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 d>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Adding Cell 1 to Cell 0:
 +++++>++++?<\\:?<\\\:-<+>\
Ternary

Ternary is an esoteric programming language created by zerosum0x0 in 2015. It consists only of the ASCII characters 0, 1, and 2. It is a member of the TrivialBrainfuckSubstitution family of programming languages.
==Commands==
Brainfuck	Ternary 	Description
> 	01 	Move the pointer to the right
< 	00 	Move the pointer to the left
11 	Increment the memory cell under the pointer	
10 	Decrement the memory cell under the pointer	
. 	20 	Output the character signified by the cell at the pointer
, 	21 	Input a character and store it in the cell at the pointer
[ 	02 	Jump past the matching 12 if the cell under the pointer is 0
] 	12 	Jump back to the matching 02
==Examples==
===Hello, world! program===
 11111111111111110201111111110201111101111111011111110111000000001012011101110110010111020012
 00101201012001101010201111111111111120201111112001012000102000201111112010101010101020101010
 1010101010200101112001111120
===Cat program===
The following demonstrates an infinitely repeating cat program which terminates if encountering the null character.
 2102202112
==External resources==
* GitHub - Ternary Programming Language
* Common Lisp implementation of the Ternary programming language.
Category:Brainfuck equivalents
Category:Cell-based
Category:Joke languages
Category:Turing complete
Category:Implemented
Category:Low-level
Category:2015
Category:Brainfuck derivatives
Category:Turing tarpits
Category:Languages
Tetanus

Tetanus is a language of regular expressions and suffering. Its name was inspired by its agonizing design and difficulty of use, similar to doing surgery with a rusty hacksaw.
==Language overview==
A program in Tetanus consists of a regular expression on the first line, a replacement string on the second, and a data string consisting of all the lines afterwards. If there are no lines after the second, the data string is initially blank.
Before execution, the replacement string is checked for ~ or ` characters after group references. They are recorded, then all of them are removed from the replacement string.
If the regular expression matches the data string, all matches are replaced with the replacement string. For each marked group, if the group referred to is not null, something is done: for ~, the text captured by the group is outputted with no newline afterwards, and then for `, a line of input is appended to the end of the data string. This is repeated until the regular expression fails to match.
==Implementation notes==
Python escape sequences in the replacement string are supported. The regex Python package is used for parsing regular expressions, therefore Tetanus uses its regex flavor.
==Programs==
===Hello, world!===
 ^(H.+)
 !\1~
 Hello, world!
===Cat program===
(Note the blank lines at the end)
 ^(\n)$|(\n)(.+)$
 !\1`\3~`\2~
 
 
===Truth-machine===
 ^(!)$|^(!!)(0)$|^(!!)(1)$
 \1\1`\2\2\3~\4\5~
 !
===Quine===
(Note the blank line at the end)
 (?s)^(?!!!)(!*)(.+)
 !\1\2~
 (?s)^(?!!!)(!*)(.+)
 !\1\2~
 
===Palindromic quine===
 (?s)^(?!!!)(!*)(.+?\n)(@)|^(?!!!!)(!*).+?\n(@.+)
 !\1\2~\3\4\5~
 (?s)^(?!!!)(!*)(.+?\n)(@)|^(?!!!!)(!*).+?\n(@.+)
 !\1\2~\3\4\5~
 @
 SUP YA GOOFS
 SFOOG AY PUS
 @
 ~5\4\3\~2\1\!
 )+.@(n\?+.)*!()!!!!?(^|)@()n\?+.()*!()!!!?(^)s?(
 ~5\4\3\~2\1\!
 )+.@(n\?+.)*!()!!!!?(^|)@()n\?+.()*!()!!!?(^)s?(
==Computational class==
Tetanus is Turing-complete, since it can simulate Bitwise Cyclic Tag with this program: 
 ^([^>]+?)(\n)(.+)$|>(0)([01]*)(\n)[01]([01]*)\n*$|>(1)([01])([01]*)(\n)(1[01]*)\n*$|>(1[01])([01]*)(\n)(0[01]*)\n*$|^([01])([01]*)>(1)(\n)(1[01]*)\n*$|^([01])([01]*)>(1)(\n)(0[01]*)\n*$|([01]+)>(\n)
 \4\8\9\13\17\22>\1\2\3~\2~\5\6\7~\6~\10\11\12~\9~\11~\14\15\16~\15~\18\19\20\21~\17~\20~\23\24\25\26~\25~\27\28
 insert BCT program here
 insert BCT data string here
Category:2022
Category:Implemented
Category:Languages
Category:String-rewriting paradigm
Category:Turing complete
Category:Turing tarpits
Tetra

Tetra is a string-rewriting esolang invented by User:Hakerh400 in 2022.
== Definitions ==
A group is a list of other groups.
== Syntax ==
Group is represented by parentheses encapsulating its content (the list of groups).
List of groups is represented by the concatenation of the groups from the list (no separators between them).
Source code consists of a list of groups. It represents the main list that gets rewritten.
== Rewriting rules ==
In each step, find the first (left-most, outer-most) group g from the main list that contains an empty group as its first element. Replace g by two copies of itself with the first inner group (the empty one) removed.
Repeat this step until no more replacements are possible.
The output of a program is the total number of groups in the final list.
== Example ==
We show the computation steps of the program (()(()())). We omit the leading empty groups of the main list for simplicity. Each time an empty group appears at the beginning of the main list, it stays there and adds to the number of the groups that will be counted at the end.
 (()(()()))
 ((()()))((()()))
 ((())(()))((()()))
 (()()(()))((()()))
 (()(()))(()(()))((()()))
 ((()))((()))(()(()))((()()))
 (()())((()))(()(()))((()()))
 (())(())((()))(()(()))((()()))
 (())((()))(()(()))((()()))
 ((()))(()(()))((()()))
 (()())(()(()))((()()))
 (())(())(()(()))((()()))
 (())(()(()))((()()))
 (()(()))((()()))
 ((()))((()))((()()))
 (()())((()))((()()))
 (())(())((()))((()()))
 (())((()))((()()))
 ((()))((()()))
 (()())((()()))
 (())(())((()()))
 (())((()()))
 ((()()))
 ((())(()))
 (()()(()))
 (()(()))(()(()))
 ((()))((()))(()(()))
 (()())((()))(()(()))
 (())(())((()))(()(()))
 (())((()))(()(()))
 ((()))(()(()))
 (()())(()(()))
 (())(())(()(()))
 (())(()(()))
 (()(()))
 ((()))((()))
 (()())((()))
 (())(())((()))
 (())((()))
 ((()))
 (()())
 (())(())
 (())
The output is 32, because that many empty groups appeared at the beginning of the main string (we do not show them to save space).
== Implementation ==
Implementation in Haskell:
<nowiki>
type N = Integer
infixr 0 #
(#) = id
src :: String
src = "(()(()()))"
run' :: [N] -> N
run' xs = case xs of
 [] -> 0
 (x:xs) -> let
 (ys, _:zs) = break (== x - 1) xs
 in 2 ^ run' ys + run' zs
run :: String -> N
run = run' . tail . scanl
 (\n c -> n + if c == '(' then 1 else -1) 0
main :: IO ()
main = print # run src
</nowiki>
Category:Languages
Category:Implemented
Category:Total
Category:2022
Category:String-rewriting_paradigm
Tetrastack

Tetrastack is a stack-based esoteric programming language. Each stack has its own pop behavior. It's the 1st esolang of TS Series by User:GUAqwq
== Overview ==
There are four stacks of integers. Stacks are referenced by numbers from 0 to 3.
Source code consists of hexadecimal digits. Each digit represents an instruction. The two upper bits represent the stack which an element will be popped from, while the two lower bits represent the stack which the element will be pushed to.
For example, BD7A corresponds to 23 31 13 22, which in interpreted as
* Pop from stack 2 and push to stack 3
* Pop from stack 3 and push to stack 1
* Pop from stack 1 and push to stack 3
* Pop from stack 2 and push to stack 2
Popping from stack 0 increments the value of the popped number (before pushing to the new stack). Popping from stack 1 decrements the value. Popping from stacks 2 or 3 does not change the value.
If you ever try to pop from a empty stack, it will crash down immediately.
== Special cases ==
Instruction F (pop from 3; push to 3) is special. It pushes number 0 to stack 2.
A loop starts with an instruction that pops from stack 3 (and pushes to any stack except 3), and ends with instruction A (pop from 2; push to 2). When a number is popped from stack 3, if it is 0 then jump past the matching instruction A (the end of the loop). Otherwise execute the loop. When A is reached, jump to the matching loop start. Loops can be nested.
In summary, special instructions are A and all instructions that pop from stack 3.
==I/O==
The inputs/outputs correspond its ASCII.
The end of the inputs is the top of stack0. (the end of the stack0 is a extra -1
The top of stack3 is the start of outputs.
== Computational class ==
Tetrastack is Turing complete because any brainfuck program can be translated to Tetrastack using the following conversions:
 Start of the program: F97F963D63AF94F95F8F803DF803DF803DF803DF803DF803DF803D007A7A7A7A7A7A7A16F833DD
 7A4FBFBAD7F94F8BFD7082AF8A
 
 End of the program: F9FC3FBAEC3FBAABDBA43D743A
 
 < → 21595F833DD7A4FBFBAD7F94F8BFD7082AF8A
 > → 40F833ED7A4094FBFBAD7F95F8BFD7082AF8A
 + → F832157CD7A8FBFBAD78F8A
 - → F8317ED7A094FBFBAD71F8054A
 , → BF8383DD7A6FBFBAD7F96FA3D7A3D7AEFBAF8BFD7082AF88B16D7F832157CD7A8FBFBAD78F8AA
 . → 3F8FD7082A15497
 [ → 17C
 ] → 17AF8
== Examples ==
=== Cat program ===
 3D73A
=== Hello, World! ===
 FFBF9F9F9F9F9F9F9F9F9F9F9F9F9F9F9F940140140140140140140140143D4040140140140143D404014014040140140140
 4014014014040115151515543AF94040140401405404040143D1543AF915543AF94040FF843D508243A1540555FF843D5082
 43A15B401401401401401401401FF843D508243A15BFF843D508243A15B401401401FF843D508243A154040FF843D508243A
 15B155FF843D508243A1515FF843D508243A15B401401401FF843D508243A15B555555FF843D508243A15B55555555FF843D
 508243A154040401FF843D508243A15B40401401F8CABDBAF17E17AB111744BBB117B400000000003443BBB3
== Interpreters ==
* Interpreter written in Haskell by User:Hakerh400
Category:Languages
Category:Stack-based
Category:Turing complete
Category:Implemented
Category:Turing tarpits
TextGarbage

TextGarbage (previously named Gibberish but that's already taken) is an esoteric programming language created by User:Dominicentek. It's commands are only 1 character long making the code look like gibberish.
== Instructions ==
Instruction	Parameters 	Description
v 	<variable> <value> 	Creates a variable and sets a value to it
i 	<variable> 	Creates a variable and assigns user input to it
o 	<value> 	Outputs value as an ASCII character
n 	<value> 	Outputs value as a number
m 	<variable> <value> <operation> <value>	Performs a Math operation with 2 values and assigns it to a variaible
x 	 	Exits the program
c 	<value> <comparsion> <value> 	Performs an IF statement. If it returns true, a code block is executed
e 	 	Ends a code block
f 	<function> 	Assigns a code block to a function variable
r 	<function> 	Runs a function
l 	<label> 	Creates a label variable
g 	<label> 	Goes to a label (goto)
Invalid instructions are ignored.
=== Parameter Types ===
variable, function and label are variable names. Each variable name is named with just one character. When you define a variable type as c, you will define it, but you can't access it due to the character being used for marking constants.
value can either be a constant or variable. If it includes c at the beginning, it's marked as constant and the value after it will be used for that constant. Otherwise, it's a variable that does not have any extension. If a constant is not a number, it's treated as a character ASCII value.
operator is a Math operator. It can be:
* a - Add
* s - Subtract
* m - Multiply
* d - Divide
* r - Division remainder (modulo)
comparsion is used as a comparsion operator for IF statements. It can be:
* e - Equal
* n - Not equal
* g - Greater than
* l - Less than
== Examples ==
=== Hello World ===
ocHoceocloclocooc,oc ocWocoocroclocdoc!
=== Truth Machine ===
ixcxec1llnc1glenc0
=== Calculator ===
i1ioi2mac7mc6maaac1msc9mc5mmc7mc6mdc7mc7mddsc2mrc5mc7mrrac2coeam11a2ecoesm11s2ecoemm11m2ecoedm11d2ecoerm11r2en1
== Interpreter ==
Download
== See also ==
* Gibberish (programming language)
Category:Implemented Category:Languages
Text Binary

Text binary is a programming language first created by User:Star651 in early 2006 but never written about until November 13, 2022. The concept of text binary is very simple; Text Binary is simply a binary file that has been converted into the textual representations of 0 and 1 (ASCII values 48 and 49); originally the language was designed for eight-bit computers so each line consisted of eight digits, but a more "practical" interpreter these days would convert 32-bit executables into lines containing 32 digits, and 64-bit executables into lines containing 64 digits, though the eight-bit version can probably still be used to encode text files, and the sixteen-bit version can probably still encode more advanced text files containing characters from other languages; the sixteen-bit version can probably also encode standard sixteen-bit wav files and such. The point of Text Binary is that when you open up a Text Binary file in a text editor, you actually see the sequence of zeros and ones on your screen. This is what young children (what Star651 was in early 2006) expect to see when they open a binary file in a text editor; strings of zeros and ones on the screen. But obviously what they will actually see is what appears to be nonsense symbols; the binary interpreted as text. Well, if this file is run through a Text Binary decompiler, it will be converted to actual text featuring the numbers 0 and 1. So in a way the German compiler and decompiler could just be rewritten, so instead of the words SCHNITZEL and BEER they would be the actual numbers 0 and 1. So basically like a hex dump, but with the binary digits instead of hexadecimal digits.
Category:Languages
Category:2022
Category:Unimplemented
Text lines are cool

Text lines are cool is an esolang made by Unname4798. Unlike in Lines are cool, the boxes have to be exact.
== Boxes ==
Start and end:
 |-----|
 |start|
 |-----|
 |---|
 |end|
 |---|
Print a string (or a number):
 |----------|
 |print 2024|
 |----------|
 |------------------|
 |print string: kiwi|
 |------------------|
User input:
 |-----|
 |input|--
 |-----|
If/else:
 |------------|
 | |--
 |if 2024<2106|
 | |--
 |------------|
Variables:
 |---------| |---------|
 |var acc 0|--|print acc|
 |---------| |---------|
 |---------------------| |----------|
 |var name string: John|--|print name|
 |---------------------| |----------|
Functions:
 |------------------------|
 | var and func x y: |
 | |
 | |---------| |-------| |
 | | |--|print 1| |
 | |x * y > 0| |-------| |
 | | |--|print 0| |
 | |---------| |-------| |
 |------------------------|
 
 |--------| |-----|
 |func 1 0|-|print|
 |--------| |-----|
 
 |--------| |-----|
 |func 1 1|-|print|
 |--------| |-----|
Category:Languages Category:Two-dimensional languages
Texter

Texter uses text to code
== Commands ==
 a*b
concatenates a and b, if a was ab and b was c, it would result in abc
 a/b
remove instances of b in a, if a was abc and b was bc, it would result in a
 !a
reverses the order of the letters in a, if a was abc, the result would be cba
 \a
escapes a, if a is a symbol, escape it, else do nothing to a, if a was *, it would result in * as a text, not a symbol
 a^b
reverses a and concatenates a and b, if a was ab and b was c, the result would be bac
 a=b
if a and b are the same, turn it into a, else turn it into _, if a was a and b was a, it would result in a
 a-b
if a and b are not the same, turn it into a, else turn it into _, if a was a and b was a, it would result in _
 a>b
if a is _, turn it into b, else keep it as a, if a was _ and b was abc, it would result in abc
 a<b
if a is not _, turn it into b, else keep it as a, if a was _ and b was abc, it would result in _
 (a)
group a for no ambiguity
== Unary increment ==
 A*~
 A is the input
Textual SUBLEQ

Textual SUBLEQ is a programming language that's similar to Subleq but it uses strings instead of integers.
==Operation==
Each line is of the format:
[words]: [word] [word] [word] [words]
The first words are a "label". The next two words are variable names and their values are "subtracted": all occurrences of the second value in the first are removed. The value of a given variable can be found as follows: go to the line whose label contains that name (only one can exist) and take the ending "words" located there (these also change when the variable is changed.) Anyway, the difference between the variables is stored in the first variable. Then, if the first variable is now empty, jump to the line whose label contains the third word (there, of course, can only be one in any given program.) Output isn't defined by default but could be added as an extension.
Category:Languages
Category:OISC
Category:Low-level
Category:Languages
Tg

== Introduction ==
Tg is a postfix-expression programming language created by User:SteloKim. It is, as yet, incomplete.
Tg is quite simple. A Postfix program consists of a list of operators and operands.
Tg uses lazy evaluation and type inference.
== Types ==
Example 	Type
3 	Int
3.0 3. rand	Float
"Hello" 	String
== Functions ==
Symbol 	Function
a b +
a b -
a b *
a b /
a b = 	Returns (a+b), etc.
a b +.
a b -.
a b *.
a b /. 	Returns (a+.b), etc. (Float type)
a b car 	Returns a.
a b cdr 	Returns b.
condition then-part else-part ?	if expression
a display 	Displays the item a to the standard output.
newline 	Displays a new line to the standard output.
expression parameter \ 	Returns an anonymous function. Only one parameter is allowed.
rand 	Returns a random number [0.0, 1.0].
== Usage ==
* Compile to a.out:
tgc test.tg
* Compile and run:
tgrun test.tg
* Compile the standard input and run:
tgi
== Examples ==
10 20 + display newline;
1 1 = 2 0 / 3 cdr 10 ? display newline;;
"Hello, world!" display newline;;
3 x 2 * x \ display newline;;
3 4 x y + y \ x \ display newline;;
"Tg" "Hello, " display str display ; "!" display ; newline ; str \ ;
 
=>
30
3
Hello, world!
6
7
Hello, Tg!
== Implementation ==
Currently, Tg is implemented in OCaml. It produces an OCaml code as an intermediate language and then compiles it to get a binary.
Tg compiler source code
Tg compiler source code(20080616)
Tg compiler source code(20121113)
Category:Languages
Category:Implemented
Category:2008
Th

Th is an esoteric programming language consisting of one named pair of values, created by User:Scan in 2008. A value is again either a named pair or an atom. Is it similar to Lisp, but the length of a list is fixed. Thus, a pair represents an atomisable value itself, meaning a pair is just a thing to be evaluated. Eventually, a Th program is pretty simple.
== Types ==
Th is not type-safe. Every atom is seen as an atom. The programmer is supposed to watch what they're typing.
== Predefined pairs == 
Pair name	Description
+(,) 	Arithmetic addition
*(,) 	Multiplication
-(,) 	Subtraction
/(,) 	Division
print(,) 	Prints the values
read(,) 	Evaluates to an atom read from the keyboard, prints left before and right after input
let(x,v) 	Defines x</codE> as a constant that has the given value in the containing pair
More to come (I appreciate suggestions).
== Examples ==
=== Hello, world! ===
 print("Hello, ", "World!")
This is equivalent to:
 print("Hello, World!", nil)
=== Addition ===
 print("a + b = ", +(read("a = ", "\n"), read("b = ", "\n")))
Category:Languages
Category:2008
Category:Functional paradigm
Category:Total
Category:Unimplemented
Category:High-level
Category:Unusable for programming