nyuuzyou/wikis huggingface dataset:
W

W is a programming language with various unnecessary, redundant, and useless commands. If the compiler encounters an error, the source code is encrypted into the SHA1 hashing algorithm, followed by one of the error codes listed below the commands list.
==Every valid command in W with explanations (inputs replaced with X)==
Feel free to add to this list
* 1{X}: Prints the input (to the nearest available printer)
* Zzq5(X): Prints the input to the console (Causes an error if input does not have less than 4 characters nor contains the letter Q.)
* XFE55B1281X05B5F5BE6F7XFEC888FEX9488094D)_EF: Sets variable 1 to the 11th, 1st, 23rd, and 32nd letters of the command name (
* jS####3$XXXXX$: Runs the input in JavaScript (limited to 5 characters)
* De*&XZr3: If the input is "spacito", Despacito plays. If the input is "nmarkNationalAnthem", the national anthem of Denmark will play. Otherwise, an error will occur. Note that this means a W compiler would have to have a copy of both of those songs for it to be 100% functional.
* MbD\X/: Runs the input in Malbolge, as well as generating 2 random numbers from 1 to 60000000. If the 2 random numbers do not add up to 49, an error will occur.
* 4X: If the input is the name of a language, it will count to 4 in that language. Working languages include Igbo, Latin, Old French Sign Language, Egyptian Hieroglyphics, Danish, and Arabic numerals encrypted into SHA256, converted to binary, encrypted into SHA1, and converted to octal (142062142061060143071067061066071063060142071065070067064067145064067060066063071070065062143070142144143061070145060, too lazy to do the rest)
* &*&#%^&*&#: encrypt the input X with base-64. If the encrypted string is 'NinetyNine', output '99 bottles of beer on the wall...' etc. else output error
* 8sfr2rd85dfr{X}: If the input is "error", an error will occur. Otherwise, an error will occur. If an error occur while executing this command, an error will occur. An error will occur only if it occur. Warning: this command is unstable and risk to cause an error if executed.
==Error codes==
* Error 309: Zzq5 input does not contain the letter Q.
* Error 56: Zzq5 input exceeds length limit
* Error 111: There was a problem with your code that does not pertain to the Zzq5 command.
* Error 99: Input syntax is incorrect
* Error 111: You used the 8sfr2rd85dfr command
* Error 0: It's impossible to have this error
* Error 12: There's two errors 111
* Error 9988: You just checked if there were two errors 111
==An example of a program after encountering an error==
Original code:
 Zzq5(Eggs)
Code after error:
 53c668c38ac9f92df0c616476f9ad5abc0bab11b
 Error 309: Zzq5 input does not contain the letter Q.
Category:Joke languages Category:2018 Category:Languages
W)

