nyuuzyou/wikis huggingface dataset:
WinReg

WinReg is an esoteric programming language created by User:Dominicentek. It's syntax is similar to his other language called FolderCode. Instead of it being a folder structure, it is a tree of keys and values in the Windows Registry.
== Initialization ==
In HKEY_LOCAL_MACHINE/SOFTWARE, create a key called WinReg, and put all of your programs in there. To make a program, simply make a key and the program will be that key.
== Commands ==
All commands, exactly like in FolderCode, are indexed with numbers.
Command 	Value Type	Parameter 	Description
var 	SZ 	Variable name 	Set open variable/create a new variable
assignstr 	SZ 	Variable value	Assigns a string value to an open variable
assignint 	DWORD 	Variable value	Assigns an integer value to an open variable
assignfromvar	SZ 	Variable name 	Assigns a value from a variable to an open variable
user 	SZ 	Variable name 	Assings user input to a variable
if 	KEY 	Variable name 	Compares an open variable with a variable
else 	KEY 	None 	If the above if statement returns false, this gets executed instead
print 	SZ 	Variable name 	Prints variable value into console
add 	SZ 	Variable name 	Adds a number to an open variable
sub 	SZ 	Variable name 	Subtracts a number from an open variable
mul 	SZ 	Variable name 	Multiplies a number in an open variable
div 	SZ 	Variable name 	Divides a number in an open variable
mod 	SZ 	Variable name 	Modules a number in an open variable
loop 	KEY 	Variable name 	Loops inside code a number of times in a variable and stores its loop amount into an open variable
random 	SZ 	Variable name 	Assigns a random number to an open variable based on the range
delay 	SZ 	Variable name 	Delays the code for a number of milliseconds
function 	KEY 	Function name 	Defines a function
callfunc 	SZ 	Function name 	Calls a function
toint 	SZ 	Variable name 	Converts a string variable to an integer
tostr 	SZ 	Variable name 	Converts an integer variable to a string
exit 	ANY 	None 	Exits the program
On KEY types, the parameter acts as the type's default value.
== Examples ==
=== Hello World ===
┏ var text
┣ assign Hello World!
┗ print text
=== Truth-machine ===
┏ user input
┣ toint input
┣ var one
┣ assignint 1
┣ if input
┃ ┣ function printone
┃ ┃ ┣ print one
┃ ┃ ┗ callfunc printone
┃ ┗ callfunc printone
┗ else
 ┣ var zero
 ┣ assignint 0
 ┗ print zero
=== Fizz Buzz ===
┏ user input
┣ toint input
┣ var zero
┣ assignint 0
┣ var three
┣ assignint 3
┣ var five
┣ assignint 5
┣ var fizz
┣ assignstr Fizz
┣ var buzz
┣ assignstr Buzz
┣ var newline
┣ assignstr \n
┣ var loopamount
┗ loop input
 ┣ var threereminder
 ┣ assignvar loopamount
 ┣ var fivereminder
 ┣ assignvar loopamount
 ┣ var threereminder
 ┣ mod three
 ┣ var fivereminder
 ┣ mod five
 ┣ var threereminder
 ┣ if zero
 ┃ ┗ print fizz
 ┣ var fivereminder
 ┣ if zero
 ┃ ┗ print buzz
 ┣ var threereminder
 ┣ if zero
 ┣ else
 ┃ ┣ var fivereminder
 ┃ ┣ if zero
 ┃ ┗ else
 ┃ ┗ print loopamount
 ┗ print newline
== Interpreter ==
Download
Category:2021
Win Golf

Win Golf is a language made by SnakeyKing and is created to help people win coding golfs.
 Commands
Command 	Description
h 	Writes "hello" on the console
H 	Writes "Hello!" on the console
w 	Writes "hello world" on the console
W 	Writes "Hello World!" on the console
q 	Writes "q" on the console (can be used as a quine)
b 	Writes the lyrics of 99 bottles of beer on the console
f 	Makes a forever loop that does nothing
i 	Asks for input
I 	Asks for input infinite times
c 	Executes the cat program
C 	Executes the cat program infinite times
t 	Truth Machine
{e} 	Writes the numbers `1` to `e` with an increment of `1`
{s}_{e} 	Writes the numbers `s` to `e` with an increment of `1`
{s}_{e}_{i}	Prints the numbers `s` to `e` with an increment of `i`
=== Hello World ===
 W
