nyuuzyou/wikis huggingface dataset:
Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee with looping

Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee with looping is a dialect of Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee by User:Yes in 2022
== Additions ==
Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee with looping adds two more commands, which are
 New command/instruction
Command 	What it does
Do it again	If accumulator is 0 go back to matching checkpoint
Checkpoint 	a checkpoint
This dialect was made so the creator could implement Deadfish easier, (though its probably never gonna come out)
== A downside ==
Because it was made to implement Deadfish, accumulator cant print as ascii char.
==External resources==
Interpreter in Scratch
Category:Languages Category:Push-down automata Category:Low-level Category:Implemented
Weirdlang

A weirdlang is typically just a normal language with weird syntax, but nothing else truly esoteric about it.
== In contrast with True Esolangs ==
A True Esolang (that is, an esolang that is not a weirdlang) has to have something strange about the semantics, structure and/or some other form of esoterism. A language with strange semantics would be Malbolge and one with strange structure would be Befunge. A True Esolang still may have strange syntax, but that cannot be the only thing making it a True Esolang.
== Examples ==
* LOLCODE is a weirdlang because, aside from the lulzy keywords, it's just a normal language.
* If brainfuck was a normal language, Ook! would be a weirdlang.
== Not evil ==
It should be noted that, while many don't usually find them as interesting and entertaining as "True" Esolangs, not all weirdlangs are bad. For example, Vowels, a language with an interesting concept, is really just a low-level assembly language with weird syntax; however, it still forms an interesting idea. 
This post about vocabulary- vs logic-based esolangs is a sort-of defense of esolangs that focus on vocabulary (whether or not they are "true esolangs"). It uses the term esolexicons for weirdlangs, emphasizing that the lexicon (set of signifiers) is esoteric, not the rules of the language itself.
== On the terms Weird and Esoteric ==
Confusingly, the term "Weird Language" is sometimes used for esolangs by people who object to the word "esoteric" (usually in academia), most notably Nick Montfort in his essay "Obfuscated Code" and Michael Mateas in his "Weird Languages" (both published in Software Studies, 2005). As Mateas puts it:
:“Esoteric” is a more common term for these languages, but it is a term that could apply to programming languages overall (most people do not know how to program in any language) or to languages such as ML and Prolog, which are common in academia but infrequently used in industry. A better designation might be art languages. However, while such languages are undoubtedly a category of software art, developers of these languages do not use this term themselves, and it seems unfair to apply the term “art,” with all of its connotations, to their work. The term “weird” better captures the intention behind these languages, and is used at times by the language designers themselves."Weird Languages" by Michael Mateas "Software Studies," page 274, note #2, published 2005 http://dm.ncl.ac.uk/courseblog/files/2010/02/softwarestudies.pdf
Category:Concepts Category:Languages
Welcome To...

Welcome To... is an esolang by User:PythonshellDebugwindow based on the game of the same name.
==Memory==
Programs in Welcome To... use an arbitrary-length stack of unsigned integers.
==Program format==
Each program in Welcome To... is made up of two files, the setup file and the board file. The setup file contains vital information for the program, and the board file contains the actual code.
==Setup file==
The setup file contains the card decks. Each card has a number from 1 to 15 and a special power that can be either POOL, PARK, FENCE, ESTATE, TEMP, or BIS. There are N cards in this file, where N is a multiple of three and is greater than zero, split into three groups at runtime. For any card C with number N and power P, the 0-base ASCII code of character representing that card is 32 + N + (powers.zeroBaseIndexOf(P) * 15) for a range of 33-122, so to represent 2-FENCE, 11-BIS, and 6-ESTATE in that order, you would write:
 @vS
