nyuuzyou/wikis huggingface dataset:
Python But WORST!!

Python but WORST!! is designed by Mihai Popa.
It's just like Python But WORST, but if the program doesn't have any error, it will cause a BSOD (on Windows) or forks subproceeses on Linux or macOS. If the program raises a error, it will instead format your OS partition.
== Examples ==
=== Hello, world! ===
print("Hello, world!")
Or this:
print("Hello, world!") # Not a error
hello("Hello, world!") # Undefined
1/0
=== Truth Machine ===
 a = input()
 if a == "0":
 print(0)
 1/0
 else:
 while 1:
 print(1)
 1/0
== See also ==
Python But WORST
Category:Languages
Category:Turing complete
Category:Unimplemented
Python But WORST, at least in Esolang Wiki

Python But WORST, at least in Esolang Wiki is designed by PSTF.
It just Python, but whether your program will raise error or not, MEMZ.exe and Windows XP Horror will execute on your computer immediately.
== Examples ==
All of the sample programs have a side effect: they will completely scrap your computer.
=== Hello, world! ===
 print("Hello, world!")
=== Truth Machine ===
 a = input()
 if a == "0": print(0)
 else:
 while 1: print(1)
== Implementations ==
This programming language is too uncomputeble to implement, and even if you could implement it, it would be illegal to show an interpreter of this language, so no one can or should implement this esoteric language.
== See also ==
Python But WORST!!
Category:Languages
Category:Turing complete
Category:Uncomputable
Category:Joke languages
Python but even worse

Python but even worse is like Python, but it deletes its code if it doesn't raise an error.
In Python, if a wrong command is executed, it will raise an error, but in this esolang, the program will halt silently.
It's invented by User:None1.
==Example Programs==
===Hello World===
 print("Hello World!")
 print(x) # Note that X isn't defined
===Cat Program===
 import sys
 print(sys.stdin.read())
 a = 1 / 0
===FizzBuzz===
for i in range(1,101):
 if i%3==0:
 print("Fizz",end="")
 if i%5==0:
 print("Buzz",end="")
 if i%3 and i%5:
 print(i,end="")
 print()
a = 6128576217835128956872345782136587236578132651872365823164821587623951293846125778123658723148712635231513279 / (0 / 0)
==Interpreter in Python==
import os,sys
with open(sys.argv[1],"r",encoding="utf-8") as f:
 c=f.read()
try:
 exec(c)
except:
 pass
 """
 Indicates that the error at the end is ignored
 """
else:
 os.remove(sys.argv[1])
Note that it is also possible to write an interpreter in C/C++ using Python C APIs.
==See also==
* Python But Bad
* Python but WORST
Category:Languages
Category:Turing complete
Category:Implemented
Python but it's trash

I am User:LEOMOK, here to make Python trash.
==How I made it trash==
This programming language is exactly the same as normal Python, but:
# The underscore _ is not allowed, even in strings. Same for expressions and escape codes that produce an underscore, such as \u005f.
# All integers are 32 bit. There are no floats. Also, the only numeric literal is 0.
# math functions return truncated results. math.pi is 3.
# The only boolean is True. Expressions that evaluate to False are undefined behavior.
# All errors are called Error. That means no TypeErrors, no SyntaxErrors, just Error.
# The == operator is undefined.
# String literals may not contain whitespace, unless if that’s all it contains.
# Lists may not contain three instances of the same item, unless the list contains exactly three items.
# The stringification of None is the lyrics of Rick Astley’s Never Gonna Give You Up.
# The only variable names are foo, bar, baz and single characters.
==Examples==
Hello, world!
 print("Hello,"+" "+"world!")
Never Gonna Give You Up
 print(None)
Unbounded integer class (since PBIT’s integers are only 32 bit, does not support negative numbets)
 class I:
 self.v = [] #initial value 0
 def i(self): #increment
 return I(self+)
 def d(self): #decrement
 return I(self[not 0:])
