nyuuzyou/wikis huggingface dataset:
Your Time Is Up

Your Time Is Up is a string-rewriting esolang by User:PythonshellDebugwindow.
==Syntax and Semantics==
Programs in Your Time Is Up are in binary, composed entirely of 1s and 0s. They all match the regular expression ((?:(1+0)(1+0)([10]{N})([10]{M}))*)0([01]*). Let's go through this in more detail (the meanings of N and M will be explained).
((?:(1+0)(1+0)([10]{N})([10]{M}))*)
This is the main part of the program, where the rewriting rules are.
(1+0)
A series of 1s followed by a 0. The amount of 1s is important; let's call the amount N.
(1+0)
Another series of 1s followed by a 0. The amount of 1s is still important; let's call the amount M.
([10]{N})
A binary sequence of length N (see above). Specifies a part of the binary string to replace (a p‑string).
([10]{M})
Another binary sequence, this time of length M (see above). Specifies the replacement (an r‑string) for the part of the binary string specified previously (see directly above).
(?:...')*
Zero or more rewriting rules can be written in a program.
0([01]*)
If the first character in what would otherwise be (1+0) is 0, the rewriting section is ended immediately and the rest of the program is interpreted as the initial binary datastring.
Execution consists of picking, from the list of rules, a random rule whose p‑string exists as a substring somewhere in the datastring, and replacing that substring by the rule's r‑string. This goes on until no rules can be applied, at which point the program ends.
==Computational class==
Translation to a version of Thue with no IO can be achieved easily enough. Simply encode the datastring in binary using ASCII. The ::= rule can be replaced with 0. Since all Thue rules are finite in length, and therefore can be encoded in a finite amount of 1s, Your Time Is Up is Turing-complete.
Category:Languages Category:2020 Category:Unimplemented Category:String-rewriting paradigm Category:Turing complete Category:Probabilistic Category:Nondeterministic
Your stack may be eaten

Your stack may be eaten is an esolang by User:BoundedBeans, developed entirely on the wiki in an hour. The stack has the potential to be eaten into the code, so watch out.
==Execution==
Run the commands from first to last. After every command, “eat” a character from the stack and put it on the end of the code. The stack being eaten is the only way to do loops or conditionals. 
==Storage==
It only has a stack, though there is a stack pointer for arbitrary access. Conceivably the code is also storage, but it is very difficult to “access” the data, since it will only be executed.
==Syntax==
All characters until the exclamation point are the code. After the exclamation point is the contents of the stack, with the first character being the top. On both parts, any non-command characters are ignored. This means the stack may only have valid commands. It also means the input and output can only work with the characters v^$:/{}_@[, meaning you'll likely have to encode it in some way and have the user decode it manually.
==Instructions==
Note: There is no way to create stack elements of a character that does not already exist in it, so all characters you want on the stack should be in the initial stack state in the syntax.
 v - take the currently pointed cell, push it to the stack
 ^ - delete the currently pointed cell
 $ - pop
 : - take the currently pointed cell, make a copy and put it below
 / - swap the currently pointed cell with the one below it
 { - move the stack pointer up
 } - move the stack pointer down
 If either of the curly brackets would go outside of the stack, do nothing
 _ - input a character and insert it below the stack pointer. If not a valid instruction, insert ^
 @ - output the currently pointed character, removing it
 [ - push the contents of the entire stack to the stack
==Examples==
===Print out infinite v’s===
 [v@![v@
==Implementation==
There is an implementation on the talk page.
Category:Languages
Category:Stack-based
Category:Self-modifying
Category:Implemented
Ypsilax

Ypsilax, invented by Chris Pressey in 2001, is a reflective (i.e. potentially self-modifying), non-deterministic esoteric programming language based on grid-rewriting. Both the program and its state are rendered as symbols in a grid; in this manner, rules may rewrite the state, other rules, or both.
==Program form==
Each Ypsilax program is an unbounded two-dimensional grid of cells, each of which can contain a single symbol from a finite alphabet.
The rewriting rules in an Ypsilax program are two-dimensional structures located in this grid. Each of these is delimited by parentheses above and to either side of it; also, it must be twice as wide as it is high. For example, a rewriting rule which rewrites A symbols to B symbols:
 ( )
 AB
A critical property of these rewriting rules is that they will only rewrite things below them; never above or on the same line. In this manner, a hierarchy of rewriting rules can be formed, some of which rewrite other rewriting rules. For example, the following rule would rewrite the above rule into a different rule:
 ( )
 ( )( )
 AB CD
 
 
(Note that this rule is in fact eight cells wide by four cells high, even though the bottom two lines are filled with blanks.)
==Computational class==
Ypsilax is Turing-complete because it can directly implement an arbitrary Turing machine. The Turing machine tape can be represented using two adjacent rows of the grid: the top row represents the symbols (where the "blank symbol" that fills the unvisited potion of the tape is represented by an Ypsilax blank symbol), and the bottom row specifies the state and the location of the tape pointer: it is mostly blank, but the symbol directly below the location of the tape pointer is a non-blank symbol specifying what state the Turing machine is in. Each non-halt Turing machine transition then compiles into a number of rewrite rules equal to the number of symbols: there is one rule for each symbol it could be moving onto, because although that symbol is meaningless to how the Turing machine operates, it exists within the 2×2 bounding box of the machine's output, and thus a rewrite rule is needed for every possible value of that symbol. (Halt transitions are left out of the compilation, so that the Ypsilax program has no matching rewrite rules at that point.)
For example, the 2-symbol 4-state busy beaver Turing machine:
 	A 	B 	C 	D
0	1→B	1←A	Halt	1→D
1	1←B	0←C	1←D 	0→A
compiles to the following Ypsilax program:
 ( )( ) ( )( ) ( )( ) ( )( ) ( )( ) ( )( ) ( )( )
 1 111 1 1 11 1 111 1 1 1111 1 111 1 1 1111 1 11 1
 A B A B BA BA D D D D AB AB BC BC CD CD D A D A
 
 A
==External resources==
* 
Category:Languages
Category:Two-dimensional languages
Category:Self-modifying
Category:Turing complete
Category:Nondeterministic
Category:Implemented
Category:2001
Z

Z is a programming language developed by User:Challenger5 in April - May 2016, which uses only lowercase and capital Z, space, and newline. It is essentially assembly code with several modifications. It is based on "words" of up to 3 of the letter Z. Each word has sub-words separated by spaces, which combine to create a statement. Statements are separated by newlines. However, statements can also be separated by double spaces, and are treated as one line by the "zzz" and "zzZ" commands. Note that the case of the Z matters.
It uses a preparing number system to make it easy to interpret because the author was lazy. The system works using several commands that "prepare" a number, and other commands use the prepared number as input. It was partially inspired by brainfuck for the idea of a number table with cells. However, the language is much easier than it.
== Syntax ==
z - accepts input, stores in variable A
Z - outputs variable A
zz - puts values in A
 z - puts fixed value based on digits. Multiple words are multiple digits.
 z - one
 Z - two
 zz - three
 zZ - four
 Zz - five
 ZZ - six
 zzz - seven
 zzZ - eight
 zZz - nine
 zZZ - zero
 Z - gets value at index of A on number grid. Stores in A.
zZ - move pointer to index A.
Zz - replace number at pointer with A.
ZZ - change number at index of pointer
 z - increase number by A
 Z - decrease number by A
zzz - jump to line A
zzZ - jump to line A if value at pointer is 0
The following code is a Hello World program (printing out ASCII values):
zz z zzz Z Z
zz z z zZZ z Z
zz z z zZZ zzZ Z Z
zz z z z z Z
zz z zz Z Z
zz z zzZ zzz Z
zz z z z z Z
zz z z z zZ Z
zz z z zZZ zzZ Z
zz z z zZZ zZZ Z
zz z zz zz Z
A cat program:
z Z
A truth-machine:
z Zz
zz z zZ zzZ
zz z z Z zz z zz zzz
zz z zZZ Z
A Fibonacci program:
zz z zZZ Z
zz z z zZ Zz
zz z Z zz Z
ZZ z Z
zz z Z zZ
zz z z zz Z
ZZ z Z
zz z z zZ
zz z zz zzz
== External Links ==
* Implementation
Category:Languages
Category:Implemented
Category:2016
Z++

Z++ is the language that from C++.
== Syntax ==
See also C++.
== Programs ==
=== I/O ===
==== Hello, world ====
 #引入头文件<iostream>
 使用 命名空间 标准库;
 整型 主函数()
 {
 输出流<<"Hello, world!"<<换行符;
 返回 0;
 }
=== Variables ===
==== A+B Problem ====
 #引入头文件<bits下的stdc++.h>
 使用 命名空间 标准库;
 整型 a, b, c;
 整型 主函数()
 {
 输入流>>a>>b;
 c=a+b;
 输出流<<c;
 返回 0;
 }
==== 99 Bottles of BEERS ====
 #引入头文件<bits下的stdc++.h>
 #引入头文件<windows.h>
 使用 命名空间 标准库;
 字符串 unit="bottles";
 整型 主函数()
 {
 重复执行(整型 i=99; i>0; i--)
 {
 输出流<<i<<" "<<unit<<" of the beers on the wall, "<<换行符
 输出流<<i<<" "<<unit<<" of the beers."<<换行符;
 输出流<<"Take one down, pass it around, \n"<<i-1<<" "<<unit<<" of the beers on the wall."<<"\n\n";
 等待(1000);
 }
 输出流<<"No more bottles of beer on the wall, \nno more bottles of beer.";
 输出流<<"Go to the store and buy some more, \n99 bottles of beer on the wall.";
 返回 0;
 }
Category:2024 Category:Unimplemented Category:High-level Category:CJK
Z3

The Z3 is a German computer created by wikipedia:Konrad Zuse in 1941. Despite its extreme simplicity (the computer simulated only addition, subtraction, multiplication, division, and square-rooting), wikipedia:Raúl Rojas has successfully simulated a universal Turing machine using this computer by literally gluing the ends of the punched tape together so that a program can run in a single loop.Rojas, R. (1997a). However, without this looped program contrivance, Rojas states "the Z3 is ... no universal computer in the sense of Turing".Rojas, R. (1997b). The Architecture of Konrad Zuse's Early Computing Machines
== See also ==
* Blindfolded Arithmetic
== References ==
==External resources==
* Konrad Zuse Internet Archive
Category:Computational models
Category:Before 1993
Category:Turing complete
ZALIBY

ZÁLIBY is a simple programming language created as part of a programming competition run by students at Charles University. An implementation can be found here
== Overview ==
ZÁLIBY is a stack-based language. The stack can contain an unlimited number of integers in the range 0 to 32767.
Typing a sequence of numbers causes it to be pushed to the stack. To push two separate numbers next to each other, separate them with a space.
== Commands ==
a is the first value popped, b is the second. Commands popping two values always operate on b first, so 2 1 - is 1
Instruction	Description
+ 	Pops two values, pushes b + a
- 	Pops two values, pushes b - a
* 	Pops two values, pushes b * a
/ 	Pops two values, pushes b / a
= 	Pops two values, pushes 1 if b = a, otherwise 0
< 	Pops two values, pushes 1 if b < a, otherwise 0
; 	Pops one value, pushes a twice
. 	Pops one value, prints (value of) a
== Conditionals ==
Conditionals take the format ? actions_if_true : actions_if_false !. When the ? is reached, if the top of the stack is nonzero the first set of actions will be taken, otherwise the second set. After the relevant actions have run, execution continues from the !
== Loops ==
A while loop takes the format [ test @ actions ]. First, the "test" will be executed, then, if the top of the stack is nonzero, the "actions" will be executed and the loop will be repeated. If the test results in the top of the stack being zero, execution will continue from the ]
== Examples ==
Print numbers from 10 to 100 in steps of 10:
10 [; 110 < @ ; . 10+]
== External Links ==
* Original specification (in Czech)
Category:Languages
Category:Implemented
Category:Stack-based
Category:Output only
ZOMBIE

ZOMBIE, according to its author David Morgan-Mar, stands for Zombie-Oriented Machine-Being Interface Engine and was designed for necromancers, particularly evil ones.
Programs are run in a multithreaded environment where every kind of entity (zombie, vampire, ghost, demon or djinn) acts in a slightly different way. A program is a list of entity declarations stating the action that each entity must perform.
== External resources ==
* Interpreter (mirror in the Esoteric File Archive).
* ZOMBIE language description
* Interpreter updated to Python 3.
Category:Languages
Category:Implemented
Category:Thematic
Category:2004
Category:High-level
ZOWIE

ZOWIE is an assembly-like esoteric programming language designed by Chris Pressey between summer and winter of 2009.
The primary design goal of ZOWIE was for control flow to be both structured (i.e. not using explicit jumps or labels) and memory-mapped (triggered by reads and writes of registers.) This design goal was inspired by Jeffry Johnston's attempt to reduce the number of instructions in BitChanger by memory-mapping the loop operation.
The main challenge in meeting this design goal was that memory-mapping a loop structure like while requires some way to jump to the end of the loop -- but if the end of the loop is defined by when some memory location is changed, rather than when some point of the program text is reached, it is not possible to always detect it statically (by Rice's Theorem.)
It took several attempts to find something that worked (and it is not clear that this approach could be carried over to BitChanger.) Once it was clear that this was possible, it was decided to memory-map all operations in ZOWIE, so there is only one instruction, MOV, with a handful of forms.
==Syntax==
ZOWIE's syntax is similar to that of SMITH. There are five instruction forms:
 MOV register, immediate e.g. MOV R8, 141
 MOV register, register MOV R8, R9
 MOV [register], register MOV R[R8], R9
 MOV register, [register] MOV R8, R[R9]
 MOV [register], [register] MOV R[R8], R[R9]
Unlike SMITH, the closing square bracket is purely for decoration -- R[R8 is equivalent to R[R8], while R2] is equivalent to R2.
==Computational class==
The "Computational class" section of ZOWIE's documentation
demonstrates that a brainfuck interpreter can be
implemented in ZOWIE; it follows that ZOWIE is Turing-complete. 
==External resources==
* 
* ZOWIE reference distribution on Codeberg
Category: Languages 
Category: Implemented
Category: Low-level
Category: Turing complete
Category: 2009
ZTOALC L

== Control flow ==
A ZTOALC L program starts with a line containing a positive integer, followed by a number of lines containing instructions. There is an instruction pointer (IP), which is initially the number at the first line of the program. Until the IP becomes 1, the following is repeated: The instruction at line IP is executed (if this instruction exists), and consecutively IP is either divided by 2 if it is even, or it is multiplied by 3 and increased by 1 if it is odd.
== Expressions ==
ZTOALC L has two types of values, namely integers (of unlimited size) and arrays (these arrays can contain both integers and other arrays). Now there are a few possible expressions:
input 	The expression input will read one character from the input, and evaluate to its ASCII value.
variable 	Variables will evaluate to their value.
number 	Numbers will evaluate to their value, for example -29 will evaluate to -29.
[size] 	where size is some expression evaluating to a number. [size] will create a new array with size size.
array[index]	where array is some expression evaluating to an array and index evaluates to some number. This will evaluate to the item at position index in the array array.
== Instructions ==
The following instructions can be used:
print expr 	where expr is some expression evaluating to a number between 0 and 127. This will print the character corresponding to this ASCII value.
jump if expr	where expr is some expression evaluating to a number. If this number is zero, nothing happens. If the number is however non-zero, then IP will be increased by 1, and it will not be divided by 2 or multiplied by 3 and increased by 1 after this.
lhs = rhs 	where lhs and rhs are both expressions. This will put the value of rhs into lhs. If lhs is a name that was not defined yet, this will also define a variable with this name.
lhs += rhs 	where lhs and rhs are both expressions evaluating to numbers. This will increase lhs by the value of rhs.
lhs -= rhs 	where lhs and rhs are both expressions evaluating to numbers. This will decrease lhs by the value of rhs.
== Examples ==
===Hello, world!===
 18
 print 10
 print 87
 print 33
 print 114
 print 32
 print 108
 print 100
 print 101
 print 111
 jump if 1
 print 111
 
 print 108
 
 print 108
 
 print 72
===Truth-machine===
 6
 jump if m
 m = n
 print n
 m -= 48
 n = input
==Implementations==
A Python interpreter by User:Bangyen.
Category:Languages Category:2018 Category:Implemented
ZZT-Flip

Category:Languages
Category:2018
Category:Two-dimensional languages
Category:Reversible computing
Category:Self-modifying
Category:Implemented
ZZT-Flip is a variant of BackFlip that User:Zzo38 implemented with ZZT.
The commands are:
* A variant of the BackFlip arrows, where instead of the arrow now pointing where you came from, they point into the direction you were moving in (the opposite direction from BackFlip).
* A ricochet which reverses the direction of program execution when hit.
* Empty space (NOP).
The program can be reversed by reversing the direction of program execution and also reversing all arrows.
==Implementing in ZZT==
* The initial point of the program is a bullet.
* The arrows are a empty or fake or water with the same stats like a bullet; i.e. having cycle 1 and the direction set.
* The ricochet is a ZZT ricochet.
Because the stats are executed in order, once a bullet moves into the space with the other stat, now that stat is executed now that it is a bullet it can do something, which is to move away; the original stat from the original bullet remains, but which is no longer a bullet.
Note that in ZZT it is actually possible for the direction of a stat to be any pair of integers (X delta and Y delta), rather than only having to be the four ways (although directions other than these four cannot be added using the built-in editor of ZZT, but it is possible with ZZTQED).
Z Sharp

Z Sharp (Z#), is an interpreted procedural programming language created by user:Sam-astro in 2022. The Z# interpreter was written in C++, and was inspired by the popular languages: C#, Python, and Java.
== Features ==
* Programs use higher level syntax
* Z# has a fully functioning interpreter; see External Links at the bottom.
* If and while statements
* Types include: int, float, bool, string, along with extra Vec2, Sprite, and Text. All of these are builtin to the interpreter, but will be recreated in Z# once classes are implemented.
* Functions can return any type, and their input variables can also be of any type.
=== Example snippet: ===
func Main() // the main method is the start of the program.
{
 print "Print text to the console with this!"
 int i = 10 // semicolons are not required.
 while i > 0 // brackets for statements have been removed
 {
 i -= 1
 print "Hello " + i + " more times!"
 }
 // foreach and for loops do not exist in Z#, but can be easily emulated using a while loop.
}
=== Syntax ===
You can declare a variable with its type, then name, followed by a set operation (=), and its value:
int x = 10
Declare a function with the func keyword, then name, and parenthesis with input variables inside:
func Name(arg)
{
 print arg
}
==External Links==
*Source code
*Youtube video
*Install
Category:Languages Category:Implemented Category:High-level Category:2022
Z mjhkh

Z mjhkh is made by User:Yes and stands for Zebra milk just hidkh (Zebra milk just idk)
Z mjhkh's compiler is very fast. So fast, that computers are known to explode because it requires at least 500 Ghz to not explode.
The documentation only outpuuts after compiling, and User:Yes gave himself anmeisa when he was done with the compiler, so we dont know the details.
Category:Languages Category:Joke languages Category:Unknown computational class Category:Usability unknown
Zed

== Zed Language ==
Zed is a language consisting of a total of 32 distinct symbols. A program consists of commands, as well as nested loops, scopes, threads, variables, and functions. Each scope has a single stack of which infinite signed long numbers may be added to. A memory value is also present.
Labels may be used for definitions or calls.
Symbol	Action
+ 	Increment Memory By 1
- 	Decrement Memory By 1
? 	Pop From Stack
! 	Push To Stack
% 	Get Stack Size
. 	Output Unicode Character
, 	Input Unicode Character
: 	Restart Execution
; 	Complete Execution
* 	Delay Milliseconds
< 	Initiate New Thread
> 	End Thread
( 	Repeat Equal to Value or Variable
) 	End Repeat or Variable
[ 	Repeat Until 0 or Function
] 	End Repeat or Function
{ 	New Scope Block
} 	End Scope Block
# 	Export Memory To Child Scope
& 	Import Memory From Parent Scope
/ 	Max Long Value
\ 	Reset Memory Value
= 	Modify Execution Position
" 	Get Execution Position
' 	Set Execution Position
~ 	Opposite of Value
` 	Exit Program
$ 	Toggle Debug Mode
@ 	Get Scope Depth
 	Get Milliseconds Since
^ 	Access Parent Scope
_ 	Access Child Scope
Variables, scopes, and threads are computed immediately. Functions are saved. A function call runs that bit on the current scope. A scope call becomes the current scope. Variable calls replace the value.
This language is a work in progress, but here are some of the very programs that work on the fully functional Java interpreter.
Program 	Description
++++((+))+.+.+. 	Print ABC
+[,!]?%(?.) 	Reverse Input
dbl[(+)] ++++dbl dbl dbl dbl+.+.+.	Function Example
Category:LanguagesCategory:Stack-basedCategory:Unknown computational classCategory:Brainfuck derivativesCategory:ImplementedCategory:2019
ZenoCodR

ZenoCodR is a visual and literal language for creating interactive application. It has an integrated community for sharing and remixing projects, self-contained Scripts contained within Sprites.
==Syntax==
Commands are specified by parenthesis in the Code view, and blocks in the Block view.
List of commands:
text
do
comment
repeat
summon
forever
if
function
message
set
get
increment
speak
image
add
subtract
multiply
divide
remainder
floor
join
audio
play
wait
call
import
export
step
glide
look
touching
key
web
random
greater
less
equal
and
or
not
index
letters
length
where
abs
sqrt
ceiling
sin
cos
tan
asin
acos
atan2
log
exponent
array
at
clickedHere
clicked
timer
mouse
json
unjson
clone
unclone
===Sample code===
(comment(Welcome! View https://wiki.zenoverse.net/w/index.php/Zenoblockly_Wiki for in-depth tutorials on how to use Zenoblockly. Additionally, source code is available at https://git.zenoverse.net/Zenoblockly))
(set(text(costume))(image(text(./example.svg))))
(summon
 (do
 (forever
 (do(play(audio(text(./example.mp3)))))
 )
 )
)
(summon
 (do
 (forever
 (do(set(text(size))(multiply(get(text(size)))(text(1.001)))))
 )
 )
)
Category:Implemented
Category:Languages
Category:2024