nyuuzyou/wikis huggingface dataset:
Walking Straight Forward

Walking Straight Forward is a programming language I made based on a song I made called Walking Straight Forward, the song goes like this:
 Walking straight,
 Walking straight,
 Straight forward!
 Walking straight,
 Walking straight,
 Straight forward!
 Walking straight,
 Walking straight,
 Straight forward!
 Stop.
 Turn [direction],
 Turn [direction].
 {loops}
The structure of the program is the song, including the looping, if you want more stuff, the program looks like this:
 Walking straight,
 Walking straight,
 Straight [command]!
 Walking straight,
 Walking straight,
 Straight [input]!
 Walking straight,
 Walking straight,
 Straight [input]!
 Stop.
 Turn [input],
 Turn [input].
 {loops}
Commands:
 Forward, make the 1st input a var.
 Backward, return the value of the 1st input as a var.
 Leftward, add 1st input and 2nd input and put it in 3rd input as var.
 Rightward, subtract 1st from 2nd into 3rd as var.
 Nowhere, Set 1st to 2nd.
Inputs:
 Forward, the number 1
 Backward, the number -1
 Leftward, the var 1
 Rightward, the var 2
 The same way, refer to the last returned value
 Nowhere, the output, when set, outputs the value being set to
 Left in turn, set this line to the var 1.
 Right in turn, go to the line that is var 1.
 Not at all in turn, do nothing there
123 program:
 Walking straight,
 Walking straight,
 Straight Forward!
 Walking straight,
 Walking straight,
 Straight Leftward!
 Walking straight,
 Walking straight,
 Straight Nowhere!
 Stop.
 Turn Not at all,
 Turn Not at all.
 Walking straight,
 Walking straight,
 Straight Leftward!
 Walking straight,
 Walking straight,
 Straight Leftward!
 Walking straight,
 Walking straight,
 Straight Forward!
 Stop.
 Turn Not at all,
 Turn Not at all.
 Walking straight,
 Walking straight,
 Straight Nowhere!
 Walking straight,
 Walking straight,
 Straight Nowhere!
 Walking straight,
 Walking straight,
 Straight Leftward!
 Stop.
 Turn Not at all,
 Turn Not at all.
 Walking straight,
 Walking straight,
 Straight Nowhere!
 Walking straight,
 Walking straight,
 Straight Nowhere!
 Walking straight,
 Walking straight,
 Straight Leftward!
 Stop.
 Turn Not at all,
 Turn Not at all.
 Walking straight,
 Walking straight,
 Straight Nowhere!
 Walking straight,
 Walking straight,
 Straight Nowhere!
 Walking straight,
 Walking straight,
 Straight Leftward!
 Stop.
 Turn Not at all,
 Turn Not at all.
Category:Languages
Category:Pseudonatural
Walls

