nyuuzyou/wikis huggingface dataset:
Woefully

Woefully is a programming language based on lines made of spaces. It uses a unique type of control flow, featuring no explicit conditionals, and is believed TC, though it is too much of a tarpit to have a prime checker yet.
== Basics ==
Before we talk what's in a program, let's talk about what's not. There are no characters but newlines, pipes, and spaces. There are no spaces next to newlines, or newlines next to spaces etc. Programs that have these will produce output "confuse :(".
On the program, there are two pointers: char pointer, and instruction pointer. The CP (char pointer) starts at the first char, and the IP starts at the CP. The ip moves across the lines until it finds a space; if there is no space on the current line, it will try the next line, etc. The top line is considered next to the bottom line for these purposes. Note that a program with no spaces produces the output "confuse :(". Once it finds a space, it will try to navigate down it as a path. navigation works like this: it checks if there is a space in the three adjacent squares below it:
 #
/|\
If there is, it will go to the first one there. if there is not, it halts the program.
It will keep going in this direction, until there are no spaces in that direction anymore:
(lines denote the spaces it checks)
 #
 /|\
 /
 /
(line end)|\
 |
 /|\
 (no more spaces near this space)
When it finds the end of the line in that direction, it executes a command based on the path length. If the length is 2, it is a nop. if it is greater than 2, execute a command (see below).
When the entire path ends, as in the example above, after the line ends, the IP is set to the CP's position.
== Stacks ==
There are two stacks, A and B.
Stacks start initialised with a single zero.
Stack A is the main stack, and stack B is very much a secondary place to store data temporarily. All push commands are to A, except dupe and A to B.
== Commands ==
All two length commands are nops.
Commands subtract three because the minimum length of a command is three, because length two is a nop.
=== DDL (diagonally down left) ===
Path length is taken, minus three, pushed to stack A.
=== DOWN ===
Path length is taken, minus three, mod 4,
then looked up in this table:
 	Name	What it does
0	AtoB	pop a from A, push a to B
1	diff	pop a from A, b from B, push a-b to A
2	mult	pop a from A, b from B, push a*b to A
3	dupe	peek a from A, push a to B
=== DDR (diagonally down right) ===
Take the length of a DDR path, subtract three, mod 5, then look up in this table.
Moving works with negative integers; it moves back. Moving wraps at the line, and moves down a line, like regular text. It also wraps at the end, to the start.
 	Name	What it does
0	move	pop a from A, move pointer by a
1	bool	pop a from A, push 1 if a!=0, else 0
2	inpt	push input to A
3	otpt	pop a from A, print a
4	swap	swap decimal/text i/o (text supports utf-8)
Category:Languages Category:Stack-based
Wolfgang