w> is a esolang where the only way to store data is by creating pointers and changing commands. its self modifying. it was created by User:Yayimhere. and yes w> can have multiple IP’s which are all executed at once. the pointer starts in the upper left corner of the program and moves left. if any of the IP's go of program it halts. if to IP's intersect the one from bottom or left direction is sent to the upper right corner of program
== Syntax ==
Let's start with the simplest command: /. when the IP lands on the slash it will copy the pointer. The first one will keep going in the original pointer direction while the other one will have turned 90 degrees anticlockwise. To delete a pointer the \ can be used. It will delete the IP when ran. the [ command will when ran be pushed in the pointers direction and turn the pointer direction 180. if its pushed into another command it will delete that command. ; will delete the last command ran including itself. With these rules a infinite loop can be created:
 /\[
 ;
 / /
 \ [
The > will oscillate the below command between / and ,. , will move the pointer downwards. So the loops can be modified:
 ,[
 ;
 //
 \[
There's also the ] will if its right to a pointer it will copy the command to the right of the ] and the ] itself to the left of the pointer.
Category:Languages Category:Self-modifying Category:Two-dimensional languages Category:Concurrent programming
W.W.E

W.W.E (World's Worst Esolang) is a programming language created by User:TheCanon2 that can only do popular problems.
==Commands==
W.W.E programs are read in nibbles. W.W.E has 15 commands.
Opcode	Symbol	Action
0000 	h 	Prints "Hello, World!"
0001 	9 	Prints the lyrics to the "99 bottles of beer" song
0010 	q 	Prints the program's source code
0011 	f 	Prints the Fibonacci numbers
0100 	! 	Prints the factorial of the input
0101 	e 	Prints all even numbers between 0 and the input
0110 	c 	Prints the input
0111 	d 	Prints the digital root of the input
1000 	i 	Interprets the input as Deadfish
1001 	r 	Prints the ROT13 of the input text
1010 	p 	Prints the value of pi
1011 	t 	Prints "0" and halt if the input is 0, or prints "1" indefinitely if the input is 1
1100 	5 	Prints the Fizzbuzz for values 1 to 100
1101 	0 	Makes an infinite loop
1110 	l 	Counts from 0 to the input
1111 	* 	Crashes the interpreter
==Examples==
===Deadfish interpreter===
¨
In hex:
A8
Unrelatedly prints the value of pi as well.
===Crash===
ÿ
In hex:
FF
==Implementations==
The following Python script is an interpreter.
wwe = input('>wwe ')
wwe = .join(format(ord(i), '08b') for i in wwe)
import math
for inst in range(0, len(wwe) // 4):
 cmd = [wwe[4*inst], wwe[4*inst+1], wwe[4*inst+2], wwe[4*inst+3]]
 cmd = .join(cmd)
 if cmd == "0000":
 print("Hello, World!")
 elif cmd == "0001":
 message = '{0} bottle{1} of beer on the wall.\n{0} bottle{1} of beer.\nTake one down, pass it around\n{2} bottle{3} of beer on the wall.\n'
 for i in range(99, 0, -1):
 print(message.format(i, "" if i==1 else "s", i-1 or "No more", "" if i-1==1 else "s"))
 print("No more bottles of beer on the wall,\nno more bottles of beer.\nGo to the store and buy some more,\n99 bottles of beer on the wall.")
 elif cmd == "0010":
 print(.join(chr(int(wwe[i*8:i*8+8],2)) for i in range(len(wwe)//8)))
 break
 elif cmd == "0011":
 a = 1
 b = 1
 print(1)
 print(1)
 while True:
 c = b+a
 print(c)
 a = b
 b = c
 elif cmd == "0100":
 print(math.factorial(int(input('> '))))
 elif cmd == "0101":
 a = 0
 b = int(input('> '))
 while a <= b:
 print(a)
 a += 2
 elif cmd == "0110":
 print("%s" % input('> '))
 elif cmd == "0111":
 a = int(input('> '))
 print((a - 1) % 9 + 1 if a else 0)
 elif cmd == "1000":
 x = 0
 a = input('> ')
 for i in range(0, len(a)):
 if a[i] == "i":
 x += 1
 elif a[i] == "d":
 x -= 1
 elif a[i] == "s":
 x **= 2
 elif a[i] == "o":
 print(x)
 if x == -1 or x == 256:
 x = 0
 elif cmd == "1001":
 import codecs
 print(codecs.encode(input('> '), 'rot13'))
 elif cmd == "1010":
 print(math.pi)
 elif cmd == "1011":
 a = input('> ')
 if a == "0":
 print(0)
 break
 if a == "1":
 while True:
 print(1)
 elif cmd == "1100":
 for i in range(1, 101):
 if i % 15 == 0:
 print("FizzBuzz")
 elif i % 3 == 0:
 print("Fizz")
 elif i % 5 == 0:
 print("Buzz")
 else: print(i)
 elif cmd == "1101":
 while True:
 pass
 elif cmd == "1110":
 a = int(input('> '))
 for i in range(0, a+1):
 print(i)
 elif cmd == "1111":
 print(1 // 0)
Category:Joke languages
Category:Languages
Category:Implemented
Category:Unusable for programming
Category:2024
W110

W110 (or Wolfram's rule 110) is a 1D Cellular automaton proven to be Turing-complete. Its name is derived from how each cell's state is determined.
== Computational class ==
W110 has been proven to be Turing-complete as it can implement a cyclic tag system. (Note that this requires the use of an infinite pattern of cells, with two different infinitely-repeating patterns extending to the left and right – the behaviour is not known to be Turing-complete starting from a finitely initialized pattern.)
== External links ==
* Rule 110 on Wikipedia
* Rule 110 on LifeWiki
Category:Cellular automataCategory:Turing complete
W4ng =

w4ng = is a esolang created by User:Yayimhere inspired by Wang tiles. a w4ng = program takes the given tiles and use a algorithm to tile the plane, halting when it can no longer tile
== semantics ==
to define the list of tiles available:
 [ tile | other tile | other other tile ]
(yes the spaces are needed). now this is the format of a tile:
 { right side(x) | upper side(y) | lower side(z) | left side(d) }
(again the spaces are needed) the strings can by ANYTHING. i swear any string. also the letters are their variable names
== I/O ==
w4ng = has I/O! it will print the grid in this format:
 xyzd
 xyzdxyzd
you see? its just all its sides added together as a single string then those added together base on their coords. and to take input a string must be replaced by ℐ
=== example ===
this example:
 [ { 1 | 1 | E | 1 } | { E | W | E | 1 } | { 1 | E | W | 1 } ]
(no i wont compute it) here the tiles are(im bad at editing plz replace with better image):
== computational class ==
w4ng = is Turing complete since it can compute wang tiles and wang tiles are turing complete
Category:Languages Category:Declarative paradigm Category:Turing complete Category:Turing tarpits Category:Two-dimensional languages Category:Low-level
WASD

==About==
Current Version 1.1
WASD is a language inspired by brainfuck. It was designed to be programmed using only one hand, mainly the left hand (assuming a QWERTY keyboard.)
The file extension for all WASD files is .wasd
==History==
The original interpreter was created by Max00355 in 2012 in order to create a language that would be quick to program, and ultimately create a language that only required one hand to write (assuming a QWERTY keyboard.)
==How To==
WASD works the same way brainfuck works. A pointer is moved in an array of cells which are all set to 0. Each cell can be incremented or decremented by one, then output as an ASCII character.
Command	Description
d 	Move the pointer to the right
a 	Move the pointer to the left
w 	Increment the cell the pointer is currently on by one
s 	Decrement the cell the pointer is currently on by one
e 	Output the data in the cell as an ASCII character
q 	Allow user input then assign the input to the cell
1 	If pointer is set to 0 loop starts
2 	End of loop
( 	Start a comment
) 	Close a comment
==Examples==
Hello World
 dwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwedwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwewwwwwwweewwwessssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssseawwwwwwwwwwwwwwwedwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwewwwessssssessssssssessssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssse
Comments Example
 (this is a comment)
 1dww(this is also a comment)wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwe2
==Interpreters==
Original interpreter by Max00355 in Python
Current Version 1.1
Max00355's Interpreter - Python
Category:Languages Category:2012 Category:Implemented Category:Brainfuck derivatives
WC is a toilet but v, and c are Unlambda operators

WC is a toilet but v, and c are Unlambda operators or WCTVCUO is a esolang by User:Yayimhere. the only change from Unlambda is that he only operators are c and v with another operator:
 .x̅z̃y create operator x that is the code y with input z
also ` is allowed
Category:Languages Category:Functional paradigm Category:2024 Category:Unimplemented Category:Unknown computational class
== See also ==
* Subtle cough
WHAT

WHAT is a tape-based esolang with one extra variable called Memory. It was inspired by the language in 2D Boy's Human Resource Machine.
==Commands==
 IN: Gets an input and stores in Memory.
 OUT: Puts the value in Memory into the output.
 GO: Halts the program and sends all the output values to the screen.
 SWAP 1: Swaps the value in Memory with the value of cell 1.
 READ 1: Overrides Memory with a copy of cell 1's value.
 SET A: Sets jump point A.
 JUMP A: Goes to jump point A
 IF 0: Only executes the next line if the cell in memory is 0.
 IF NEG: Only executes the next line if the cell in memory is negative.
(WIP)
Category:Languages Category:2024 Category:Cell-based Category:Works-in-Progress
WII2D

WII2D is a 2D esolang created by Cortex. Its name stands for "Why Is It 2D?" It was clearly inspired by Befunge. It is probably even harder to compile than Befunge. If it goes over the top, under the bottom, et cetera of the grid, wrap around.
== Commands ==
Character 	What it does
^v<> 	Move north, south, west, or east.
 	Reverse the direction of the pointer.
@ 	Move the pointer to the position above the closest other @ command.
0123456789	Set the accumulator to the digit used.
+-*s/ 	Increment, decrement, double, square, or half the accumulator
~ 	Print the accumulator as an ASCII character.
? 	Move in a random direction.
. 	End the program.
! 	Mark where to position the pointer at at the start of the program (start at the position above the position of the ! command). When the program starts, the pointer is moving northward. Exactly one of these must be used each program.
# 	Nop.
== Examples ==
=== Hello, World! ===
>8s++++++++~9+s+~+++++++~~+++~9+**++++~8**~*9+s-------------~9+s+++++++++++~+++~9+s++++++++~9+s~4s*+~.
!
== Implementations ==
A Python interpreter by User:Bangyen.
Category:Languages Category:Two-dimensional languages Category:Implemented Category:2019 Category:Unusable for programming Category:Output only
WILSON

WILSON is a symbolic logic processing language written by User:john.ohno in 2009. It is based on a simplified subset form of PROLOG syntax, and is non-Turing-complete, instead correlating directly to formal symbolic logic.
(Contents derived from the WILSON introduction manual)
==Description==
WILSON is a highly cut-down symbolic logic language with a syntax loosely based on PROLOG. In WILSON, there are no variables – only symbols which are either true or false. Given a dependent relationship between the values of these symbols, WILSON will compute the value of any symbol whose value is unknown.
 
The syntax for defining a symbol foo is as follows:
 
 foo :- bar, baz, !quux.
 
This means that foo is true if and only if bar and baz are true and quux is false. Similarly, you can define based on 'or':
 
 foo :- bar, baz; !quux.
 
This means that foo is true if either both bar and baz are true, or if quux is false. To define foo as always true, the following is useful:
 foo.
 
==Syntax==
The BNF syntax for WILSON is as follows:
 predicate ::= / name ( ':-' (expr*) )? '.' /
 expr ::= / ( ( '!' name) | (name ( ',' | ';' ) ))* ( name ) /
 name ::= / ([A-Za-z0-9]+) /
==Implementation==
The WILSON compiler will generate equivalent source code in FORTH for your expressions, and should check for and notify of most common errors.
To run the WILSON compiler:
 
 cat foo.raw | wilson2forth > foo.fs
 
The canonical extension for WILSON source files is .raw.
==External resources==
* Translator written in GNU FLEX that translates WILSON source into GNU FORTH compatible FORTH source code.
Category:Languages
Category:2009 Category:Implemented Category:Declarative_paradigm Category:No_IO Category:Usability_unknown
WISC

==Body==
WISC is a OISC that has the instruction "Whisk a batter for __ minutes and go to instruction of the recipe that the minutes whisked of this batter is offsetting to and move to the next batter".
Because that's kind of vague and long, we can shorten it to "wisc __". The operation adds __ to the value pointed to the data pointer, then jumps to that numbers value, and increment the data pointer. Implied Loop.
Category:Languages
Category:OISC
W (A)

w is a postfix esoteric programming language invented by User:A based on wren designed for code golf. It has a very consistent syntax for stack operations, without involving the concept of blocks and infix operators, as well as avoiding the concept of modifyable accumulators! (W also only has a single stack, which prevents the program from being hard to read.)
In addition, w doesn't apply the operations directly - every instruction chain is treated as an anonymous function. This makes the language very easy to learn and write code in.
== Project Euler 1 ==
Project Euler 1:
1000a5ma3m&!WJ
Explanation:
1000 % Literal 1000
 W % Filter out all numbers that fullfill
 % the following condition in the range
 % 1..100
 a5m % The provided each input of F modulo 5
 a3m % The provided each input of F modulo 3
 & % And those values
 ! % Negation (i.e. remove those that don't)
 J % Summate the remaining list
Due to W's shorthands, 1000 can be replaced with `3^`, i.e. 10 to the power of 3.
== An example ==
Factorial finder
1.@*R
Explanation
There is an implicitly-given input
 R For every item in
 . the generated range
 from the implicitly given input
1 to the number 1:
 @ Roll down to exploit two operands
 R Reduce this range using this method:
 For the implicitly given 2 operands
 (the accumulator and the current item):
 * Multiply them
Implicit output the value
Or, since W now auto-maps in the range (1..input) inclusive:
*R
== Do you make me up? ==
t!
t""=
Explanation
Implicitly provide 2 inputs
t "Trim" them (a.trim(b) is removing all characters in b that exist in the string a)
 = Check equality with
 "" the null string
Implicit output
== Hello, world! ==
There isn't a built-in, so the string is in its literal form.
Hello, world!"
Explanation
Implicitly provide a quote
Hello, world!" Push this string
Implicit print
== Quine ==
p34CS+"p34CS+
Explanation
" THe implicit quote
 p34CS+" This string.
 p Print & return the string.
 34CS+ prepend it with a quote.
Return this value.
There's also a quote built-in in W. (7 bytes)
pqS+"pqS+
== Prime tester ==
Works for 1. Also, no boring built-ins in W for this one!
m!Wk2=
Explanation:
 W % Generate a range from 1 to the input
 % Keep those items where the following condition is true:
m % Find the remainder of the input and the current item of the range
 ! % Negate this result
 k2= % Is the length of the list 2?
 % Implicit output
== Mean of array==
This is an idea taken from the XENBLN page.
:JSk/
== Reference implementation ==
Here is the implementation. This is a reimplementation in Python that makes sure all examples work. (Not in Wren, because I can't seem to get Wren to work...)
Category:2019
Category:Languages
Category:Implemented
Category:Golfing language
W (Viktor T. Toth)

W is a compiled low-level programming language created by Viktor T. Toth in or before 2001. The goal of the language is to have a compiler that can be run on DOS 3 computers with a small amount of memory. The compiler host and target platform are both DOS x86 real mode with only a single segment used, so address space is limited to 64 kilobytes. The compiler is self-hosting implemented in W, though there is a (likely unpublished) C version as well.
The language is low-level, somewhat like ancient and very simplified C, but it only uses one type, unsigned 16-bit integers that are also used as pointers. You can build arithmetic expressions from this using the binary operators + - << >> & * / % | + - < <= == > >= != && || [] () = as well as unary - ~ ! # @ and parenthesis. The operator # takes address like the & operator in C, while @ dereferences a pointer to its pointed 16-bit integer. The operators && and || are not short-circuiting; they and comparison operators don't always output 0 or 1. 
The control structures of the W language have somewhat unusual syntax. Statements are written one after another with no separator punctuation, just like Lua allows, but there is not even an optional separator that you can use: in fact ; starts a comment. As a result, statements can't start with an opening parenthesis for that would be ambiguous with a function call. A braced blocks of statements { } can be used as an expression, with the last statement giving the return value. Conditional expressions x ? y , z or x ? y are available. Loops are written using the $ pseudo-variable which represents the instruction pointer: you save it to a temporary variable at the start of a loop and assign to it with the = operator when you want to jump back. 
Global and local variables, declared with :=, can be scalars as well as arrays. Such arrays are initialized with a comma-separated list of 16-bit integer constants, and this can be used not only to store data but also machine code functions that would be hard to express directly in W. You can also declare functions with argument lists and call them with the () operator. 
The compiler generates straightforward code with not many optimizations, but surprisingly does constant folding. Expressions are evaluated with a stack stored on the x86 stack, the top element in AX instead. Interestingly, reading the $ pseudo-variable is compiled to using the CALL instruction to get the instruction pointer, rather than using the known address as a constant. 
== Links ==
* Viktor T. Toth's pages about the W language
Category:Languages
Category:Implemented
Category:2001
Category:Low-level
WaifuScript

WaifuScript is a joke esolang made by User:Juanp32.
 anything in square brackets is placeholder. so "uwu a" is correct but "uwu [a]" isnt. so the correct label format is _text
command 	meaning
uwu [string] 	print [string]
:3 .X? 	declare variable .X
owo .X iz Y 	assign value Y to .X
~w~ iz .X?Y 	if .X ? Y then (? is placeholder, valid symbols: > < = != => =<)
it iznt!? T_T 	else
^_^ 	true
>.< 	false
its in _[label] uwu 	go to _[label]
were in _[label] now uwu 	set label
plz add/sub/mul/div/exp/mod X with Y uwu	add/substract/etcetctheotheroperators value X with value Y
~ [text] ~ 	comment
send me stuff and put it in .X? 	input to .X
theres a block here uwu 	begin code block (put before the if conditional)
nvm it ended T_T 	end code block (put it after last line of the thing to do on the if-then/if-then-else statement)
-_- 	warn before quitting, freezes program until user input ("press any key")
^w^ 	reset all variables
thats all uwu, cya guys ~ 	quit program (without user prompt)
=== hello world ===
 uwu hello world
 thats all uwu, cya guys ~
Wait

Wait is not really a programming language. When it compiles, it uses the current time to write a program and runs that program. The program can be encoded in any way, in any Turing-complete language. There has to be a way to map time and date to the program. One example is bit-encoded Brainfuck. One implementation is Sunwait, which runs on a Sun machine of some kind.
Wait was invented by Daniel B. Cristofani.
==External resources==
* The wait Programming Language Specification
* Online sunwait interpreter 
* Online bfwait interpreter