in walls you use a logic of a maze to run instructions
===syntax===
in walls there is places where numbers is stored. the program pointer itself has a stack. then the primary memory is a cell based strip
0: 0 is the path and is followed by the program pointer. if it splits the program halts
1: 1 is the walls. the program pointer can't go into walls
>: move the memory pointer to the right
<: move memory pointer to the left
number: if you put a number on the track then the program pointer will pick it up and store it in the stack for later use on the memory band. to use a 1 or a 0 you type a # in front of it
!: a key. you can name keys using only numbers. keys are used for ~. you put the number the key in front of the key itself
~: a door. you name doors with a number and the corresponding key(the door number is the key number which i placed in front of it. after the door has been opened the program pointer can pass through it like a 0. else it behaves like a 1.
o: a hole. add the number of the current key to the current memory cell.
/: print the current memory cell
": ascii variant of /
=: go left if the current memory cell is zero. else this operator behaves like 0
Category:Languages Category:Cell-based
Wang program

Wang programs were introduced by WangWang, Hao (1957): A variant to Turing's theory of computing machines. Journal of the Association for Computing Machinery (JACM) 4, 63-92. in what he called a "program formulation" of Turing machines. For a Turing machine with binary tape-alphabet, a Wang program replaces the state-transition function with a program based on the instruction-set M, E, L, R, Ck (meaning, respectively, Mark, Erase, move Left, move Right, and Conditionally jump to the instruction labelled k if the current cell is marked). 
Wang B-machine is the above except that the Erase instruction is omitted; it is still Turing-complete.
The Wang program concept generalises to a tape-alphabet of size m >= 2 by
using the instruction-set Wi, L, R, Ck, where Wi writes the i-th letter of 
the alphabet into the current tape-cell.
==Similar computational models==
A Brainfuck-like computational model results from Wang's model if 
* labels and conditional jump instructions are replaced by matching brackets '[', ']', and
* a cyclic ordering is applied to the tape-alphabet, with write instructions replaced by '+' and '-', understood as instructions to change the current letter to the next and previous letter (respectively) in the cyclic ordering.
The Fm languages are then obtained by also removing '-' from the instruction-set. Bohm's programming language P%27%27 for TMs with a left-infinite tape results if the instructions '+' and '<' are then combined into one instruction equivalent to '+<' (or, for a right-infinite tape, by combining '+' and '>' into '+>').
==Sequential Tag System/Cyclic Tag System to brainfuck to B-machine==
In the article Brainfuck minus - is represented a way to translate Sequential Tag System and Cyclic Tag System to brainfuck, and then from brainfuck to B-machine.
==Computational class==
The Wang program formulation of Turing machines is Turing-complete by construction.
==See also==
*Fm
==Reference==
Category: Computational models
Wariolang

WarioLang is an esolang inspired by the AI system of Warioware D.I.Y, it is created by discord user CosmicMan08#1975 (User:CosmicMan08).
== INSTRUCTIONS ==
Set [Var] to [Data] ---- Sets a variable of the programmer's choosing to something else of their choosing.
Ask for Input ---- Pauses to let the user type in an input, then the default variable "Input" is set to what they typed.
When [Var] is [Data]: ... ​End ---- Detects if a specific variable is equal to a certain value/string/boolean and runs the code inside if it returns on
Until [Var] is [Data]: ... End ---- Repeatedly reads a set of instructions until a specific variable is equal to a certain value/string/boolean, in which the loop will stop
Action [Name]: ... End ---- Acts as a block of code that can be called on by Call [Function]
Call [Function] ---- Skips to the function called and returns back to the line after the function terminates.
Stop! ---- exits the program/function/if statement/while loop
== DATA ==
Number ---- just a plain number, (ie 1, 2, 5, 5639546798, 3.4, etc)
String ---- any text surrounded by "s
On/Off ---- a binary form of data storage
== MISC ==
Input ---- special variable that is overwritten every time "Ask for Input" is used
Prompt ---- special variable that acts as the output of the program
== EXAMPLES ==
=== Hello World! ===
Set Prompt to "Hello World!"
=== Cat program ===
Ask for Input
Set Prompt to Input
=== Truth-machine ===
Ask for Input
When Input is "0":
 ​Set Prompt to "0"
End
When Input is "1":
 ​Until Off:
 ​Set Prompt to "1"
 ​End
End
Category:Languages Category:Pseudonatural Category:Unimplemented Category:Unknown computational class
Warp

The Warp programming language is a derivative of Harp (still alive at its history page), both by User:Rdococ.
== Structure ==
Warp is much like Harp, with a single instruction which has two arguments. However, with Warp, you would be able to check inputs against regular expressions instead of equivalence to a string, and you would be able to check if the input is empty too, unlike in Harp.
The regular expressions would also give you data about the wildcard material - for example, if you were to check the input against 'f(*)' where * is a wildcard, then the program would fill the input with the material in the wildcard, instead of asking the user. For example,
herp* 3
* 1
true 6
false 8
* 1
&* 3
* 6
&* 9
* 8
If we said, for example, 'herptrue', the interpreter would go to instruction #3, with the input filled with 'true'. Since it matches 'true', we ask the user this time and go to 6. Let's say we said '&false'. Now we're back at 3, with 'false'. Now, 'false' doesn't match 'true', so we go to the next line. There, 'false' matches 'false', so we go to 8, forgetting the wildcard stuff. Now, let's say we put '&true'. Now we're at 9, with 'true' in input. No matter what, anything matches '*', so we go to 8. This example doesn't mean much, or atleast I don't think.
== Computational class ==
I'm not sure... I tried to prove it was Turing-complete but it just didn't work out...
Category:Languages
Category:OISC
Category:Unimplemented
Category:Unknown computational class
Warpdrive

Warpdrive is a language created by User:Aithecomputerguy that is very loosely based off of cellular automata. Its name comes from the idea of going faster than the speed of light, which in cellular automata is faster than one cell per tick and in traditional cellular automata is impossible. It consists of an infinite one dimensional array of cells with unique identifiers. On each tick, cell N may "activate" another cell depending on how many cells activated cell N on the previous tick.
=Language description=
Every statement describes the behavior of a cell:
 STATEMENT := CELL_NUM: SINGLE_1, SINGLE_2, ..., SINGLE_N ! MULTI_1, MULTI_2, ..., SINGLE_N;
where CELL_NUM is a unique case-sensitive string that identifies the cell (characters :,! and ; are not allowed), SINGLE_1, SINGLE_2, etc. are cell identifiers to activate when this cell is activated by exactly one other cell, and MULTI_1, MULTI_2, etc. are cell identifiers to activate when this cell is activated by more than one other cell on the previous tick. In each statement, CELL_NUM and the symbols :; are required, but nothing else is. If a cell doesn't have a corresponding statement or has an empty statement associated with it, it does nothing upon activation.
Comments are designated with # and continue until a newline is reached.
Upon starting, each statement is interpreted and stored in a usable format (implementation specific). Cell zero is then activated.
=Examples=
Half adder. In this example, it adds 1+1 by calling A_1 and B_1 simultaneously. Either Out_0 or Out_1 will be activated depending on the inputs. Likewise and simultaneously, Carry_0 or Carry_1 will be activated. OutXor takes two ticks to complete, so CarryDelay is required.
0: A, B;
A: A_1;
B: B_1;
# The half-adder.
A_0: OutXor_0, CarryAnd_0;
A_1: OutXor_1, CarryAnd_1;
B_0: OutXor_0, CarryAnd_0;
B_1: OutXor_1, CarryAnd_1;
OutXor_0: OutXor2_1 ! OutXor2_0;
OutXor_1: OutXor2_1 ! OutXor2_0;
OutXor2_0: Out_0 ! Out_0;
OutXor2_1: Out_1 ! Out_0;
CarryAnd_0: CarryDelay_0;
CarryAnd_1: !CarryDelay_1;
# Output
Out_0:;
Out_1:;
CarryDelay_0:Carry_0;
CarryDelay_1:Carry_1;
Carry_0:;
Carry_1:;
==Computational class==
The ability to create both AND and XOR gates proves this language is able to represent any Bounded-storage machine but as it is not possible to access any cell not explicitly specified in the original program it is not Turing-complete.
Wasaya/Error

Here shows the Error code and what it means.
 Error
Code	Mean
0 	Exited the program normally.
1 	Grammatical errors.
-1 	The program is manually terminated by the user.
2 	Math errors.
3 	Failed to find the standard library that this program was hoping to introduce.
5 	You can't assign a value to a keyword.
6 	An error occurred while converting the type.
8 	There is a problem with the value being passed in.
10 	Stack overflow.
19 	Failed to establish a connection to the internet to access the online standard library.
Wasaya/Libraries

As a practical programming language, Wasaya supports a number of standard libraries. These standard libraries typically support advanced mathematical operations (e.g., trigonometric functions, greatest common divisors, etc.), efficient algorithms (e.g., insert sorting, quicksorting, etc.), inputs and outputs, and even manipulating systems, drawing pictures, etc.
== Math Library ==
Math Library supports more mathematical operations. To use this library, you don't need to "require" it.
Its name is "math".
Supported functions:
math.sin(x) ---Sine
math.cos(x) ---Cosine
math.tan(x) ---Tangent
math.cot(x) ---Cotangent
math.sec(x) ---Secant
math.csc(x) ---Cosecant
math.gcd(x, y) ---Greatest common divisor
math.log(x, b) ---Logarithm
math.pow(x, y) ---Power
math.sinh(x) ---Hyperbolic
math.cosh(x)
math.tanh(x)
math.coth(x)
math.sech(x)
math.csch(x)
math.asin(x) ---Anti
math.acos(x)
math.atan(x)
math.acot(x)
math.asec(x)
math.acsc(x)
math.sgn(x) ---If x is positive, it returns 1, if x is negative, it returns -1, otherwise it returns 0.
math.round(x) ---Round
math.ceil(x) ---Round away from 0
math.floor(x) ---Round toward 0
math.fact(x) ---Factorial
== IO Library ==
I've talked about it in the part "Input and Output".
io.read()
io.read_prompt(__prompt = "")
io.printf(format, *args, **kwargs)
io.printend(*args, **kwargs, end="")
== Random Library ==
Of course, in order to achieve more advanced content, we'll also implemented random libraries in Wasaya.
Supported functions:
random.random(seed) ---Generate a seed.
random.randint(a, b) ---Generate a random integer between a and b.
random.random01() ---Generate a random real number between 0 and 1.
random.choice(list) ---Choose a random element from list.
== Algorithm ==
A series of algorithms are implemented here.
#---[[
These are most useful functions
]]---#
algo.sort(list, cmp = less_than) ---Sort a list.
algo.midsearch(list) ---Search an element from list.
==Self-interpreter Library==
by User:ZCX islptng
 request("exec")