=== Quine ===
 q
=== Cat Program ===
 C
Category:Languages
Category:Golfing language
Category:2023
Window

Windows is a programming language that uses windows like Google x: to code
== Windows ==
 Example x:
 LINK EX2
 ]
 EX2 x:
 Hi
 GOBACK
 ]
 comments:
 Example links to EX2
 that means if the user opened example, it would do the stuff in it,
 LINK is the goto command which goes to a 
 different window, use REDIRECT 
 to instantly do that, use GOBACK to go back,
 if there is no keyword behind it, it prints it, when it reaches ],
 the program does GOBACK, if 
 there is no more places to go back to, it halts the program
== User actions ==
 HELLO x:
 Hello
 ]
 USER:
 open HELLO
 wait
 comments:
 open [window] opens a window
 wait waits a step
 close [window] closes a window
 click clicks
 maybe [DO] maybe do do or maybe do wait
 look look at the screen
 if saw [text]:
 [do]
 ] if saw text in this step, do do
 or:
 [do]
 ] if after a maybe command, do this when the maybe doesn't run, if after an if, do this when the if doesn't run
 if user:
 [do]
 ] if the user of this program, not the USER: part, clicks, then run [do]
 user commands take first presence, then window commands
== More window commands ==
 STORE [text] IN [window] store the text in the window
 GETDATA get the data in this window
 IF CLICK:
 [DO]
 ] if user clicks at this command, do do
 IF [val] IS [text]:
 [DO]
 ] if val is text, do do
 SHOW [text] show text
 HIDE [text] hide text
 CLOSE [window] closes window
 DOWNLOAD [text] INTO [file] puts text in a file
 UPLOAD TEXT FROM [file] returns text from a file
== Example ==
 Clickorelse x:
 IF CLICK:
 CLOSE [Clickorelse]
 ]
 DOWNLOAD you got a virus INTO virus
 ]
 USER:
 open Clickorelse
 maybe click
 comments:
 this will give you virus if you do not click immediately
Category:Languages Category:Thematic
WindowGolf

WindowGolf is like Drive-In Window but insanely short. It was created by User:BoundedBeans. 
Programs follow this format:
(entrees).(sides).(order)
==Entrees and sides==
Entrees follow the format [price][name]. The price excludes the zero, and the name knows to start and end depending on whether the next character is a letter. Sides are the same as entrees, but the price includes all digits. Multiple entrees/sides are separated by commas.
==Order==
Order is a ton of instructions, not separated by commas. The format is [instruction][person number][menu item]. Any irrelevant fields are removed. The Person N needs X dollars more/less for his order! instruction is special, and features an extra number for X preceded by + for more, and - for less. The Person N would like what Person X has. instruction is also special, and precedes X with * for normal, & for "would also like", and ! for "would not like". Menu items work the same way. "With" the side item is represented with an additional &, and "Hold" the side item is represented with an additional !.
Person N would like menu_item (with side_item). 	~
Person N will pay for his order! 	:
OK, what should Person N get? 	;
OK, how much money should Person N have? 	@
Let's just do this until Person N has no more money!	[
Person N has no more money! 	] (this does not need an argument for N)
Person N needs X dollars more/less for his order! 	>
Person N would like what Person X has. 	<
Just wait while we decide... 	?
==Examples==
===Cat===
 1Cat Food..~1Cat Food[1;1:1]
===Truth-machine===
 5Vodka.2Truth Serum.@1[1~1&Vodka!Truth Serum[1:1]]~1&Vodka!Truth Serum:1?
Category:Languages
Category:Cell-based
Category:Thematic
Category:Finite state automata
Category:2022
Category:Unimplemented
Category:High-level
Windows 1.0