Again, the file is expected to contain N cards, where N is a positive nonzero multiple of three following, this pattern; any other characters throw an error, ending the code entire program, meaning the board file will be completely ignored. After these cards, a newline is expected, followed by a series of space-separated base-36 numbers, with no preceding whitespace other than the aforementioned newline and no succeeding whitespace at all. These numbers specify the number of houses in each street, and also the number of streets (which is the number of base-36 numbers).
==Board file==
The board file contains the actual code. Each line (turn) contains three base-10 numbers. The first one specifies which card is being played (one-indexed) and is referred here to as B, the second specifies which house to fill in and is referred to as H, and the third one specifies where (and if) to use the card's power and is referred to as W. After every turn, the top card of each pile is popped and then pushed to the bottom of its pile.
Power 	Effect
POOL 	Pop from the stack and push to the output queue
PARK 	Push the card's number to the stack
FENCE 	If the card's number is equal to 0, then jump past the matching TEMP
ESTATE	Add the card's number to the top of the stack, then mod the top of the stack by 15
TEMP 	If the card's number is nonzero, then jump back to the matching FENCE
BIS 	Duplicate the top of the stack
==Output queue==
The output queue is where number are sent to be output. When the output queue first receives a number X, it waits for another number Y, and when it receives it, it outputs the ASCII character of (X - 1) + ((Y - 1) * 15) and waits for more numbers. X and Y can be any numbers. If the output queue has only 1 number at the end of the program, a 0 will be sent to the output stream.
==Program end==
If one of the three cards cannot be played, or if the chosen card cannot be played, then its effect will be skipped and a building violation will be gained. Once 3 violations are reached, the program will end, but with a warning message printed after any output. The program will also end if all houses are filled in, but with no warning message.
Category:Works-in-Progress
Welcome to Esolang, the esoteric programming languages wiki!

==Brief Intro==
Welcome to Esolang, the esoteric programming languages wiki! is an esolang, WtE,teplw! for short.
==Operations==
There are 8 words you can use for programming:
* Welcome: Print "Hello, World!" and a new line
* to: Print the website of Esolang Wiki, a.k.a. https://esolangs.org/wiki/Main_Page and a new line
* Esolang: Print the name of Esolang Wiki and a new line.(Just "Esolang Wiki")
* the: Print the code and a new line.
* esoteric: Print how many words there are in the code and a new line.
* programming: Print how many words there are in the code in ASCII.CAUTION: If you want to use this command, you should make sure your code is longer than 31 words.
* languages: Print the code in backward order and a new line.
* wiki: NOP
The code needs to seperate the words with a space.
==Example==
===Hello World===
Welcome
===Quine===
 the
==Interpreters==
===Python===
import sys
code=sys.stdin.read()
reverselist=list(code)
reverselist.reverse()
reversecode=.join(reverselist)
for i in code.split():
 if i=='Welcome':
 print('Hello World!')
 if i=='to':
 print('https://esolangs.org/wiki/Main_Page')
 if i=='Esolang':
 print('Esolang Wiki')
 if i=='the':
 print(code)
 if i=='esoteric':
 print(len(code.split()))
 if i=='programming':
 print(chr(len(code.split())),end=)
 if i=='languages':
 print(reversecode)
==External Resources==
* Online interpreter of this esolang in Interpret Esolangs Online and its JavaScript source.
Category:Languages Category:Thematic Category:Output only Category:Unusable for programming Category:Total Category:Implemented Category:Pseudonatural Category:Joke languages
Whap

you do whappy stuff
== commands ==
 whap [thing] - adds 1 on to [thing]
 whop [thing] - subtracts 1 on to [thing]
 whep [thing] - sets [thing] to input
 whup [thing] - outputs [thing]
 whip [thing] [thong] - if [thing] == [thong], run the indented
 whyp [thing] [thong] - if [thing] != [thong], run the indented till that is true
 whp [thing] - define [thing] to be 0
== cat ==
 whp zero
 whp input
 whap input
 whyp input zero
 whep input
 whup input
Category:Languages Category:Pseudonatural Category:Unimplemented
What???

You know you like put random punctuation sometimes like "What?!?!?.!??!?..!??.!?!?..!?.?!?...!?.?", well this is based on it
== Structure ==
The words before the punctuation determines the type of code
 What - a program that uses ASCII
 Why - a program that uses numbers [default]
 How - a program that loops around, the symbols can also do that
 Where - a program that prints its code