Using it is easy, this is not even a library but a function:
 exec("#---[[ Any Wasaya Code ]]---#")
== Network operation ==
Its name is "network".
network.connect()
network.disconnect()
network.ConnectStatus ---This is a boolean value, which shows connecting status. If it is normal, then return True.
network.access(website)
network.ping(host, *args)
network.address(host)
== System ==
It supports to control your OS.
system.pause()
system.cmd(cmd)
system.time(timezone = 0)
system.date(timezone = 0)
== stdlib ==
This library needn't to show its name.
--- Currently, the stdlib library supports some common data structure types.
stack
queue
deque
array
dict
tuple
graph
tree
hash
== Regular Expression Library ==
Its name is "re".
re.match(pattern, matching, flag = NULL)
#---[[
If there is a matching string in pattern then return the matched string's position
that it appears first time,
else return None.
It can only match from starting point, unlike the stronger re.search.
]]---#
re.search(pattern, matching, flag = NULL)
re.replace(pattern, matching, mask, flag = NULL)
#---[[
Replaces all "matching" in "pattern" by "mask".
]]---#
Wasaya/More examples

== Truth machine ==
a = bool(int(io.read()))
if a:
 while a do
 print(a)
 end
end
print(a)
== Guessing number ==
a = random.randint(-50, 50)
b = int(io.read_prompt("How many chances do you want to give yourself? "))
temp = b
while b > 0 do
 c = int(io.read_prompt("What is the number you guessed?"))
 if c == a:
 print(f"Congratulations! You guessed it! The answer is {a}.")
 b = 0
 d = (io.read_prompt("Do you want to play again? (y for yes, lowercase only)") == 'y')?true:false
 if !d:
 print("Thank you for playing!")
 break
 else:
 b = temp
 end
 elif c < a:
 print(f"{c} is too small! Please try again. You have {b - 1} more chances.")
 b -= 1
 else:
 print(f"{c} is too large! Please try again. You have {b - 1} more chances.")
 b -= 1
 end