Windows 1.0 is a version of Brainfuck made by Mihai Popa but based on names of programs from Windows 1.0. Commands are 1 per line only.
== Table ==
Command 	Brainfuck equivalent	Description
Paint 	> 	Move the pointer to the right
Notepad 	< 	Move the pointer to the left
Terminal 	+ 	Increment the memory cell at the pointer
Clock 	- 	Decrement the memory cell at the pointer
Write 	. 	Output the character signified by the cell at the pointer
Calendar 	, 	Input a character and store it in the cell at the pointer
Calculator	[ 	Jump past the matching Reversi if the cell at the pointer is 0
Reversi 	] 	Jump back to the matching Calculator if the cell at the pointer is nonzero
Everything other than these above is a comment and it's ignored. But if you comment with these, it's executed as a command and it's a error.
==Examples==
===Hello, World!===
Quite long, but I can show here (compressed with WinRAR as ZIP and encoded in Base64)...
UEsDBBQAAAAIAFyPu1g6V2hqewAAAKwFAAAJAAAAaGVsbG8udHh0C0ktys3MS8zh5aIOyzkxJ7k0J7Ekv4iXKyAxM68EWZI6LL/8ktSCxBSgXTn5ydm8XEGpZalFxZk0sy+8KLMklQqmD1iADVzAQoOOqvFAjJlDIc6oFdpQr0JNoSoFNRruUmwMKGOg0iwpyQBKkZKASA4rCoMa1aVozgEAUEsBAh8AFAAAAAgAXI+7WDpXaGp7AAAArAUAAAkAJAAAAAAAAAAgAAAAAAAAAGhlbGxvLnR4dAoAIAAAAAAAAQAYAPOWNWZGsNoB4281Zkaw2gFuNwVmRrDaAVBLBQYAAAAAAQABAFsAAACiAAAAAAA
Here's the KZIP version:
UEsDBBQAAgAIAF2Pu1g6V2hqeAAAAKwFAAAJAAAAaGVsbG8udHh0zZOxCoNgDIT3QJ7KvRQpdA42Q2j0lxh9/i7ZWrp4otOFDJfjO/LQGG0SZ8JMnfiwumQLprvYlEzoE7eWOsuLqfM2vJl63TQWO+zeMywV4A4Gdn2whQ7aQ8nFOjuPdvEoF7CUdSX9M+AR41+3pJZgqjtr+Jn0K84HUEsBAhQAFAACAAgAXY+7WDpXaGp4AAAArAUAAAkAAAAAAAAAAAAgAAAAAAAAAGhlbGxvLnR4dFBLBQYAAAAAAQABADcAAACfAAAAAAA
===Rickrolling, by printing all the lyrics of "Never Gonna Give You Up"===
TOO long. See here: Windows 1.0/Rickroll
===99 Bottles Of Beer===
Too long. See here: Windows 1.0/99 Bottles Of Beer
==Computational class==
Windows 1.0 is turing-complete because Brainfuck, Numberfuck, Hanzifuck and Mariofuck are also turing-complete!
Category:Languages
Category:Turing tarpits
Category:Low-level
Category:Cell-based
Category:Unimplemented
Category:Brainfuck equivalents
Category:Brainfuck derivatives
Category:2024
Category:Turing complete
Windows 1.0/99 Bottles Of Beer