Wolfgang is a programming language made by User:Myname, based on Wikipedia:Petri nets.
==Code==
The source code basically consists of a list of arcs.
During runtime, arcs will be evaluated in the same order as they appear in the source code.
If a Transition cannot be active, other Places with Arcs to it will not be evaluated.
The following are valid arcs:
* -> Pid or -x-> Pid: Add Tokens to Place 'id'
* Pa -> Tb or Pa -x-> Tb or Pa -° Tb: Make the Place 'a' an input place of the Transition 'b'
* Tb -> Pa or Tb -x-> Pa: Make the Place 'a' an output place of the Transition 'b'
-x-> moves x Tokens from/to the corresponding Places iff the Transition is active.
-> is identical to -1-> and -° is an inhibitor arc.
===Special Places===
* 'OUT' is treated as a special Place which just outputs the char to a corresponding ascii code.
* 'IN' is treated as a special Place which holds the ascii code of a char from user input.
==Examples==
A simple truth-machine:
Pinit -° Tstart 
PIN -49-> Tstart
Tstart -> Pdata
Tstart -> Pinit
Pdata -> Ttrue
Pdata -° Tfalse
Pblock -° Tfalse
Tfalse -48-> POUT
Tfalse -> Pblock
Ttrue -49-> POUT
Ttrue -32-> POUT
Ttrue -> Pdata
A larger example that substracts one number from another using step-wise decrement and prints it, as long as the result is between 1 and 9:
-9-> Pregister 
-3-> Pdec
Pdec -> Tdecnz
Pregister -> Tdecnz
Tdecnz -> Ptrash
Pdec -> Tdecz
Pregister -° Tdecz
Tdecz -> Ptrash
Pinc -° Tprint
Pdec -° Tprint
Tprint -> Pprint
Pregister -9-> Tp9
Pprint -> Tp9
Pregister -8-> Tp8
Pprint -> Tp8
Pregister -7-> Tp7
Pprint -> Tp7
Pregister -6-> Tp6
Pprint -> Tp6
Pregister -5-> Tp5
Pprint -> Tp5
Pregister -4-> Tp4
Pprint -> Tp4
Pregister -3-> Tp3
Pprint -> Tp3
Pregister -2-> Tp2
Pprint -> Tp2
Pregister -> Tp1
Pprint -> Tp1
Tp9 -57-> POUT
Tp8 -56-> POUT
Tp7 -55-> POUT
Tp6 -54-> POUT 
Tp5 -53-> POUT
Tp4 -52-> POUT
Tp3 -51-> POUT
Tp2 -50-> POUT
Tp1 -49-> POUT
Since building a finite-state automaton with Wolfgang should be trivial, it should be turing complete with this, because you obviously can do branch if zero with an inhibitor arc and simulate a Minsky machine with two registers.
==External resources==
* GitHub
Category:Languages Category:Implemented
Woodchuck

Woodchuck is a brainfuck derivative by User:Rdococ. Instead of the memory model being an infinite tape of numbers, it is an unlabelled binary tree.
== Instructions ==
Instruction	Action
< 	Traverses the left branch. If there's no node, a new one is created.
> 	Traverses the right branch. If there's no node, a new one is created.
^ 	Traverses up to the parent node.
% 	Destroys the current node and all of its descendants, traversing back up.
[...] 	Runs the code within the brackets while both the left and right branches have nodes.
+ 	Increments the accumulator.
. 	Outputs the ASCII character corresponding to the accumulator's value and resets the accumulator to 0.
== Translation from BF ==
A translation from non-wrapping, unbounded brainfuck to woodchuck is as follows:
brainfuck	woodchuck
+ 	>>[>]>^<^[^]^
- 	>>[>]%<%^[^]^
< 	^
> 	<
. 	>>[>+].^[^]^
[ 	>>[^^
] 	>>]^^
On the right is the result of compiling +->+>+++>++<<< to Woodchuck and then running it. The red edges represent left edges, and the blue edges represent right edges.
A green node represents an unbounded bf cell. Going right takes you to its 'zero node', which always has a branch missing and serves as a stopping point for the incrementing, decrementing and looping constructs. Going right again is a chain of nodes, all of which have both branches.
The increment and decrement instructions are converted into code that continually follows this chain until it finds the last node, and either destroys it to shorten the chain and decrement the cell, or adds more branches to lengthen the chain and increment the cell. Then, it finds its way back up the chain, stopping when it reaches the zero node.
Loops are converted into code that only checks the start of the chain, as any positive cell will have both branches there, while a zero cell does not.
This translation is very slow, turning basic instructions into time-consuming scans across value chains. Far better performance could be gained by writing programs directly in Woodchuck, or possibly with a smarter translation algorithm that uses binary rather than unary to store cell values.
== Implementation ==
A (maybe working) implementation of woodchuck is available here.
Category:Languages
Category:Brainfuck derivatives
Category:Turing complete
Category:Turing tarpits
Category:Output only
Category:Implemented
Category:2021
Woodchuck/Implementation