end
Wasaya/Operators

== Monocular operators ==
 Monocular operators
Operator	Meaning
!x 	Return logical NOT x.
~x 	Return bitwise NOT x.
x++ 	Let x to be x+1.
x-- 	Let x to be x-1.
== Binocular operators ==
 Binocular operators
Operator	Meaning 	
x+y 	示例 	
x-y 	示例 	
x*y 	示例 	
x/y 	示例 	
x//y 	Integer division.	
x%y 	Modulo. 	
x&&y 	示例 	
x 	y 	示例
x&y 	示例 	
x^y 	Bitwise XOR. 	
x**y 	Power. 	
y 	示例 	
x=y 	Assignment. 	
x<y 	示例 	
x>y 	示例 	
x==y 	示例 	
x<=y 	示例 	
x>=y 	示例 	
x~=y 	Same as in LUA. 	
x<<y 	示例 	
x>>y 	示例 	
== Trinocular operators ==
 Trinocular operators
Operator	Meaning
c?a:b 	If c returns true, return a, otherwise return b.
== Tetrocular operators ==
 Tetrocular operators
Operator 	Meaning
a\b($c, d)	Get the result of a×b. Such as, 1\2($1, 2) will get √2.
Category:Generated by AI
Wave

Wave is an unimplemented esoteric programming language made by User:WhoeverKnew123.
It's named wave because of the 2 input and output operators: /` and \_.
 ~! STRT ?? Start program
 !! END ?? End program
