nyuuzyou/wikis huggingface dataset:
Where is my esolang?

yet another esolang by islptng
==Syntax==
i'm too busy to write detail here
where is my [name]? # define variable
I've forgot where I put [name] for the [number][st/nd/rd/th] time! # name <- number
let me think about it. after I used my [name] the last time... # while [name] > 0
...a-ha! it's there! # end while
it was [time]. # define label
what did I do at [time]? # goto label named [time]
# 'wait.' take the one used above as an argument
wait. what about my [name]? # [wait] - [name]
wait. is my [name] here? # name <- wait
===I/O===
mobile handles i/o 
reading it calls a character input 
writing to it outputs the value in ASCII
==Examples==
Print Hi! (too lazy to write Hello, world!)
 where is my h?
 I've forgot where I put my h for the 72nd time!
 wait. is my mobile here?
 where is my i?
 I've forgot where I put my i for the 105th time!
 wait. is my mobile here?
 where is my exclamation?
 I've forgot where I put my exclamation for the 33rd time!
 wait. is my mobile here?
Category:Languages Category:2024 Category:Pseudonatural Category:Unimplemented
WhimsiCode

WhimsiCode is invented by PSTF and his ChatGPT.
This Esolang has a lot of emoji as its command.
== Syntax ==
WhimsiCode uses a combination of emoji and ASCII characters for its syntax.
Each line of code must end with a smiley emoji :) to be considered valid.
== Variables ==
Variables in WhimsiCode are represented by random combinations of fruit emojis.
For example, 🍎 represents a variable named "apple" and 🍌 represents a variable named "banana".
== Control Flow ==
WhimsiCode uses a unique control flow structure called "Magical Forest".
The Magical Forest consists of trees represented by 🌳 emoji.
Code blocks are executed only if the programmer manages to find a hidden 🌟 emoji within the Magical Forest.
== I/O Operations ==
Input is taken using a 📷 emoji, which prompts the user to take a picture of their desired input.
Output is displayed using a 🎥 emoji, which shows a short video clip of the program's result.
== Arithmetic Operations ==
WhimsiCode uses unconventional arithmetic symbols. For instance, 🌽 represents addition, 🍇 represents subtraction, and 🍉 represents multiplication.
== Example ==
=== A+B Problem ===
🌳 find 🌟
📷 🍎
📷 🍌
🍏 = 🍎 🌽 🍌
🎥 🍏 :)
I think pseudo code is this: 
start();
input a;
input b;
c = a + b;
print c;
exit();
== Note ==
Please note that WhimsiCode is purely fictional and designed to demonstrate the concept of an esoteric programming language. It may not be practical or useful for real-world programming tasks.
== Turing Completeness ==
WhimsiCode language described above is not Turing-complete. It lacks essential features and constructs necessary to achieve Turing-completeness, such as loops or conditional statements. WhimsiCode is intentionally designed to be esoteric and whimsical, focusing more on unconventional syntax and control flow rather than practicality or computational power.
== Categories ==
Category:Languages
Category:2024
Category:Unknown computational class
Category:Unimplemented
Category:Generated by AI
WhimsyScript

= WhimsyScript =
== Overview ==
WhimsyScript is an esoteric programming language designed to bring a touch of magic and whimsy to coding. Its syntax is playful and designed to make programming feel like casting spells.
== Basic Commands ==
* `*twinkle*` - Start of the program
* `*shine*` - Print command
* `*sparkle*` - Addition
* `*glisten*` - Subtraction
* `*glow*` - Loop
* `*wink*` - End of the program
== Example Programs ==
=== Hello World ===
 
*twinkle*
*shine* "Hello, World!"
*wink*
 
=== Addition ===
 
*twinkle*
*shine* 4 *sparkle* 3
*wink*
 
=== Looping ===
 
*twinkle*
*glow* 3
 *shine* "Looping!"
*wink*
 
WhimsyScript aims to make programming an enchanting experience, blending creativity with code. CodePhantom (talk)
Whirl