Windows 1.0 <--- Back to the main page!
This program in Windows 1.0 prints all lyrics of the song 99 Bottles Of Beer. It's derived from this: Mariofuck/99 Bottles Of Beer which in term is also derived from this: , originally in Brainfuck. It's 27.2 KB uncompressed but the powerful KZIP program squashed to ONLY 651 bytes! WOW! Here is attached (encoded as Base64, BTW):
UEsDBBQAAgAIALKSu1g2IjruDwIAANxsAAANAAAAOTlib3R0bGVzLnR4dO2cQUvEMBCF7wv7q7yLiOA5rDkU61Zq9ffrIQgmbIYmzUxqv9MM2Dbp9E36tu+ZBzdcl/MphCc/vw1XN7bM7tx4+RzdMs0/+ThdXs+nW5O4nxb/7l4yicaU4/k9+i8/fwx6A4YqydUIh/6t8e+10pA+iwQJRQ8nVCgzTPr84vJmp5peL5xlBhX7jOx5HhYfELFRINxYOYR+owPpwAaBDhRCMQlr360rVpAAI+nWFG/XuhjdNHfxiZWLg3C6dF4hZ5S59j/k0NULjUmvdtq/W6Jx3a+czPPjJQIw62lbAbTBGWQlHNQZsZGBC3BZIO0XOvDSP3IafgfJXFoAJsA86ls5gkdDCMj4rfvdZEIMLNqqf0zJRbHlbpm5I3uSIboIgYDsSUYHInsieyJ7InsieyJ7InsiRyF7IntCVpA9FSBssCb09VnTrP77Ixq9tZXiUG3eVXAiOBEMCdRtUwyTlVJxUDplj2aaAzhHDCsuBzVjiuZ6ZtjEkKz+qZWVNAkY4fn7Xmhl56sFg4vOgwBiNSxTVE22ZhEHrZHcwlC5iZVps+Gvwu3V35fyDj9x4WTMHMLbymZFZHgGew+4dsnoQILQc3pcBY5bb3rj64h6MewNLsWthYqLzw1TPqZ8TPmY8jHlY0DDlA/OMOWj1wNc9iIDL+xFBjC3ydiLjL3I+Kc9BWfOUb6n9AVgoXIrjvkGUEsBAhQAFAACAAgAspK7WDYiOu4PAgAA3GwAAA0AAAAAAAAAAAAgAAAAAAAAADk5Ym90dGxlcy50eHRQSwUGAAAAAAEAAQA7AAAAOgIAAAAA
Category:Examples
Windows 1.0/Rickroll

This program in Windows 1.0 prints all lyrics of the song Never Gonna Give You Up. It's derived from this: Numberfuck/99 Bottles Of Beer, which in term is also derived from this: , originally in Brainfuck. It's 104 KB uncompressed but the powerful KZIP program squashed to ONLY 1.5 KB! WOW! Here is attached (encoded as Base64, BTW):
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
Category:Rickrolling
Category:Examples
Windows找不到文件“啊”。请确认文件名正确后再试一次。

Windows找不到文件“啊”。请确认文件名正确后再试一次。 or 视窗操作系统(aka swodniW) is an esolang inspired by dmc, hasB, llehsrewoP and SOD-SM made by User:PrySigneToFry.
== Syntax ==
There are ℵ0 Commands, and they prints nothing and you'll get a pop-up:
Windows找不到文件“(command name)”。请确认文件名正确后再试一次。
== Examples ==
=== A weird thing ===
‮
Note that this thing is just a LRO character.
And it prints:
Windows找不到文件“。次一试再后确正名件文认确请。”
I omited the LRO in the result.
== Interpreters ==
Add by yourself, I don't wanna write it anymore because I'm already go to sleep.
== Categories ==
Category:Languages Category:2024 Category:Joke languages Category:Implemented Category:Total Category:Output only
Wireless Coolbeans

Wireless Coolbeans is an esolang made by User:Unname4798.
== Help ==
Signals can move in the air in in 4 directions:
^ up
> right
v down
< left
? is used for comments.
Signals get reflected 90 degrees by /'s and \'s. / turns the signal right, while \ turns the signal left:
< \ / >
 ^ ^
They collect and store numbers:
> 2024
And strings:
> &Hello, world!&
$ outputs the signal contents to the console:
> "kiwi" $
? Output: kiwi
% sets contents of the signal to user input.
v
%
$
V reflects signals by 180 degrees:
v
V
And duplicates signals:
V
^
Y toggles operator mode:
> 2024 Ylog(x)Y O
? Output: log(2024)
It supports multiple inputs:
 v
 2
> 1 #+# O
? Output: 3
Operator mode supports these operators:
+, -, *, /, %, &, |, ^, >>, << (2 inputs)
sqrt, cbrt (1 input)
exp, xroot (2 inputs)
log, log2, log10 (1 input)
logx (2 inputs)
abs, sign, floor, sin, cos, tan, sinh, cosh, tanh, asin, acos, atan, asinh, acosh, atanh (1 input)
L turns the signal left if 0 or string, and turns the signal right otherwise:
 v
 1