== The punctuation ==
 ? - set the next symbol to the previous symbol, example !?. would turn into !?!, I am not interpreting the ! or . in this example
 ! - set the next symbol to the number of !s in front of this,
 and also skip the next !s, example !!!! would turn into !3!!
 . - print the next symbol and send this symbol one before where it is,
 example would be !.. which would print ., but turn into .!., I am not interpreting the ! in this example
 , - set the previous symbol to the next symbol, example .,! would turn into !,!, I am not interpreting the ! in this example
 ( - enter a group, example is in the next one
 ) - exit a group and run it twice, example (.) would print ) then do nothing because the . escaped the (), and it would turn into .() after that
 & - input one symbol, example & could turn into any symbol
 ` - does nothing, example ` turns into `
 - - prints the previous symbol, example `- prints ` and turns into `-
== Cat ==
 How&.
== Print t ==
 What?`-
Category:Languages
What a mess!

What a mess! is an esoteric programming language by User:A which is extremely messy.
variables are defined like this:
 var=value,
and the value can be both integer or string. This is the only command that is not messy here.
$variable, 	prints the variable's value.
.variable, 	inputs a value for the variable to take.(If is contains only numbers, it is an int. Else, it is a string.)
+- 	do math. For example:
 x=4,
 J=x-2,
sets x as value 4 and J as value 2 (4-2). Also:
 a=honey,
 b=moon,
 c=a+b,
sets a as value honey, b as value moon, and c as value honeymoon (word math only works with +).
condition?do when true:do when false,	start an if statement with the condition.
condition:do something, 	starts a while loop with the given condition.
There are 2 conditions:
>	is greater than
<	is less than
And, two logic statements:
!	not
&	and
==Example - Hello, World!==
 hello=Hello World,
 $hello,
Category:Languages
Category:2018
Category:Unknown computational class
Category:Usability unknown
What the fuck is the Internet?

What the fuck is the Internet? is a tape and stack machine by JayCampbell
inspired by Jason Mewes' obscene rap in Jay & Silent Bob Strike Back.
==Instruction Set==
fuck fuck fuck 	increment current cell
motherfuck fuck 	increment current cell by 4
mother motherfuck fuck 	multiple current cell by 4
noinch noinch 	decrement cell
noinch noinch noinch 	zero cell
fuck fuck 	cell pointer moves right
fuck fuck motherfuck 	cell pointer moves left
who drinks the beers? we drink the beers 	begin a function
who smokes the weed? we smoke the weed 	end function definition
who rolls the blunts? we roll the blunts 	call Nth function determined by current cell
smoking weed weed weed 	begin loop, while current cell equals zero
drinking beers beers beers 	begin loop, while current cell equals top stack element
rolling blunts blunts blunts 	end a while loop
smoking weed, drinking beers, rolling blunts	use in pairs to copy values to/from current cell, push/pop the stack, and I/O
==Hello, World!==
fuck fuck, motherfuck fuck
mother motherfuck fuck
mother motherfuck fuck
motherfuck fuck, motherfuck fuck
rolling blunts, smoking weed
fuck fuck motherfuck, fuck fuck fuck
motherfuck fuck
mother motherfuck fuck
motherfuck fuck, fuck fuck fuck
mother motherfuck fuck, fuck fuck fuck
rolling blunts, smoking weed
drinking beers, smoking weed
fuck fuck
fuck fuck
fuck fuck
smoking weed, drinking beers
fuck fuck motherfuck
fuck fuck motherfuck
fuck fuck motherfuck
motherfuck fuck
motherfuck fuck
noinch noinch
rolling blunts, smoking weed
rolling blunts, smoking weed
motherfuck fuck, noinch noinch
rolling blunts, smoking weed
drinking beers, smoking weed
fuck fuck, fuck fuck
smoking weed, drinking beers
fuck fuck motherfuck, fuck fuck motherfuck
noinch noinch noinch
motherfuck fuck, motherfuck fuck
mother motherfuck fuck, fuck fuck fuck
drinking beers, smoking weed
drinking beers, smoking weed
drinking beers, smoking weed
drinking beers, smoking weed
smoking weed, drinking beers
motherfuck fuck, motherfuck fuck
noinch noinch, motherfuck fuck
rolling blunts, smoking weed
smoking weed, drinking beers
noinch noinch
rolling blunts, smoking weed
fuck fuck, motherfuck fuck, motherfuck fuck
motherfuck fuck, motherfuck fuck
noinch noinch
rolling blunts, smoking weed
fuck fuck
rolling blunts, smoking weed
fuck fuck fuck, fuck fuck fuck, fuck fuck fuck
rolling blunts, smoking weed
fuck fuck
drinking beers, smoking weed
motherfuck fuck, motherfuck fuck
noinch noinch
rolling blunts, smoking weed
smoking weed, drinking beers
noinch noinch
rolling blunts, smoking weed
smoking weed, drinking beers
rolling blunts, smoking weed
==Compilers==
jay2ruby.rb compiles the noinch-noinches into runnable Ruby.
bob2jay.rb compiles a simpler token language to feed into jay2ruby. It was used on hello.bob to create the hello.jay example program.
For a quick proof of Turing Completeness, use bf2jay.rb to convert a brainfuck program into noinch-noinches. Note that neither cells nor the tape wrap.
==To Do==
* Crystal compiler for LLVM optimized binaries
* More examples
Category:Languages
Category:Brainfuck derivatives
Wheel

Wheel (WHolly ElEgant Language) was created by User:PixelatedStarfish in 2021. The syntax of the language is designed to be terse, with single character operations. The syntax is influenced by bf and Heck. 
==Memory==
Wheel is designed such that memory in the language can be stored on a specialized Deque as if bytes are stored on an (expandable and unbounded) spinning wheel. Integers ranging from 0 to 255 are stored at each value, and each value is accessible via an index that wraps.
==Operations==
Note that some operations take parameters as decimal values. C65 prints A.
 Operations Table
Op 	Desc
+ 	Add to val
- 	Sub from val
< 	Rotate Anticlockwise
> 	Rotate Clockwise
L 	Label
G 	Goto
Z 	Goto if 0
Y 	Goto if not 0
D 	Decrease size of wheel (Removes value at pointer.)
I 	Increase size of wheel (Adds a value to wheel.)
V 	Print as Value
C 	Print as ASCII
# 	Set index to 0
* 	Take Input and Store at Cell
% 	Shuffle Wheel
@ 	Print Wheel
^ 	Print Wheel Index
$ 	Halt
(Comment)	A comment
==Grammar in EBNF==
 Grammar:
 Program ::= {Codon}
 Codon ::= Symbol | (Symbol, Value)
 Value ::= {Digit}
 Digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
 Symbol ::= '+' | '-' | '<' | '>' | 'L' | 'G' | 'Z' | 'Y' | 'D' | 'I' | 'V' | 'C' | '*' | '%' | '^' | '#' | '@'
==Program Examples==
===Hello World===
 C72C69C76C76C79C32C87C79C82C76C68
===Truth Machine===
 I*Y00V$L00V01G00
===Random Number (0-9)===
 I10>+>+2>+3>+4>+5>+6>+7>+8>+9%V
==Proof of Turing Completeness==
Bf is Turing complete.
By translating each bf command to Wheel, it can be shown that Wheel is also Turing complete.
(Note that ' :: ' is a stand-in for a newline.)
 Conversion Table 
Wheel 	bf	Desc
> 	> 	increment
< 	< 	decrement
+ 	+ 	add 1 to cell
- 	- 	take 1 from cell
C 	. 	Output ASCII value at cell
* 	, 	Take input at cell
Zx 	[ 	Jump past ' ] ' (to label x)
Zx :: Gy :: Lx	] 	goto ' [ ' (label y) if cell is greater than 0
==External Links==
*Interpreter (Java)
*Online Interpreter 
Category: Languages Category: 2021 Category: Turing complete Category: Deque-based
When The

When The is a programming language. The number thing was kinda inspired by Emmental
yeah	how to yeah
# 	Number (usage: #7)
( 	Rotate Counterclockwise
) 	Rotate Cockwize
$ 	Print Number
& 	Print ASCII
+ 	Add using reverse Polish notation
- 	Subtract
* 	Multiply
/ 	Divide
% 	Mod
_ 	Forever
~ 	Input
Hello World: #73#101#108#108#111#44#32#87#111#114#108#100#33(_&
Cat: _~(&
Category:Languages
When statement

A When statement executes all of the code inside of it the moment the statement is true. This statement acts as a subroutine meaning that whenever it gets finished executing it goes back to the line of code the program was running before it was true.
To implement this you could check every When statement before every line of code is ran.
Psuedocode example:
Int A = 0
While (true){
 A++
}
When (A == 5){
 Print(“A is 5”)
}
== See Also ==
* Goto-when
Category:Language constructs
Category:Ideas
Category:2024
When the Imposter is Sus

When the Imposter is Sus is a deque-based OISC made by User:Maikeru51.It is based off of popular video game Among Us. Its one command consists of a colored crewmate calling another crewmate sus. It also features a buffer value.
When Red, Blue, Green, Yellow, Orange, Purple, Pink, Brown, White, Black, Lime, Cyan, Banana, Rose, Maroon, or Gray call each other sus, the Buffer Value is set to a hex value. This buffer value will later be able to be used to modify the deque.
Category:OISCCategory:Deque-basedCategory:LanguagesCategory:2021Category:Sus
Whendo

It is very similar to Thue, but uses numbers instead of strings.
==Memory==
It uses variables, which contains unbounded signed integers. Variables that are not defined are zero when read, and are defined when modified.
==Syntax==
Its syntax is very simple:
 variable1==variable2=>variable3+=number
If variable1 equals to variable2 then add number to variable3, number can be positive, negative or zero, variable2 can also be a number, but variable1 and variable3 can't.
Both the parts before and after the =>'s are optional, when the part before does not exist, the condition is satisfied by default. When the part after does not exist, it does nothing when the condition is satisfied.
==I/O Syntax==
Sometimes, the program needs to input or output, in this case, the syntax changes a little bit.
 variable1==variable2=>variable3+=number=>y
If variable1 equals to variable2 then add number to variable3, then output y (which can be a number or variable) as ASCII.
 variable1==variable2=>variable3+=number->y
If variable1 equals to variable2 then add number to variable3, then output y (which can be a number or variable) as decimal.
 variable1==variable2=>variable3+=number<=y
If variable1 equals to variable2 then add number to variable3, then input y (which can only be a variable) as ASCII.
 variable1==variable2=>variable3+=number<-y
If variable1 equals to variable2 then add number to variable3, then input y (which can only be a variable) as decimal.
==Execution==
When the program is executed, it picks a random line where the condition in that line is satisfied, and than executes it. When there are no lines like that, the program terminates.
==Examples==
XKCD Random Number:
 a==0=>a+=4->a
Hello, World!:
a==0=>a+=1=>72
a==1=>a+=1=>101
a==2=>a+=1=>108
a==3=>a+=1=>108
a==4=>a+=1=>111
a==5=>a+=1=>44
a==6=>a+=1=>32
a==7=>a+=1=>87
a==8=>a+=1=>111
a==9=>a+=1=>114
a==10=>a+=1=>108
a==11=>a+=1=>100
a==12=>a+=1=>33
The following is an example that demonstrates Whendo's nondeterminism:
a==0?a+=1=>65
b==0?b+=1=>66
When the program starts, both the first and second lines have their conditions satisfied, so any one might be executed first, after that, only the condition in the other line is satisfied. Thus, AB and BA are two possible outputs of this program.
Infinite loop:
 =>
There is one line, with its condition always satisfies, so the program never terminates.
Category:Languages
Category:Unknown computational class
Category:2024
Category:Unimplemented
Category:Nondeterministic
Whenever

Whenever is an esoteric programming language by David Morgan-Mar, with no sense of urgency. The program code is like a to-do list: the interpreter is free to execute statements in any order it chooses. However, a line may contain a clause specifying that it cannot be executed until certain conditions are true. There are no control flow structures or variables.
== Syntax ==
Whenever code must include line-numbers manually typed by the user.
So,
1 1#9;
is valid, however,
1#9;
is invalid.
== Commands ==
The following is a list of all valid Whenever commands.
(linenumber)#(numberoftimestoaddorremove) - variable definition
(linenumber)#read() - variable definition with the value of the user input
print() - Self explanatory
Compound statements:
defer((linenumber)) - will ignore the line containing "defer()" unless if the linenumber is executed
again() ;
forget() ;
Built-in functions:
N()
U()
== Math ==
Built in operators:
+
-
*
/
==
&&
||
!
==Examples==
===Hello, world!===
 1 print("Hello, world!");
If you want to print "Hello, world!" in two lines for some reason, Do this:
 1 print("Hello,");
 2 defer(1) print("world!");
===Calculator===
1 defer(true) 0;
2 defer(true) 0;
3 defer(true) 0;
4 1#read();
5 defer(4) 2#read();
6 defer(5) 3#read();
7 defer(N(2) != 44 || 6) print(N(1) + N(3) + -2);
8 defer(N(2) != 46 || 6) print(N(1) - N(3));
9 defer(N(2) != 43 || 6) print((N(1) - 1)*(N(3) - 1));
10 defer(N(2)!= 48 || 6) print((N(1) - 1)/(N(3) - 1));
==External resources==
* Whenever website
* Interpreter written in Javascript
* Interpreter written in Python + Compiler to C
==See also==
* Strelnokoff
Category:Languages
Category:Nondeterministic
Category:Unknown computational class
Category:Implemented
Category:High-level
Category: 2001
Category: Probabilistic
Where

Where is an esoteric programming language created by User:Ketok.
==Language overview==
Where operates on 4 memory cells, initially set to 1, 2, 3, 4.
Each cell can contain value ranging from 0 to 255.
===Statements===
====Where statement====
Syntax:
 WHERE condition action
Where statement executes action on all cells satisfying the given condition.
For example:
 WHERE >2 SET 255
will set all memory cells with value higher than 2 to 255.
====While statement====
Syntax:
 WHILE [ANY|ALL] condition
 ...
 END
While statement executes its contents while all/any cells satisfy the given condition.
====Reset statement====
Syntax:
 RESET
Reset statement resets values of all cells to their initial state.
It's mainly intended to be used in the interactive mode.
===Conditions===
* =n
* <n
* >n
===Actions===
* SET value
* ADD value
* SUB value
* INPUT
* OUTPUT
==Interactive Mode==
Interactive mode is a feature added in v0.2.0 release used to run Where code interactively in the terminal. In other words it executes REPL (Read, Evaluate, Print Loop) for Where.
It can be entered by running Where interpreter without any command line arguments. 
==Examples==
===Truth machine===
 # Truth machine
 WHERE =1 INPUT
 WHERE =0 OUTPUT
 WHILE ANY =1
 WHERE =1 OUTPUT
 END
===Adder===
 # A simple program that adds two numbers together
 WHERE >1 ADD 251
 WHERE =1 INPUT
 WHERE <253 ADD 128
 WHERE =253 INPUT
 WHERE >253 SET 0
 WHILE ANY >128
 WHERE >128 SUB 2
 WHERE >0 ADD 1
 END
 
 WHERE =0 SET 255
 WHERE <128 OUTPUT
==Interpreter==
Interpreter for Where is written in F# with FParsec.
It can be downloaded from github.
Category:LanguagesCategory:2021Category:Cell-basedCategory:Implemented