Category:LanguagesCategory:Joke languagesCategory:Turing completeCategory:High-levelCategory:Unimplemented
P→P'

P→P' pronounced P to P prime is a esolang created by User:Yayimhere
== syntax ==
P→P' is a subset of Underload based on its notation. it uses the P, L, R, Q, {}, and ' notation stuff converted to underload code, like this:
 {x} = <x>
 x' = x^
 x = *x
 Q = ;
 L = %
 R = .
 (x) = [x]
 where x must be in P, L, R, Q, {}, and ' notation stuff(with the transtitions). so x described in BNF:
 x = [x] | *x | ; | ~ | . | % | x^ | <x>
and these are the commands(these are the only ones we have other than the P, L, R, Q, {}, ' stuff):
 ^ = `
 * = +
 : = @
 ! = ·
all programs for input to the notation is made up like this:
 : = @ #still the same
 (…) = ´…´
 ^ = %
they must be encased in |…| and will not be ran as a program nor is allowed to be in a program normally. theres also _x which will first run the underload program x(only with ()^:*) each with a different stack until it finds one that halts(just be running them) and pushes its stack then for every succsesfull stacl it pusehs some stacl elements that would make all of the stack elements be deleted
Category:Languages Category:Unknown computational class Category:2024 Category:Unimplemented
P𝐋𝕆𝕺𝑷Ӌ

P𝐋𝕆𝕺𝑷Ӌ or PLOOPY is an esolang created by User:Yayimhere based on a joke on Failboats streams
== semantics and syntax ==
=== syntax ===
the "fonts" are defined as:
 [what A will be replaced[space]with what b will be replaced with[space]ect.]
(where [space] is replaced with a space) the font numbering is just line order. the words come after the fonts(line wise). the base string is the last line of the program
==== the alphabet ====
 ABDCEFGHIJKLMNOPQRSTUVWCXYZabcdefghijklmnopqrstuvwcxyz1234567890+´<!"#€%&/()=?`>¡“§£∞™¶[]≠±'≤¯”$¢‰˜\{}≈¿⁄≥^¨*'º~@°∑é®†¥ü|œπ‘ªß∂ƒ©«‹∆¬äöΩ…ç√∫ñµ‚·–•˚ÉÂ‡ŸÜıŒ∏’Êˇ˘ﬁÁ»›˝ﬂÄÖ¸˙Ç◊ËÑ˛„÷—§$'
=== semantics ===
so what the program does is it finds a string(one of the words, detected top to bottom) in the base string and then replaces each induvidual char with the ones of the first font. then second cycle its second font and so on. then next cycle of the program it goes to next font(yes were detecting the words even after font application). then ´the third one and when the last font has been cycled.
Category:Languages Category:2024 Category:Unknown computational class Category:String-rewriting paradigm
Q

: Not to be confused with the APL-like non-esoteric language Q by Arthur Whitney
The Qabalah language (Q) is not only an esoteric programming language, but it is also an occult programming language. The first version of the language was conceived while in bed with my mobile device and a C compiler app, and the program was a fully functional interpreter in 112 lines - with only a very narrow set of operators, and a brainfuck type of variable selection. The code was then transferred to my computer, and the language started developing into what it is today.
==Language overview==
When Q is run, it creates an environment containing 22 variables, and a stack for 55 blocks; this is what the programmer can make use of. The variables are accessed with latin or Hebrew (UTF-8 unicode) letters, one letter names one variable, and naming a variable places it in the slot V0 and pushes the previous variable to V1, which in turn is pushed to V2 (there is no V3). These three slots are then operated upon by the operators. All letters are references to the variables, therefore some variables are shared by many letters, e.g. O, U, V point to the same variable, named Vav.
There are 22 operator signs, !#%&'()*+-/:<=>?@[]^|~, which can be used as single operators, or be combined into double operators with additional functionality, e.g. ++, >= etc. Some combined operators are recognised from other languages, and others are entirely unique to Q, e.g. -+ which is an operator for abs (a = abs(a);).
==Examples==
===Hello, World!===
A Hello world-program, creating a string and printing it:
'Hello, World!' &
Another way, print directly:
?>Hello, World!
===Fibonacci sequence===
A program printing the Fibonacci sequence, starting with zero:
 A 'Fibonacci &C:^&D\' /* create string */
 B10 C0 D0 E1 F+ /* initialise variables */
 [ /* block */
 BC++ <= ? /* if(++C <= B) */
 A& /* output A */
 ED: FE: DF+: /* D = E, E = F, F += D; */
 @< /* loop from start of block */
 ]
Above program will output:
 Fibonacci 1: 0
 Fibonacci 2: 1
 Fibonacci 3: 1
 Fibonacci 4: 2
 Fibonacci 5: 3
 Fibonacci 6: 5
 Fibonacci 7: 8
 Fibonacci 8: 13
 Fibonacci 9: 21
 Fibonacci 10: 34
==External resources==
* Complete documentation of the language
* About the Qabalah
===Notable implementations===
* Q interpreter implementation
Category:Turing complete 
Category:Implemented 
Category:Languages
Category:2016
Q-BAL

Q-BAL is language designed by Ben Yackley and Michael Shulman. It attempts to show what a stack-based language would be like if it were based on queues instead. Q-BAL is, in fact, an acronym for Queue-BAsed Language.
==External resources==
* Q-BAL specification
Category:Languages
Category:Unimplemented
Category:Queue-based
Category:Unknown year
Q-Ref

Q-Ref is a queue-based language invented by User:Zzo38, with the only data type being queues of references of queues. The variable names must follow the regular expression ([A-Za-z_][A-Za-z_0-9]*).
Commands are: (to use reference dequeued from the queue, prefix with #)
* A.B -- enqueue reference to B onto A
* [ commands ] -- loop
* <labelname> -- define label
* -labelname -- goto label
* A? -- exit loop if queue A is empty
* macroname(parameter) -- call a macro
* <macroname(code)> -- define macro (use $ to access parameter, % for a unique identifier for this invocation)
* A+B -- make a copy of B and enqueue the reference to the copy onto A
* /* comment */ -- comment
* number -- repeat the next command that number of times (if it comes before a macro, the entire macro is repeated)
Built-in macros for I/O:
* _outchar -- Output character by number given in parameter
* _outcharcount -- Output character by number of items in the queue given by parameter
* _outnumcount -- Output number of items in the queue given by parameter
* _inchar -- Enqueue a number of references to itself by the input character
* _innum -- Enqueue a number of references to itself by input number
Example to copy input to output until NULL:
 _inchar(x)
 [
 x? /* Quit if null */
 _outcharcount(x)
 [ #x? ] /* Empty it */
 _inchar(x) /* Input another character */
 ]
Example of a cyclic tag machine:
 Yes.Yes
 /* You must set List to the references of Yes and No */
 [
 /* First cycle */
 [ #List?
 List.Yes List.Yes List.No /* Change according to what value you want */
 No? ]
 /* Second cycle */
 [ #List?
 List.No List.Yes /* Change according to what value you want */
 No? ]
 ]
Category:Languages
Category:Unimplemented
Category:Queue-based
Category:2007
Category:Unknown computational class
Q47

Q47 is a speedlang made by Europe2048. Unlike the others, it isn't a statue - I can update this language, so stay tuned for them!
== Commands ==
=== v1.0 ===
Command	Description
0-9 	Pushes the corresponding value to the stack
+ 	Adds the top two values
* 	Multiplies
` 	Negates
/ 	Reciprocal
p 	Print as number
@ 	Print as character
i 	Take user input, and push result
action}	Conditional statements. Operators can be =, <, or >, all applied to the top 2 values of the stack.
=== v1.1 ===
Command 	Description
{times~action}	Repeats a statement a given number of times
; 	Jump back to the beginning of this statement
() 	Grouping, creates a new statement (when running, is ignored)
. 	Duplicates the top value of the stack
, 	Duplicates the second-to-top value
? 	Pops the top value from the stack
: 	Swaps the top two values
^ 	Exponent
== Examples ==
=== Hello, World! ===
 89*@48*1++@7+@@3+@49*1+3*`+56+4*@34*`+@56+5*+@64*+@3+@6`+@8`+@45*5*`+56+3*@
=== Truth Machine ===
 i{=0|0p}{=1|1(p;)}
== Time ==
Version	Commands	Examples	Total time so far
1.0 	2:06.36 	2:25.60 	4:31.96
1.1 	2:58.24 	0:32.18 	8:02.38
Category:Languages Category:Stack-based Category:Total Category:Unusable for programming
QFL

QFL is a Turing tarpit inspired by Iota and Jot. Basically it's a Iota with IO. 
== Features ==
* functional purity
* literate programming
* full unicode support
* minimalism (there are only two operations)
* weird IO model (different from monads and uniq types)
== Syntax ==
There are two combinators: fu (equal to λf.fSK) and bar (used for output). Keyword "fu" pushes the fu combinator to the top of a stack. Keyword "bar" pushes the bar to the stack. Keyword "~" pops two entities, say, a (the topmost one) and b from the stack, then pushes (ba) back to the stack.
== bar combinator == 
Bar combinator takes two arguments: a unicode character encoded as a Church numeral and a value of type RealWorld. It returns a universe where the character is printed.
== IO ==
There are no monads nor uniq types, so values with type RealWorld may be referenced many times. It means that there may be more than one RealWorld. Hence the program is executed in a quantum way: in a multiverse, rather than in a universe. One should perform a measurement to observe the output of a program. A measurement basically sends QFL VM to a one of the possible worlds.
== Input ==
Although there is no explicit syntax for input, runtime interaction with a QFL program is possible. Hint: you just have to appear in a world where the right input is already typed.
== Realization ==
Working realization and some examples are found there: https://github.com/i2l/QFL 
Category:Languages
Category:Turing tarpits
Category:Functional paradigm
Category:Implemented
Category:Nondeterministic
QKAS

You can vist QKAS's official website here.
QKAS was made in 2015 by a user simply known as "Prince". The idea of QKAS (Pronounced Kaz) is simple. Be as simple as possible. Although it only uses two main characters (+ and -) you can use all other character excluding letters normally.
Here's how it works, each - or + is equal to +1 to the right on the letter section of a QWERTY keyboard (Remember, the + and - only are for letters). For instance, q being the first letter on the qwerty keyboard is equal to -. w is equal to --, e is equal to ---, r is equal to ---- and so on. The same is with the uppercase letters, except you use + instead of -. So Q is equal to + and W is equal to ++. Hopefully you get it by now, if you don't the read it again. There is one more thing you must know, ALL punctuation stays the same. If you wanted to say Hi!, you would type ++++++++++++++++o--------! (o is the separator).
The first encoder was made by a user known as "_MysteriousMagenta_" and the first decoder was made by "Prince" himself (Although it was very bad).
==Examples==
Here is the Hello, World! program in QKAS:
 ++++++++++++++++o---o-------------------o-------------------o---------o,o o++o---------o----o-------------------o-------------o!
Here is the "Hello, World!" program in Brainfuck:
 ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
As you can see, it is simpler but longer.
Here is the "Hello, World!" program in Python2:
 print "Hello, World!"
And in Python3:
 print("Hello, World!")
==Implementations==
The following offers a simple implementation of QKAS in Common Lisp. The mapping of integers to keyboard characters is represented in a string lookup table, the first element of which, which would associate a superfluous zero count of - or +, is defined by a dummy space entry.
 (defparameter +LOWERCASE-CHARACTERS+ " qwertyuiopasdfghjklzxcvbnm")
 (defparameter +UPPERCASE-CHARACTERS+ " QWERTYUIOPASDFGHJKLZXCVBNM")
 
 (defun interpret-QKAS (code)
 "Interprets the QKAS CODE and returns ``NIL."
 (declare (type string code))
 (let ((position 0))
 (declare (type fixnum position))
 (symbol-macrolet ((character (the character (char code position)))
 (has-character (< position (length code))))
 (flet ((check-for-separator ()
 (when (and has-character (char/= character #\o))
 (error "Expected separator at position ~d instead of ~s." position character))
 (incf position)))
 (loop do
 (cond
 ((not has-character)
 (loop-finish))
 ((char= character #\-)
 (write-char
 (schar +LOWERCASE-CHARACTERS+
 (loop while (and has-character (char= character #\-)) count 1 do (incf position))))
 (check-for-separator))
 ((char= character #\+)
 (write-char
 (schar +UPPERCASE-CHARACTERS+
 (loop while (and has-character (char= character #\+)) count 1 do (incf position))))
 (check-for-separator))
 ((alpha-char-p character)
 (error "Error at position ~d: The letter ~s is not permitted." position character))
 (T
 (write-char character)
 (incf position)
 (check-for-separator))))))))
Category:Joke languages
QTTRPG

QTTRPG is a Quantum TTRPG that functions both as a Quantum Programming Language and as a TTRPG. All rules and such are still in Development and subject to change.
Functions of the Code - 
Pnt - Pointer
Dim - Dimesnsions
Int - Interger
Qub - Quibit
Mod - Dice Modifier
Pnt Commands - 
Pnt.+(dim) - Creates a new pointer in the requested dimension labeled as pointer[x]
Pnt.(dim).[pointervalue][< or >](int) - Moves Requested Pointer in the requested directions (int) amount
Dim Commands - 
Dim.+(dim) - Creates a new Dimension labeled as Dim[x]
Dim.-(dim) - Removes a Dimension 
Dim.@(dim) - Records the Binary Values of a Dimension. Labels text file as (dim)output
Int Functionality - 
Int is just intergers. That's it, you use them for stuff.
Qub Commands - 
Qub.H - Put a Qubit through a Hadamard Gate
Qub.M - Collapses a Superposition and Measures the Qub as an Int.
Qub.@ - Records the Value of a Quibit onto a Text file labeled as [qub](dim)output
Mod Functionality - 
Modifies the Dice by Multiplication on Attacks and Defense.
category:Languages
category:Unimplemented 
category:2020
category:Quantum computing
QWERTYUIOP

QWERTYUIOP is a semi-joke esoteric programming language created by Cinnamony. QWERTYUIOP is designed to look like keyboard mashing.
==Commands==
Q - Print ascii of memory slot
W - Clear memory slot to 0
E - Increase memory slot by 1
R - Increase memory slot by 10
T - Increase memory slot by 100
Y - Decrease memory slot by 1
U - Decrease memory slot by 10
I - Decrease memory slot by 100
O - Set memory slot to random number between -100 and 100
P - Print number of memory slot
A;; - Repeats code inside the ;s forever
S"" - If memory slot is less than 50 than run the code in the "s
D[[ - If memory slot is 50 or more than 50 than run the code in the [s
F - Terminate code
G - Repeat last command 2 times
H - Repeat last command 3 times
J - Repeat last command 4 times
K - Repeat last command 10 times
L - Print “lasagna”
Z - Quine, prints out “Z”
X - Prints the entirety of 99 bottles of beer on the wall
C - Prints out fizzbuzz
V - Asks for users number input and saves to memory slot
B - Skip the next command
N - Skip the previous command
M - Prints out the lyrics to Show Yourself, an Among Us animation
==Words==
 CINNA;MON;
This prints out Fizzbuzz, decreases memory slot (memory slot -100), skips the previous command (memory slot 0), skips the previous command (memory slot -100) and repeats printing the lyrics to Show Yourself (doesnt change the memory slot because the randomizer command is skipped).
 LA;S"A;GNA;;;;"
This prints out Lasagna, the memory slot is less than 0 so it repeats doing nothing forever (The repeat last command 2 times is skipped by an N, and even if it weren't skipped it wouldn't do anything)
 S"HOW" YOURS"ELF"
The memory slot is less than 0, so it can repeat the last command 3 times, which does nothing, set memory slot to random number between -100 and 100, and clears the memory slot. It then decreases the memory slot (memory slot -1), randomizes the memory slot from -100 to 100, decreases the memory slot by 10 (memory slot from -110 to 90), increases the memory slot by 10 (memory slot from -100 to 100), and does not run ELF. Oh wait, speaking of elves:
 ELF
This increases memory slot by 1, prints "lasagna", and terminates the code. How neat!
==How to do things==
===Print out a letter===
Let's say you want to print out the letter N.
The letter N's ASCII code is 078, so you would do this:
 WTUGYGQ
It clears the memory slot to 0, adds 100, subtracts 10 2 times, and subtracts 1 2 times.
===Other things===
Lets say, if the user inputted number is over fifty or equal to fifty, repeat printing out "lasagna" forever.
 VD[A;L;[
==Hello World script==
 WTUGYJGQWTEQWTEJGQQWTREQWRJEJQWRHEGQWTRGYQWTREQWTREJQWTRGYQWTQWRHEHQF
I might have made some errors.
==99 Bottles of Beer==
 XF
That's it. Just one command followed by an executor.
==Fizzbuzz==
 CF
I might have gotten a little bored...
==Truth machine==
There we go, an actual challenge.
 WVRRJYS"WPF"D[WEA;P;[
==Quine==
 Z
Too easy.
Category:Languages
QWERTY Keyboard Dot Language

................................ ................. ...................................
 ................................... .......................
The above dots say hello. I decided not to write all of Hello, World! because it would take too long. The way this programming language is written is quite simple: You put as many dots as there are keys on the keyboard that are printable characters up to the key you want (including itself). For example: .=` and ..=1 and ...=2, and so on. If you want to write a shifted character, you must use commas (,) instead of periods (.); for instance: ,,=!.
OK. now that I have gone over the output, I shall go over the programming.
This program is written as so: You tell the computer what you want it to do. If you want the computer to write onscreen "Merry Christmas", you write "Write Merry Christmas" but do it in the dots. If you want to computer to erase a file, write "Erase The file called ----" in dots, of course. If you want the computer to make you a cup of tea, write "Make me a cup of tea" in dots. The computer will try its best to do what you command, but I don't think it can make tea. The only time it won't try to do as you say is if you say "From now on let me type everything using the real characters rather than dots".
==Examples==
The following code prints Hello, World! to the standard output:
 ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, ................. ................................... ................................... ....................... .............................................. ................................................. ,,,,,,,,,,,,,,,, ....................... .................. ................................... ............................. ,,
==Interpreter==
* Common Lisp implementation of the QWERTY Keyboard Dot Language programming language.
Category:Languages Category:Joke languages Category:Output only Category:Implemented
QWOP

QWOP is an esolang by User:Rdococ. As the name suggests, it uses four characters: Q, W, O and P. All others are ignored....well, except when following the letters W and P.
== Overview ==
Q is a quine. Here is the shortest non-null quine:
Q
W is a conditional. If the input character is not equal to the next character, it will skip the next command:
Wxy
O is a loop. It will return the pointer to the last O, if one exists. Here is an infinite loop:
OO
P is a print command. It will print the next character rather than executing it:
Px
== Examples ==
=== Hello, world! ===
PHPePlPlPoP PWPoPrPlPdP!
=== Quine ===
Q
=== Truth-machine ===
OW1P1W1OW0P0
== Computational Class ==
The language does not support any form of storage, nor does it support nested loops. It is likely something in the range of a finite state machine, if not less powerful.
==Interpreter==
* Common Lisp implementation of the QWOP programming language.
Category:2017