Whirl is an esoteric programming language invented by Sean Heber (2004), with only two instructions, 0 and 1. These instructions rotate the Operations Ring and the Maths Ring, each of which has 12 sectors. The language therefore has 24 actual commands. The task of remembering the current orientation of each ring is left to the programmer.
An example program that reads two integers from standard input, adds them together, and prints the result:
 0110010000110001100010011001100011110000011100
Whirl is an example of a turning tarpit.
==See also==
* Fortuna
==External resources==
* 
* Blog post about a Whirl compiler written using LLVM: 
Category:Languages
Category:Turing tarpits
Category:Turning tarpits
Category:Implemented
Category:Low-level
Category:2004
Whoeverscripts

WhoeverScripts is an esoteric programming language made by WhoeverKnew123 which was designed to have weird syntax.
This language is not turing complete.
File extensions are made up, they're not implemented; It's interpreted in Scratch, it's obviously not gonna support file extensions. (Except .sb3, .sb2, .sb, .sprite3, .sprite2, and .sprite.) 
==Syntax==
On the interpreter, the syntax goes like this:
 <command>;
Then a dialog appears associated with the command.
==Examples==
All the dialogs are gonna be seperated with the colon sign. :
===Hello World===
 print; : Hello World!
===Cat===
Since this language doesn't have input, it's gonna print whatever text you type in.
 print; : The input text goes here...
===Find the definition of the word "code" (Definitely useless)===
 define; : code
==External Resources==
Scratch Interpreter
Category:Languages
Category:2020
Category:Implemented
Whole

Whole is an esolang invented by User:None1. It is a version of 🕳️ that uses English letters.
==Commands==
Whole 🕳️ Corresponding word
_______________________________
h 🕳️ hole
q ❓ question
e ❗ exclamation
w ⚠️ warning
===Variants===
Gaură is a variant of Whole that uses letters picked from Romanian words instead of English ones:
Gaură 🕳️ Corresponding word
_______________________________
g 🕳️ gaură
î ❓ întrebare
e ❗ exclamare
a ⚠️ avertisment
==Examples==
===Cat===
Normal Whole:
 {h}
Gaură variant:
 {g}
===Hello World===
Normal Whole:
 q*"Hello World!"*
Gaură variant:
 î*"Hello World!"*
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:2025
WholesomeFuck