==Instructions==
 Tokens
Token 	Description
/` 	Output operator
\_ 	Input operator
in 	User input kewword
ans 	Recent input answer
# 	Variable data-type token
@ 	Print function
% 	End statement
:( 	Open loop/condition
)% 	Close loop/condition
if <bool> 	If condition
for (i, start, end, step)	Repeat from start to end by step
while 	Repeat until boolean is not true
& 	Assignment operator
\n 	Add a newline
==Data types==
 Data types
Data Type	Description
int 	Integer/Number
str 	String/Text
bool 	Boolean True/False
==Examples==
Hello, World!
 ~! STRT ?? Start program
 @/`"Hello World"% ?? Print string Hello World
 !! END ?? End program
Cat program
 ~! STRT
 in\_"Enter something"% ?? Ask for user input
 @/`ans% ?? Print the answer
 !! END
Truth-machine
 ~! STRT
 in\_"Enter 1 or 0"% ?? Ask for user input.
 if <(ans) = (0)> :( ?? If the answer is 0, print 0.
 @/`0%
 ) elif <(ans) = (1)> :( ?? Otherwise if it's 1, print an infinite number of 1's.
 while <True> :(
 @/`1\n
 )%
 )%
 !! END
=Declare variables and assigning them=
==Declaring==
 #str greeting
 #int age
 #bool isTheEarthRound
==Assigning==
 greeting & "Hello, World!"%
 age & 15%
 isTheEarthRound & true%
==Declaring and assigning on the same line==
 ~! STRT
 #str greeting & "Hello, World!"%
 #int age & 15%
 #bool isTheEarthRound & true%
 !! END
Category:LanguagesCategory:Unimplemented
Wct

Wct is a impossibly strange number system, which obtains fast and lightweight compiler for building tiny and quick applications in machine code. In other words, this is simple toy for fans of unusual. We believe development must be an enjoyable, creative experience to be truly fulfilling.
== Symbols ==
Here are all the letters of the Wct:
 A B C D E F G H I J K L M N P O
== Installation ==
To get Wct Editor from Launchpad PPA, just use following commands:
 # apt-add-repository ppa:mihip/wct
 # apt-get update
 # apt-get install wct
If you are using another Linux distro, you can also use this command:
 $ curl -s https://raw.githubusercontent.com/Mihip/Wct/master/src/tools/other/install.sh | sudo bash
== Usage ==
If you use Linux, just copy wcteditor to /usr/bin folder, and you can use Wct Editor with following command:
 $ wcteditor <source> [output]
Example:
 $ mkdir test
 $ cd test
 $ wcteditor test.wct output
 $ dir
 test.wct output
 $ ./output
== Example ==
This is small example, it will display martix-like symbols falling.
Supports MS-DOS.
 Me BM		// загрузка в bx сегментного регистра es	<───────┐
 Jo		// загружаем младший байт регистра флагов в AH		│
 		//							│
 Kl		// в ES:DI кладем элемент из регистра AX		│
 		// и изменяем значение регистра di			│
 Eh		// увеличиваем регистр di на единицу			│
 Eh		// два раза						│
 		//							│
 Pl OJ		// делаем прыжок на инструкцию Me BM		>───────┘
 		// и повторяем все заново
== Notes ==
* Wct editor has been created on Wct Editor. You can also create programms in machine codes on wct. Only letters, my friend, only letters :)
* Wct is used in Stapler programming language and practically does not differ from the Hex, but has a more advanced system of writing code.
* If you need to create application quickly and easily, use other programming languages, such as C++, Python, etc. Wct only created for pampering and aesthetic pleasure.
== External resources ==
* Wct official website
* Stapler website
* Demoparty
* Our group in VK
We30++

We30++(or Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee++) is derivate of Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee by User:ChuckEsoteric08 for creating Deadfish interpreter in it.
==Changes==
Accumulator is unbounded now. To increment or decrement accumulator, write how many times you want to do it on next line. It also have Looping commands from Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee with looping, except Do it again will jump to n-th Checkpoint(n is a number on next line).
Category:Languages Category:Unimplemented Category:Push-down automata
Weave

Weave is a concurrent dialect of brainfuck. The original specification was written by Seven Inch Bread. 
Brainfuck translates particularly well into concurrent programming, which can be attributed to its simple design and execution procedure.
==Specification==
Weave consists of a list of Brainfuck-like programs being run concurrently. Each program is read command by command at roughly the same time (well... a command from a program at the top of the list is read before a command from a BF program below it, but they are all interpreted close to the same time)
Each thread has its own private array, which only it has access to, as well as access to the public (or global) array. The private array allows separation of concern and local scoping, while the global array allows sharing of data.
===Syntax===
A ! denotes the beginning of a thread, while a ; marks the endpoint.
 !<thread1>;!<thread2>;!<thread3>; ... ...
For readability, it is sometimes desirable to use newlines to separate the threads as well...
!<thread1>;
!<thread2>;
!<thread3>;
...
...
This is useful to imagine the order of events as they occur.
The following are commands that may occur in the body of a thread:
 > - Increment the array pointer
 < - Decrement the array pointer
 + - Increment the value of the pointed cell of the current array (see ~)
 - - Decrement the value of the pointed cell of the current array
 . - Output the ASCII value of the pointed cell of the current array.
 , - Store user input in the pointed cell of the current array 
 [ - If current cell is 0, skip to the corresponding ]
 ] - if the current cell is not 0, return to the corresponding [
 
 ~ - Toggle between the global or private array.
All characters outside of a thread are ignored, and all characters in a thread that aren't commands are treated as a NOP.
==Computational class==
Because brainfuck is a subset of Weave, it can be easily proven that Weave is a Turing-complete language.
==Implementations==
weave.rb is a ruby interpreter for Weave (and Brainfork and pbrain and brainfuck). Note that this implementation uses only semicolons as thread spawn points, as the exclamation mark(!) is used in brainfuck to attach input to the tail of a program.
Category:Languages
Category:Implemented
Category:Brainfuck derivatives
Category:Turing complete
Category:Concurrent programming
Category:2007
Web framework list

List of esoteric web application frameworks. Most of these are fully functional web frameworks that aren't about making the coder's life easier. Often they are a response to the hype wave surrounding some technologies (such as Ruby on Rails).
==Frameworks for esoteric languages==
* INTERCAL: INTERCAL on Interstates
==Esoteric frameworks for ordinary languages==
* 
* DOS on Dope (Batch files)
Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee Python interpreter

:
import sys
while 1:
 code=input()
 if code=='Start epidemic':
 break
acc=0
while 1:
 code=input()
 if code=='Infect person':
 acc+=1
 if code=='Deinfect person':
 acc-=1
 if code=='Bulk infect':
 ch=sys.stdin.read(1)
 acc=ord(ch)
 if code=='Check number of infections':
 print(chr(acc),end=)
 if code=='Bulk deinfect':
 acc=(1 if acc>0 else 0)
 if code=='Skip next if no one infected':
 input()
 if code=='Delevop vaccine':
 break
Category:Implementations