O L
? Output: 1
T turns the signal left if number, and turns the signal right otherwise:
v
1
T O
? Output: 1
R randomly turns the signal left or right:
v
1
R O
==See also==
* Coolbeans
Category:Languages Category:Two-dimensional languages Category:Concurrent programming
Wise

Wise is a stack-based language based on an extension of bitwise operations for bases ≥ 2.
== Overview ==
There are 3 main registers (A, B,C) and 2 stacks (X, Y). In addition there is the base register, which notates the current base. All numbers are unbounded non-negative integers. A digit of A is notated as a and B as b.
A, B and C are all initialized to 0, and base is initialized to 2.
=== Operators ===
The digit-wise operators operate on each of the least-significant C digits of A and B (or just A in the case of ~). Any remaining digits of A are preserved in the result. The result is then pushed to X.
 Digit-wise operators
Command	Description
~ 	(base - 1) - a
 	min(a + b, (base - 1))
^ 	(a + b) mod base
& 	min(a × b, (base - 1))
* 	(a × b) mod base
The shift operators operate on all of A and B. They can be thought of as shifting all digits of A by B. The result is then pushed to X.
 Shift Operators
Command	Description
< 	A × pow(base, B)
> 	floor(A ÷ pow(base, B))
The digit count operator returns the number of digits in A, not including leading zeroes. The result is then pushed to X.
 Digit Count Operator
Command	Description
/ 	if (A == 0): 0, else: log_base(A) + 1
The final math operator is the base operator, which is used to set base. Attempting to set base to a value < 2 is an error.
 Base Operator
Command	Description
_ 	A → base
The cycling operators are used to change register and stack references.
 Cycling Operators
Command	Description
$ 	Swap the stacks; X becomes Y, and Y becomes X
% 	Cycle the main registers; A becomes B, B becomes C, and C becomes A
The stack operators all modify X. Popping from an empty stack is an error.
 Stack Operators
Command	Description
@ 	Push A, does not modify A
! 	Pop into A
0 	Push 0
1 	Push 1
The branching operators are used for conditional execution. The program is treated as an implicit block. If C is 0, then A and B are treated as 0.
 Branching Operators