:"This Warms My Heart" --Dtp09
WholesomeFuck is a language created by User:Dtp09. It is a brainfuck equivalent, and uses emoticon faces seperated by spaces as commands. Specifically, emoticon faces with greater-than and less-than symbols. The idea was thought up one night between me and my friend when we were joking around about how excessively we used to use the emoticon faces, and how many variations of the face there were that you could make an esolang of them.
You may technically run code that isn't seperated by spaces, but I wouldn't dare to try it.
= Commands =
WholesomeFuck	brainfuck equivalent
:> 	>
:>> 	+
:< 	<
:<< 	-
;> 	]
;>> 	,
;< 	[
;<< 	.
= Programs Translated from brainfuck =
== Hello, World! ==
 :>> ;< :<< :<< :> :<< ;< :> :> :>> :> :<< :<< :<< :<< :<< :< :< ;> :< :<< :<< :< :<< :<< :<< ;> :> :<< ;<< :> :> :> :>> ;<< :> :> ;<< ;<< :>> :>> :>> ;< ;<< :> ;> :< :< :< :< ;<< :>> :>> :>> ;<< :<< :<< :<< :<< :<< :<< ;<< :< :< :<< ;<< :> :> :> :> :>> ;<< 
== Cat ==
 ;>> ;< ;<< ;>> ;>
= Implementation =
Written in JavaScript here.
Category:Languages
Category:Turing complete
Category:Turing tarpits
Category:Cell-based
Category:Brainfuck equivalents
Category:Thematic
Category:Implemented
Category:2022
Whopper

Whopper is a stack-based language created by User:hyperdawg. It was created in python in under 100 lines of code.
=Commands=
PSH <number>	pushes <number> to the stack
POP 	pops the top value off the stack and prints as a number
PPC 	pops the top value off the stack and prints as an ASCII character
INP 	gets user input and pushes it to the stack
HLT 	halts the program
ADD 	pops two top values off stack, then pushes the sum
SUB 	same as ADD, but minus
MUL 	same as ADD, but times
DIV 	same as ADD, but divided
MOD 	same as ADD, but modulo
NLN 	prints a newline character
comments are defined by: 
: <comment> 
there MUST be a space between the : and the comment
=Programs=
==hi==
 : hi
 
 : Print the letter 'h'.
 PSH 10
 PSH 10
 MUL
 PSH 4
 ADD
 PPC
 
 : Print the letter 'i'.
 PSH 10
 PSH 10
 MUL
 PSH 5
 ADD
 PPC
 NLN
==cat==
: cat
INP
POP
==Interpreter==
* Common Lisp implementation of the Whopper programming language.
Category:Languages Category:Low-level Category:Stack-based Category:Implemented
Why Does This Towel Smell Different Each Time I Use It

Why Does This Towel Smell Different Each Time I Use It is an esolang created by User:LarhoCherqi, with other names being WDTTSDETIUI or Towellang. WDTTSDSETIUI's data structure consists of infinite stacks and a register called mem. mem starts at 0 and can be used to replace any value name in a command.
== Commands ==
Command 	Meaning
make X 	makes a new empty stack called X
push A X 	pushes the value A onto the stack X
pop X 	pops the top value of stack X
towel A B	generates a random number between A and B and sets mem to this number
print X 	prints the top value on stack X as a number
letter X 	prints the top value on stack X as an ASCII character
add X 	adds the top value of stack X with mem and stores the result back into mem
input 	gets one byte of input from the user and overwrites mem with it
while X 	if the top value of stack X and mem are equal, jump to the matching end command
end 	if the stack specified in the matching while's top value and the value of mem aren't equal, jump back to the matching while command
Note: print and letter commands can have mem as parameters.
== External links ==
A compiler for WDTTSDETIUI has been made by the esolang's creator: WDTTSDETIUI Compiler
Category:Languages Category:Stack-based Category:2021 Category:Unknown_computational_class Category:Implemented
Why tho

why tho is a esolang created by User:Yayimhere and is inspired by Lambda calculus and Fractran.
== How it works ==
The start of the program is a two lambda calculus expression (the first one is xn, and the second one is xm), each encased by square brackets.
The rest of the program consists of a list of lambda calculus expressions(all must be encased by normal brackets). Now the program sees if there is a lambda calculus function, f, such that when f is applied to xn, it evaluates xm.
If so, xn will be set to f, and xm will be set to xn. Every iteration of this, it will print xm, and f. 
if two functions are valid, it will set xn to the first function with input as the second function
If f cannot be found, xn will be added to the list, and xm will be swapped with xn. 
the program halts if xn=xm or xm=f. 
Why tho has input that can replace xn, By simply replacing the expression with µ
== simple example ==
heres a simple example:
 [λx. x] [λx. y] (λx.(x y)) (λx. x) (λx. λx. y)
 f = λx. λx. y
 Beta reducing '(λx. x)' into '(λx. (λx. y))'
 β > (λx. y)
 xn is equal to (λx. y)
 now:
 xn = λx. x
 xm = λx. λx. y
 f cannot be found
 add xm to the list:
 (λx.(x y)) (λx. x) (λx. λx. y) (λx. λx. y)
 do the swap:
 xn = λx. λx. y
 xm = λx. x
 f cannot be found
 ...
the loop continues
== computational class ==
ok. heres how to represent any expression(here the expression is A) in lambda calculus proving why tho TC. then the program would become:
 [(λx.x)] [A] (λx.x A)
yea that simple. note that only the first iteration of why tho is considered for computation
== see also ==
* Fractran
* Lambda calculus
Category:Languages Category:Functional paradigm Category:Unimplemented Category:Low-level Category:Turing complete Category:Turing tarpits
Whyfuck

Whyfuck is confusing derivate of well-known esoteric programming language Brainfuck. It shares brainfuck's possibilities and adds some new ones, but makes programming annoying and slow, though you could create a script to produce code. (And that is cheating!)
== Working Mechanism ==
Whyfuck uses 10 commands whose 8 is shared with brainfuck with 2 extra commands, giving small addition to command arsenal. Syntax otherways is same.
Brainfuck	Whyfuck	Meaning
> 	0 	move selector into next cell in tape
< 	1 	move selector back in tape
+ 	2 	increase value of current cell by 1
- 	3 	decrease value of current cell by 1
[ 	4 	jump to next corresponding ] if cell value is zero
] 	5 	jump back to corresponding [ if cell value is zero
. 	6 	output current cell value as corresponding character
, 	7 	input user-given character as corresponding integer value into current cell
 	8 	skip next command
 	9 	reverse read direction
But, as this would be way too easy, each character is crypted into new one, with this python-syntax function:
 str((number+1)*(number_index_in_code+1)*71)[-2]
Meaning, that each number is different, depending on it's position in code. You must type the code the way that output does the things you ordered it to. 
So a raw code which simply looks like this without crypting:
 0422205
Will look like this after crypting, which is then executed using those number commands:
 7135628
And we can easily make script which creates 'true' output values:
 | index:
 0 | 7 4 1 8 5 2 9 6 3 1 8 5 2 9 6 3 0 7 4 2 9 6 3 0 7 
 1 | 4 8 2 6 1 5 9 3 7 2 6 0 4 8 3 7 1 5 9 4 8 2 6 0 5 
 2 | 1 2 3 5 6 7 9 0 1 3 4 5 6 8 9 0 2 3 4 6 7 8 9 1 2 
 3 | 8 6 5 3 2 0 8 7 5 4 2 0 9 7 6 4 2 1 9 8 6 4 3 1 0 
 4 | 5 1 6 2 7 3 8 4 9 5 0 6 1 7 2 8 3 9 4 0 5 1 6 2 7 
 5 | 2 5 7 0 3 5 8 0 3 6 8 1 3 6 9 1 4 6 9 2 4 7 9 2 5 
 6 | 9 9 9 8 8 8 7 7 7 7 6 6 6 5 5 5 4 4 4 4 3 3 3 2 2 
 7 | 6 3 0 7 4 0 7 4 1 8 4 1 8 5 2 8 5 2 9 6 2 9 6 3 0 
 8 | 3 7 1 5 9 3 7 1 5 9 2 6 0 4 8 2 6 0 4 8 1 5 9 3 7
== Examples ==
===Hello World===
 865320875485976421926431086532087582593857598233308653207454217768159864310865320871340972061728994051627097114
===Ascii MAchine===
Loop which counts numbers to infinity and prints the matching symbol
 35376
Category:Languages Category:Low-level Category:Brainfuck derivatives Category:Cell-based
Wierd

Wierd is a graphical language developed by Chris Pressey, Ben Olmstead, and John Colagioia, in 1997.
==Etymology==
The name "Wierd," commonly mistaken for a spelling error or a typo, actually comes from a fusing of the words "weird" and "wired." It is often pronounced like the English word "wired", but with extra stress or lengthening of the diphthong, so that it sounds more like "why-eared" ([ˈwaɪ.iɹd] or [ˈwaɪ.ʔiɹd]).
==Syntax and Semantics==
In Wierd, there are only two symbols: whitespace and everything else. Non-whitespace characters are followed in lines (starting in the top left corner, going southeast), and when a turn needs to be made to keep on the line, an instruction is executed, based on the angle that the turn required. In the following table, from the spec, it is not clear if these angles are meant to be turns to the left (counterclockwise) or to the right (clockwise); however, the first interpreter running on the first example program suggests that they are turns to the left.
 0 degrees NO: No operation, continue as normal.
 45 degrees P1: Push a data value of 1 onto the stack.
 90 degrees IF: Pop the stack. If the value is zero, continue
 executing as normal. If the value is nonzero,
 however, reverse direction.
 135 degrees GP: Pop the stack. If the value is zero, pops the next
 two items from the stack, retrieves (gets) the
 value stored at the coordinates specified by these
 values (x, then y), and push it onto the stack. If
 the first value was nonzero, however, takes the
 value stored below the coordinates on the stack,
 and stores (puts) it at the coordinates.
 180 degrees QU: Jump the gap, if possible. Otherwise, terminate.
 225 degrees IO: Pop the stack. If the value is zero, read a
 character from input, pushing it onto the stack.
 If the value was nonzero, pop the stack, and print
 the value to output as a character.
 270 degrees IF: See 90 degrees. Included for flexibility.
 315 degrees SB: Subtract the top of the stack from the value
 beneath it, popping both values, and pushing the
 result.
(from the Wierd spec).
According to John Colagioia, it was not supposed to be legal to cross wires, but several Wierd programs are in circulation that rely on this.
Wierd was inspired by Brainfuck and Befunge.
==External resources==
* 
* Wierd files
Category:Two-dimensional languages
Category:Stack-based
Category:Unknown computational class
Category:Implemented
Category:Low-level
Category:1997
Category:Languages
Wierd Machine

The Wierd Machine is a theoretical computer science construct of a 2-cell machine which can implement the cat utility, can(theoretically) implement the Truth-machine and do Flow-down arithmetic (Another theoretical computer model by the author).
====Is Wierd a typo?====
The 'Wierd Machine' is weird, but not quite. Therefore, it is called the 'Wierd Machine'. So no, it is not a typo.
====How it works====
There are 6 instructions: I,H, Q, C, L and J 
Here is a Table of meaning for these functions:
I	Input
Q	Output primary cell
C	Compare cells.
L	Loop for amount of time in loop counter
J	Jump
H	'Hardware' input
====Truth-machine====
In theory, it's possible to create a simplification of the machine:
ICHQL∞
We get input, compare it with the 2 empty 0 cells, take that as input, Print that forever.
Input=1:
1111111111111111111111111111111111....
Input=0:
0000000000000000000000000000000000....
So, we just need a 'If' statement to make the truth-machine!
Details of the Truth-complete Wierd Machine:
Statements = I, F, C, H, L, Q
F=if
Code of Truth-machine:
ICHF0JQI1QL∞
Woohooo! Yahoo! Hurray! A Truth machine in 5 statements! Beat that!(not the shortest tho)
====Examples====
Wierd Machine-1:
Cat program:
IQ
Input+1:
IPQ
Wierd machine-2:
Doubling
IPLIQ
====References====
Truth-machine- Wierd machine was created to make a solution to it.
Category:2018
Category:Unknown computational class
Category:Languages
Wiki/pedia/.org

Wiki/pedia/.org(pronounced Wikipedia dot org) is a esolang created by User:Yayimhere based on the Philosophy Game
== semantics / syntax ==
the program structure:
 / wikipedia page name(in 19.30, 5. september 2024 denmark time) / n
this will go to that page and check:
* what is the nth link excluding:
:* exclude the language 
:* exclude Help pages
:* thats it
iterate this until you get into a page with no links OR that the page is philosophy
== examples ==
Infinite loop:
 / Philosophy / 1
Category:Languages
Wiki/wiki/wiki/wiki/wiki/wiki/

you can also come up with how the commands work, too
every command is seperated by a /.
command 	what it does
esolangs.org	?
wiki 	?
User: 	?
Esolang: 	?
Category: 	?
File: 	?
Template: 	?
Talk: 	Print function.
==Examples==
=== Hello, world! ===
 Talk: Hello, world!
I deliberately made the text to be output a link.
Category:Languages Category:Works-in-Progress
WikiFuck

WikiFuck is a BrainFuck derivative created by User:GoodCoderBBoy (inspired by User:David.werecat) that does exactly what you expect it to do.
Command 	Description
</nowiki> 	Move the pointer to the right
</code> 	Move the pointer to the left
}} 	Increment the memory cell at the pointer
{| class="wikitable"	Decrement the memory cell at the pointer
* 	Output the character signified by the cell at the pointer
{{WIP}} 	Input a character and store it in the cell at the pointer
=== 	Jump past the matching 
 if the cell at the pointer is 0

 	Jump back to the matching === if the cell at the pointer is nonzero
All other characters should be considered comments and ignored.
==Examples==
===Hello, World!===
 }}}}}}}}===</nowiki>}}}}===</nowiki>}}</nowiki>}}}</nowiki>}}}</nowiki>}</code></code></code></code>
 {| class="wikitable"
</nowiki>}</nowiki>}</nowiki>{| class="wikitable"</nowiki></nowiki>}===
 </code>