:
This is a simple Woodchuck interpreter written in Lua, along with a function to translate brainfuck to Woodchuck through the method described in the main article.
<pre>
return {
	run = function (wc)
		local wc = wc:gsub("[^%^%<%>%%%[%]%+%.]", "")
		
		local root = {}
		local node = root
		local accumulator = 0
		local stack = {}
		
		local i = 1
		while i <= #wc do
			local char = wc:sub(i, i)
			
			-- Movement
			if char == "^" then
				node = node.up
			elseif char == "<" then
				node.left = node.left or {up = node}
				node = node.left
			elseif char == ">" then
				node.right = node.right or {up = node}
				node = node.right
			elseif char == "%" then
				if node.up.left == node then node.up.left = nil
				elseif node.up.right == node then node.up.right = nil end
				node = node.up
			
			-- Control
			elseif char == "[" then
				if node.left and node.right then
					table.insert(stack, {type = "while", ip = i})
				else
					local depth = 1
					i = i + 1
					while depth > 0 do
						local char = wc:sub(i, i)
						if char == "[" then depth = depth + 1
						elseif char == "]" then depth = depth - 1 end
						i = i + 1
					end
					i = i - 1
				end
			elseif char == "]" then
				if node.left and node.right then
					i = stack[#stack].ip
				else
					table.remove(stack)
				end
			
			-- Output
			elseif char == "+" then
				accumulator = accumulator + 1
			elseif char == "." then
				io.write(string.char(accumulator))
				accumulator = 0
			end
			i = i + 1
		end
		return root
	end,
	frombf = function (bf)
		return bf
			:gsub("[^%+%-%<%>%.%[%]]", "")
			:gsub("%+", "%$inc")
			:gsub("%-", "%$dec")
			:gsub("%<", "%$left")
			:gsub("%>", "%$right")
			:gsub("%.", "%$out")
			:gsub("%[", "%$while")
			:gsub("%]", "%$end")
			:gsub("%$inc", function () return ">>[>]>^<^[^]^" end)
			:gsub("%$dec", function () return ">>[>]%<%^[^]^" end)
			:gsub("%$left", function () return "^" end)
			:gsub("%$right", function () return "<" end)
			:gsub("%$out", function () return ">>[>+].^[^]^" end)
			:gsub("%$while", function () return ">>[^^" end)
			:gsub("%$end", function () return ">>]^^" end)
	end
}
</code>
Category:Implementations
Word

Word is a language by User:PuzzleHunter84 that takes the form of sentences. It is stack-based and has 18 variables (i-z).
==Language==
Each of the letters of the alphabet is assigned one of twelve instructions (thirteen including the nop instruction). The letters a-m and n-z use the same instructions. The period also has an instruction and the space just separates words. The words are taken letter by letter separately in alphabetical order and the actual order they occur in the word is not actually important, i.e. art, tar, rat, atr, rta, and tra are all the same. 
===Instructions===
Instruction	Description
a/n 	Pops the top two stack values and pushes their sum.
b/o 	Pops the top two stack values and pushes their difference (top minus second-from-top).
c/p 	Pops the top two stack values and pushes their product.
d/q 	Pops the top two stack values and pushes their quotient(top divided by second-from-top).
e/r 	Nop.
f/s 	Push the number of letters in this word onto the stack.
g/t 	Push the ASCII value of the next letter in this word alphabetically onto the stack but still execute its instruction. Do nothing if it is the last letter in this word alphabetically.
h/u 	Pop the top value of the stack and set the variable named by the next letter in this word alphabetically to it but still execute its instruction. Do nothing if it is the last letter in this word alphabetically.
i/v 	Retrieve the value from the variable named by the next letter in this word alphabetically and push it onto the stack but still execute its instruction. Do nothing if it is the last letter in this word alphabetically.
j/w 	Duplicate the top value of the stack.
k/x 	Swap the top two values of the stack.
l/y 	Input a value and push it on top of the stack.
m/z 	Pop the top value of the stack.
. 	Output the top value of the stack as an ASCII character.
==Programs==
===Hello, world!===
 reef fee prefer per. rester rug ore referee rex beer. rester rug ore
 were. ere. effort go. referee free are free per. refers rep seer ex
 roe. wet reem. effort go. fee true or. rester rug ore. referees
 me rester rug ore beer. referee free are fee per.
==External resources==
*Interpreter in C.
Category:Languages
Category:Stack-based
Category:Unknown computational class
Category:Implemented
Category:2009
WordLang

WordLang is an turing-tarpit esoteric programming language designed on December 26, 2019 by William Rågstad. It has a meaning-like grammar and intuitive syntax and semantics.
The idea is that programs are executed using only one memory buffer that is modified with different operations. Each character has a major impact on the result, which means that typos have a serious significance and are often occurring during development.
It is meant to be a challenge for intelligent programmers, to produce programs which are also fully legible sentences and texts.
Writing a program in WordLang requires a lot of mental calculation and early planning. This makes the language a perfect challenge during game nights with friends or something you can get stuck with and sit up all night with.
== Background ==
The concept is similar to brainfuck, with the twist that each character increases a global memory buffer called the data value, by the characters corresponding ASCII value instead of +, -. There are also no for-loops or multidimensional data structures, but only variables of the data type double.
== Etymology ==
The language name refers to the idea of source code which is also classified as valid words and sentences in any natural languageWikipedia, Natural language. Therefore, the contraction of word and language was chosen as the representation of the programming language.
==Related languages==
* Brainfuck is the most famous esoteric programming language, and has inspired the creation of a host of other languages.
* Shakespeare is, according to the Manual, to make a language with beautiful source code that resembled Shakespeare plays.
==See also==
==External resources==
===Notable implementations===
* Original distribution by William Rågstad. Includes a cross-platform interpreter built in C#, .NET Core. The interpreter can be compiled with the dotnet CLIMicrosoft .NET, ".NET Core command-line interface (CLI)".
==References==
Category:Languages
Category:Pseudonatural
Category:Turing complete
Category:Turing tarpits
Category:Cell-based
Category:Declarative paradigm
Category:Low-level
Category:2019
Category:Implemented
Word worm

Word Worm is an esoteric programming language designed by User:Yayimhere and User:ais523 and named by User:int-e based on the children's game word chain
== types ==
there are two types:
* letters which are letters in the memory (a string)
* words are all groups of letters that are separated by spaces. each word must be a valid word in english
== syntax ==
the first line is the string memory and then there are other lines:
 〈AB〉₯x
(note that A and B must be single letters) this will replace the letter A with B in the string, unless one of the words that are being replaced in is equal to x
and the special one:
 《A》₯x
which will replace A with a space. if A is ' it will be deleted(both with same condition)
 「x」⇒「y」
what this command does is, if the last word of the string is x then append y to the end. and dis will just delete the first word:
 ⇘
and this will move it to the back
the program halts if one of the words in the string is not a word in english, or if no replacements apply, else it loops
word contractions will decontract(table:)
isn't → is not
i'd → i had
i'll → i will
ain't → is not
n' → and
aren't → are not
amn't → am not
'bout → about
doin' → doing
can't → cannot
'cause → because 
cuz → because
c'mon → come on
could've → could have
couldn't → could not
didn't → did not
doesn't → does not
== examples ==
hello world:
 hello world
more interesting version:
 hello
 「hello」⇒「world」
infinite loop
 hello
 「hello」⇒「hello」
 ⇘
Truth-machine:
 [input]
 「one」⇒「one」
replace [input] with the input(as words)
Category:Languages Category:String-rewriting paradigm Category:Unknown computational class Category:No IO Category:Unimplemented Category:Low-level
Worder

a language that uses your text input to generate code
== Example+output ==
 hello hi cat program what
 greet>noun
 greet = ?
 noun = ?
 Output will use neural network stuff to find greetings and nouns
 Ex: greet = [hello, hi]
 Ex: noun = [cat, program]
 Ex: other = [what]
 then output based on rules
 Ex: hello cat
 Ex: hi program
== Pseudocode for the interpreter ==
 split code into sections, line 1 code, rest rules
 ai add code
 ai rule rules
 ai output
Works in progress

Please keep this in alphabetic order
Feel free to add a WIP page/esolang
* 2002-12-14
* AREA
* Arrows
* Asvi
* Emojifunge 1C
* Genetic
* HelloWorld
* lingua abstrusa
* LogicGate
* Register
* Special:UncategorizedPages
* User talk:/w/wiki/index.php/Talk:index.php/Main page
* Твердою
* ⦿⚚♆⚧⟁⌬⚶⟆⚡⟴⚘⍟⚕⧏⚜⫷⚡⌛⍨⚭⟊⚳⦾⏁⚋⟾⚬
==See also==
* List of ideas
* :Category:Works-in-Progress
Worstscript

worstscript, also widely known as sausage script, is the award winning scripting language near you!
Never before have we been blessed with this kind of features built upon the PHP platform for performance !.
Here is the SPEC for worstscript:
Syntax is 
<PROGRAM> ::= <PROGRAM LINE> | <PROGRAM LINE> <EOL>
<PROGRAM LINE> ::= <LINE> <INSTRUCTIONSPEC>
<INSTRUCTIONSPEC> ::= <GOTO> <VARORLITERAL> |
 <ADD> <VAR> <VARORLITERAL> |
 <SUB> <VAR> <VARORLITERAL> |
 <MUL> <VAR> <VARORLITERAL> |
 <DIV> <VAR> <VARORLITERAL> |
 <SET> <VAR> <VARORLITERAL>
 <PRINT> <VARORLITERAL> |
 <GOTOIF> <VAR> <VARORLITERAL> #goto if variable isn't 0.
 <END>
You'll be happy to see that this is the only documentation. Because let's be honest, who reads it anyway?
So we parse worst script using PHP which is a script language that can run on basically any machine preferably another virtual machine.
In the next release we are planning to have a "GOTO if" statement. WOW We also plan of switching all parameters around, just because we can. You will notice once your programs start to fail.
If you find bugs and have to upgrade you'll have to upgrade to the latest and worst version which is promised to be highly unstable! Remember you are our testers!
Just look at these reviews from 2 people who loved worstscript, who were totally not me!
* Hi, I have a medium to big sized company. Before we switched we heard developers complain about design patterns and difficulties with classes and namespaces. That is now a thing of the past. They can now focus on completely other problems now!
* I always have problems with creating a HELLO WORLD application, gladly worst script is out to help!
Wow, labels are variables now!

Wow, labels are variables now!(WLAVN) is a self-modifying esolang by User:ChuckEsoteric08 where you can change label names.
==Description==
It uses label names instead of variables. Label names can be integers, both positive and negative or list of integers seperated by spaces. You can use n(a) which means "a-th integer in n-th label" instead of n in all commands except for :n and ^n and can use instead of m in >n m, <n m and |n m. Here are all of commands:
Command	Operation
:n 	label which name is n
+n m 	add name of n-th label and name of m-th label, storing result in n-th label
-n m 	same as previous, but it subtracts
*n m 	same as previous, but it multiplies
=n m 	set name of n-th label to name of m-th label
>n m 	if value of n-th label is bigger than zero, goto label m(if there is multiple labels with this name, then goto to label that was declared earlier)
<n m 	if value of n-th label is smaller than zero, goto label m
n m 	if value of n-th label is equal to zero, goto label m
^n 	goto label n
@n 	output name of n-th label
;n 	input number and set name of n-th label to it
#n(a) 	delete a-th integer in n-th label
Category:Languages Category:Turing complete Category:Self-modifying
Wow owo

wow owo is a Cellular automaton created by User:Yayimhere while bored
== cell types and interactions ==
cell types:
* # copies itself in every direction(no diags). if 3 come in a horizontal cluster walls form around them(### becomes [###]). they are blocked by walls, -'s, |'s, and other #'s
* - copies itself horizontally. they are blocked by walls, #'s and other -'s. if 3 come in a horizontal cluster the middle becomes a #
* | copies itself vertically. they are blocked by #'s, -'s, ='s, and other |'s. a vertical cluster of |'s form a [ in the middle.
* = copies itself vertically if the cell north of it is a -, copies itself horizontally if the cell north of it is a | and if its any other cell it will disappear. its blocked by #'s, -'s, ='s, and other |'s.
* : blocks everything from any direction even walls. they grow upwards but only on walls. if they get into [[[: or :]]] it will become [[:: and ::]]
* M does not copy itself and blocks everything. every iteration it will take the cell north of it and replace it with the cell south to it. it will also delete the cell on top of it
* X does not copy itself and blocks everything. it will copy the two nearest cells north of it into the cell south of it without deleting it. will not copy if there is something below it that would get deleted
* o does not copy itself and blocks everything. if the cell north of it was copied in a horizontal direction a - will be put south of it and if the cell north of it was copied vertically a | will be put south of it
* Y block everything and does not copy. Will not let a X copy if it below the Y
walls will only block if its blocking horizontally(so [ blocks a [# and a #[ but not in the case where theres a # on top)
== examples ==
a infinite tower:
 :[###]:
iter 1:
 ###
 :[###]:
 ###
iter 2:
 ###
 [###]
 :[###]:
 [###]
 ###
iter 3:
 [###]
 :[###]:
 :[###]:
 :[###]:
 [###]
and so on
glider (0 is empty space):
 M
 M
iter 1:
 0
 M
 M
iter 2:
 0
 0
 M
 M
infinite line:
 [:]
 -
 [:]
iter 1:
 :
 ---
 :
iter 2:
 :::
 --#--
 :::
iter 3:
 :::::
 ---#---
 :::::
and so on
growing spaceship:
 |
iter 1:
 |
 |
 |
iter 2:
 |
 |
 [
 |
 |
iter 3(its the canvas extending not the pipes moving):
 |
 |
 |
 [[
 |
 |
 |
iter 4:
 |
 |
 [
 |
 [[[
 |
 [
 |
 |
and so on
factory:
 ::
 :[# ]:
 YYMYY
 XX XX
 :[ ]:
 XX XX
i wont do the iterations of this one cuz thats going to be too hard
osc:
 00
 XX
 :[##]:
 :[##]:
 ::
iter 1:
 00
 XX
 :[00]:
 :[##]:
 ::
iter 2:
 00
 XX
 :[##]:
 :[##]:
 ::
and so on
not gate(| 1 and - 0) here the A is the placeholder for the binary value
 :
 :A:
 = :
 0o
 o
 0M
 : ]:
 :
the order of operations is top to bottom
Category:Languages Category:Cellular automata Category:Two-dimensional languages
Wrapping Rhoam

Wrapping Rhoam is an esoteric programming language created by User:EvilMuffinHa in 2019 in which there are only 2 characters. It is an extension of Rhoam.
== Syntax ==
Wrapping Rhoam has a list of instructions and it consists of two characters, ], and :. 
* ] moves the instruction pointer to the right. 
* : executes the instruction at that point. 
In this version of Rhoam, once the pointer goes past the last instruction, it will wrap back around to the first instruction, and so it allows users to perform what was done in Rhoam.
More information on the instructions can be found at this site. 
== Computational Class ==
Wrapping Rhoam can be proved to be Turing complete because it can perform all instructions of Rhoam, and Rhoam is proven to be Turing complete.
== See also ==
* Rhoam
* Rhoam Ultimate
Category:Turing complete
Category:Languages
Category:Implemented
Category:Turing tarpits
Category:Turning tarpits
WsFuck

WsFuck is a derivative of brainfuck by User:None1. It's the same as Binaryfuck, but all the 0's are replaced with line feeds, and all the 1's are replaced with spaces.
==Example Programs==
The programs are in escape since the real programs are invisible
===Cat Program===
\n\n\n \n\n \n\n 
===Hello World===
\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n\n \n\n\n\n\n\n\n\n\n\n\n\n\n \n\n \n\n\n\n\n\n\n\n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n\n \n \n \n \n\n \n \n\n\n\n\n \n\n\n\n\n \n\n\n \n \n\n \n\n\n\n \n\n \n \n\n \n \n\n \n \n\n\n \n\n\n \n\n \n\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n \n\n \n\n\n\n\n\n\n\n\n\n\n \n\n\n \n\n \n \n\n\n \n\n \n\n\n \n\n\n\n\n\n\n\n\n\n\n \n\n\n\n \n\n \n\n \n\n \n\n \n\n \n\n\n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n \n\n\n \n\n \n\n\n\n \n\n\n \n\n\n\n\n\n\n \n\n
==Turing completeness==
WsFuck is Turing complete since Binaryfuck is.
Category:Brainfuck equivalents
Category:Languages
Category:Brainfuck derivatives