Command	Description
? 	If a ≤ b for the first C digits, go to the end of the innermost block
" 	If a > b for the first C digits, go to the start of the innermost block
( 	Start a block, must have a matching )
) 	End a block, must have a matching (
The I/O operators treat numbers outside the program as base-10.
 I/O Operators
Command	Description
i 	Get a base-10 number as input and push it to the stack, converting to the current base. Waits for input
o 	Output A, converting from the current base to base-10
Comments last until the end of line.
 Comments
Command	Description
# 	Start a comment which lasts until the end of the line
Category:Languages Category:2023 Category:Stack-based Category:Unknown computational class Category:Implemented
Wishmaster

Wishmaster is a joke language created by user:Jabutosama. It is a manifestation of philosophical idea that no one can prove or disprove the relations of arbitrary actions in the cosmic scale.
Syntax is never defined to be anything specific but can be the following:
 I wish you close this program.
You cannot prove that me or anyone writing any string, or any arbitrary event in the past, was the instrumental cause of any event in the observable universe, as testing such would need omniscience. Some programs are forced to work, for example as the next second to come, but some, like true being false, are broken and can never work. There are also truly undefined and undecidable ones like the halting problem. In total all programs, by the philosophy, are truly undecidable but the trend of reality following simple rules all over makes language in some cases very intuitive and robust.
Category:Languages Category:Unknown computational class Category:Uncomputable Category:2018 Category:Turing complete
Wittgen's Zucchini

A programming language meant to combine elements primarily of Wittgen and Zucchini to create a language for programs related to neural activity, noting that node behavior in Zucchini is similar to that in artificial neural networks, and Wittgen is explicitly made to fit within neural net limitations. The general idea is that the main program is written in Zucchini, with Wittgen subprograms as a layer of abstraction.
The following description is preliminary and subject to change:
To use a Wittgen subprogram, simply use the label name of the subprogram in question in place of the target node or value. When it is used a signal, the Wittgen program is run (unless it has queued output) but with the variables "neuron0, neuron1" set to the values transmited to it, in the same order as the IDs of those neurons transmitting to it but always starting at zero and consecutive. The Wittgengen program is ran until "Doing Now" points to no assign, at which point the contents of "signal" are queued, and used one character at a time until the queue is empty similarly to the input signal.
Category:Languages
Category:Unimplemented
Wizzcake

Wizzcake is created by user:RainbowDash.
Wizzcake contains 1 register, and 1 stack.
Every single word in a given text, gibberish or not preforms 7 different instructions, multiple different times. 
==Instructions==
===The instructions===
* Pop stack
* Set reg to number
* Push reg to stack
* Add number to reg (Used to be "in" wizzcake but is now removed due to a bug that if fixed ruins previous programs)
* Subtract number from reg
* Clear reg
* Clear stack
* Pop stack but in ASCII letters
==Useful found commands==
* Foxy - Pop stack once
* Sus - Push the register to the stack then pop the stack in ASCII letters
* I - Clear the reg and stack
==Example Programs==
This program does not output Hello world, it only outputs the number -2887711.
 Hello world
This program prints out a 5x5 list of 0's
 i a fault among i a fault among i a fault among i a fault among i a fault among
This JavaScript program made by user:Salpynx outputs a given Unicode character
i = 1; // this is the count for how many times to repeat for the target char
a = -4889132; // "baka " does this to the reg
while (String.fromCharCode(Math.abs(a*i)*0.0149878) != "ඞ") { i += 1}
wizzcake("baka ".repeat(i) + "sus");
==Interpreter in JavaScript==
function wizzcake(inputPrgm){
 // Usage
 let reg = 0;
 let stack = [];
 let words = inputPrgm.toUpperCase().split(" ");
 for (let i = 0; i < words.length; i++) {
 let word = words[i];
 let hash = 0;
 for (let j = 0; j < word.length; j++) {
 hash = (hash << 5) - hash + word.charCodeAt(j);
 hash |= 0; // Convert to 32-bit integer
 }
 let seed = Math.abs(hash) / Math.pow(2, 31); // Unique number generated for every word
 if (word.length === 1) {
 seed = (word.charCodeAt(0) * 2654435761) % Math.pow(2, 31);
 }
 var x = Math.sin(seed) * 10000;
 var outputSeed = x - Math.floor(x);
 var amountOfLoops = Math.round(outputSeed * 5)+1;
 for (let i = 0; i < amountOfLoops; i++) {
 outputSeed = seed;
 x = Math.sin(outputSeed) * 10000;
 outputSeed = x - Math.floor(x);
 let instruction = Math.round(outputSeed * 8)+1;
 switch(instruction) {
 case 2: // Pop stack
 if (stack.length > 0){
 console.log(stack.join(" "));
 stack = [];
 }
 break;
 case 3: // Set reg to number
 var newRandom = Math.sin(outputSeed * 10000) * 10000;
 reg = Math.round((newRandom - (Math.floor(newRandom)))*10000000);
 break;
 case 4: // Push reg to stack
 stack.push(reg);
 reg = 0;
 break
 case 5: // Subtract number from reg
 var newRandom = Math.sin(outputSeed * 10000) * 10000;
 reg -= Math.round((newRandom - (Math.floor(newRandom)))*10000000);
 break
 case 6: // Clear reg
 reg = 0;
 break
 case 7: // Clear stack
 stack = [];
 break
 case 8: //Pop stack but in ASCII letters
 if (stack.length > 0){
 stack.forEach(number => {
 console.log(String.fromCharCode(Math.abs(number)*0.0149878));
 });
 stack = [];
 }
 break;
 }
 seed++;
 }
 }
}
Category:Languages
Category:Joke languages
Category:2024
Category:Unusable for programming
Category:Implemented
Category:Total
Category:Stack-based
Category:Output only