</code>{| class="wikitable"
</nowiki></nowiki>*</nowiki>{| class="wikitable"
 {| class="wikitable"{| class="wikitable"*}}}}}}}**}}}*</nowiki></nowiki>*</code>{| class="wikitable"
 *</code>*}}}*{| class="wikitable"{| class="wikitable"{| class="wikitable"{| class="wikitable"
 {| class="wikitable"{| class="wikitable"*{| class="wikitable"{| class="wikitable"
 {| class="wikitable"{| class="wikitable"{| class="wikitable"{| class="wikitable"{| class="wikitable"
 {| class="wikitable"*</nowiki></nowiki>}*</nowiki>}}*
==Implementations==
===Python3===
*Original
Category:2021
Category:Turing tarpits 
Category:Low-level 
Category:Cell-based 
Category:Implemented 
Category:Languages
Category:Brainfuck derivatives
Category:Turing complete
Wikipedia is stupid and dumb

wikipedia is stupid and dumb is an esolang designed by User:Tommyaweosme based on his hatred about wikipedia lying about himthey took over my home page and turned it into a false accusation rabbit hole :( https://en.wikipedia.org/wiki/User:DA_AWESOME_BOI. The title is lowercase because, in his opinion, wikipedia does not deserve uppercase.
Proof with a User:Cinnamony-style quote:
 wikipedia is so horrible it doesnt deserve uppercase.
== Commands ==
 wikipedia - moves cell pointer right
 mediawiki - moves cell pointer left
 is - asks for user input
 stupid - increments cell at pointer
 and - outputs as ascii
 dumb - decrements cell pointer
 hahaha - goes to take that if cell at pointer is 0
 take that - goes to hahaha if cell at pointer is not 0
 idiot - squares cell
 moron - square roots cell and rounds down
 i hope the servers go up in flames - clears cell
 die die die! - duplicates cell to next cell
There are infinite cells and every one is limitless.
== Cat ==
 stupid hahaha is and take that
== Truth machine ==
 is moron dumb dumb dumb dumb dumb dumb dumb hahaha
 stupid stupid stupid stupid stupid stupid stupid idiot and
 moron dumb dumb dumb dumb dumb dumb dumb
 take that
 stupid stupid stupid stupid stupid stupid stupid idiot and
Category:Languages
Wikiplia

Wikiplia was an attempt of Tom Murphy VII (tom7) to create "The Free Programming Language That Anyone Can Edit". While created as a joke for the SIGBOVIK 2007 conference, it was really implemented, but unfortunately the wiki it used is now dead. However, documentation and the source code remains.
Wikiplia has a small core language and interpreter, including a simple S-expression parser, a functional core language evaluator, a version-controlled file storage, and a bare web interface. On top of this was built a simple compiler to the core language, and a web-based user interface. 
==External resources==
*Paper about Wikiplia (PDF), dated 1 April 2007
*Wikiplia slides (Flash) for the talk at the SIGBOVIK 2007 conference
*Some blog discussion by the perpetrator
*SIGBOVIK conference
*source code (including the database)
Category:LanguagesCategory:2007
Wimpmode

A wimpmode is a mode or variation of an esoteric programming language which makes it less difficult to code in. While generally frowned upon, they are sometimes invoked as a prerequisite for getting any programs written at all.
The first wimpmode was in INTERCAL. A wimpmode for notating numbers in decimal was once suggested for Befunge — in fact many of the "fingerprint" extensions to Funge-98 had wimpmode-like semantics. The @ stack in Kipple is along the same lines. In terms of entire languages, Dis can be seen as a wimpmode for Malbolge.
Category:Concepts