nyuuzyou/wikis huggingface dataset:
Quests

Quests is the first Questa-based made language by User:ChuckEsoteric08.
==Syntax==
The following Extended Backus-Naur Form (EBNF) describes the language's syntax:
 program := [ command , { whitespaces , command } ] ;
 command := push | pop | increment | output | decrement | swap ;
 expression := integer | string | command ;
 push := "p" , "(" , expression , ")" ;
 pop := "<" , "(" , expression , ")" ;
 output := ">" , "(" , expression , ")" ;
 increment := "inc" , "(" , expression , ")" ;
 decrement := "dec" , "(" , expression , "," , expression , ")" ;
 swap := "sw" , "(" , ")" ;
 
 string := textCharacter , { textCharacter } ;
 integer := [ "+" | "-" ] , digit , { digit } ;
 whitespaces := whitespace , { whitespace } ;
 whitespace := " " | "\t" | "\n" ;
 textCharacter := letter | digit | "_" | "-" ;
 letter := "a" | ... | "z" | "A" | ... | "Z" ;
 digit := "0" | "1" | "2" | "3" | "4"
 | "5" | "6" | "7" | "8" | "9" ;
==Commands==
Command 	Function
p(x) 	Pushes x to top of the Questa
<(x) 	If x is 0, pops the element from the top. If 1, pops the element from the bottom
>(x) 	If x is 0, pops the element from the top and outputs it. If 1, pops the element from the bottom and outputs it
inc(x) 	If x is 0, increments the element on the top. If 1, increments the element on the bottom
dec(x,y)	If x is 0, jumps to the y-th command if top of the quest is zero and if it isn't decrement top of the questa, with the commands being indexed starting with zero (0). If x is 1 jumps to the y-th command if bottom of the questa is zero and if it isn't decrement bottom of the questa
sw() 	Swaps the elements on the top with the element on the bottom
x can't contain spaces, because these are utilized to separate commands.
==Examples==
===Hello World===
 p(HelloWorld) >(0)
===Goto===
The following example utilizes the dec command with the purpose of obviating the insertion of an element. After pushing the values “Hello” and 0 unto the Questa, the goto facility bypasses the pushing of the “World” string to its top by using the top 0 element for its navigation, thus popping and returning in the last step the top value 0 instead.
 p(Hello)
 p(0)
 dec(0,4)
 p(World)
 >(0)
==Turing-completness==
It is Turing-complete, beacuse it can simulate Szewczyk notation for Minsky machine with 2 registers like that:
MM 	Quests
Start	p(0) p(0)
A -1 	inc(0)
B -1 	inc(1)
A Y 	dec(0,Y+2)
B Y 	dec(1,Y+2)
==Interpreter==
* Common Lisp implementation of the Quests programming language.
Category:Languages Category:Turing complete Category:ImplementedCategory:Output only
Queue

A queue is a data structure sometimes used in esoteric programming languages.
== Operations ==
A queue works by the principle of First In, First Out (FIFO). What is enqueued onto the queue first, will be dequeued first. This leads to the operations ENQUEUE, which puts a value at the back of the queue, and DEQUEUE, which takes a value from the front, removes it, and returns it.
=== Additional Operations ===
In addition to ENQUEUE and DEQUEUE, there are a few other queue manipulation operations, many of which are the queue equivalent of stack operations, that queues can use that are generally accomplished through scalar variables.
The following table lists them, including the operation, its name, its traditional (or completely made up) laconic representation, its meaning, and an example in "Generic Queue Language" (GQL), a language used solely for example purposes.
Op 	Laconic	Name 	Meaning 	GQL
PEEK	N/A 	Peek 	Get the value at the front of the queue without removing it	Not possible due to the FIFO nature of queues
DROP	$ 	Drop 	Remove the value from the front of the queue and discard it	DEQUEUE;
ROLL	N/A 	Roll 	Move the value from the front of the queue to the back 	DEQUEUE→a; ENQUEUE a;
DUP 	: 	Duplicate	Duplicate the value at the front of the queue to the back 	PEEK→a; ENQUEUE a;
== Use in esolangs ==
Here are some examples of esoteric programming languages that use queues:
* Q-BAL works like a stack-based language, except using queues instead of stacks.
* Qdeql uses a single queue.
* NULL uses three queues.
* Fueue uses a single queue.
* 0815 uses a single queue and 3 registers.
* Bitwise Cyclic Tag uses two queues, one for program and one for data.
== See Also ==
*:Category:Queue-based
*Stack
*Deque, a double-ended queue
Category:Data Types and Structures
Queue-based esolang

"queue-based esolang" is, well, a queue-based esolang. It's also User:Emelang's first time in a while writing an interpreter for one of his esolangs.https://esolang-interpreters.glitch.me/qbe
== Syntax ==
p: pushes the character after it onto the queue.
q: pops the first item on the queue and discards it.
Q: pops the first item on the queue and outputs it.
!text!: comment.
== Examples ==
===Hello, world!===
 pHpeplplpop,p pWpoprplpdp!QQQQQQQQQQQQQ
A shorter variant that only works in the Python implementation:
 pHpeplplpop,p pWpoprplpdp!{Q}
== Interpreters ==
*Online interpreter: https://esolang-interpreters.glitch.me/qbe (is somewhat buggy though)
*Python implementation by User:Ractangle (which includes an aditional command): https://pastebin.com/KpWf1kDU
== See also ==
* QBE++ - A successor to the language the QBE
== References ==
Category:Queue-based
Category:Implemented
Category:Total
Category:Languages
Category:2024
Category:Unusable for programming
Category:Output only
Queue based

Queue based is an esolang by User:ChuckEsoteric08. The name does not only implies that it stores data in queues but also means that using Queue is based. It's main inspirations were Underload and Smurf
==Specification==
Queue based stores data in two queues. When you go to nonexisting label or try to dequeue if queue is empty program will halt
 (abc) - enqueue string abc
 , - dequeue
 @ declare new label
 ; - switch to diffirent queue
 ' - dequeue and goto label at index n, where n is length of dequeued element.
 / - enqueue a byte from user input
 \ - dequeue and output
 [abc_xyz] - this command is core of the language. It replaces every element which is equal to abc with xyz
 ~ - reverse queue
 ^ - dequeue and enqueue
==Computational class==
Queue based is Turing-complete because there is (untested) Bitwise Cyclic Tag interpreter in it:
~@~/[0_..][1_...][$_....]~'@~(..)(.)~'@~(...)(.)~'@~;
~@~/[0_......][1_.......][$_........]~'@~(..)(.)~'@~(...)(.)~'@
[......_............][......_.............];[.._..........][..._...........]~
@[.............._..........][..............._...........]~'
@(..........);,;(.........)~'
@(...........);'
@~(............)~;(.........)~'
@~(.............)~;[.........._..............][..........._...............]'
@~(..............)~(.........);(............);~'
@~(...............)~(.........);(.............);~'
This interpreter dosen't use any ^ so this will also prove Turing-completness even with this restriction. Input should be like that: Program$Data$
==See also==
*Stack based
Category:Languages Category:Turing complete Category:Turing tarpits Category:Unimplemented Category:Queue-based
Queuenanimous

Queuenanimous is an esolang by User:PythonshellDebugwindow.
==Memory model==
Queuenanimous uses an unbounded queue of unbounded signed integers.
==Syntax==
Like in brainfuck, each character of the program represents one command.
==Commands==
Dequeuing from an empty queue returns zero.
Command	Effect
0 	Enqueue zero
+ 	Dequeue N, enqueue N + 1
- 	Dequeue N, enqueue N - 1
> 	Dequeue N, enqueue N
[P] 	While loop: at each iteration, dequeue N, and break if N is zero; else run P and jump back to the start of this loop, dequeue N again, and so on
==Computational class==
Queuenanimous's computational class is unknown.
==External resources==
* An interpreter on GitHub
Category:Languages Category:2020 Category:Implemented Category:Queue-based Category:Unknown computational class Category:No IO
Queueue

Queueue (intentional misspelling of Queue) is an esoteric programming language made by :User:Rehydratedmango.
==Overview==
All data in Queueue is stored in queues, which can be further nested in bigger queues. Program execution begins with a single master queue.
==Commands==
Command 	Description
queue # to "queue" 	Queue an integer to a queue
queue "queue" to "queue" 	Queue a queue to another queue
new "queue" 	Define a new queue
forget "queue" 	Delete a queue
queue # to "queue" ?"queue"=="queue" 	Queue an integer to a queue if two queues are equal
queue "queue" to "queue" ?"queue"=="queue"	Queue a queue to a queue if two queues are equal
output from "queue" 	Dequeue the next item in the queue and print it. If the value is a queue, each value inside the queue will be printed as an ASCII character
input to "queue" 	Get input from the user. Each character they type will be queued as an ASCII code
transfer from "queue" to "queue" 	Dequeue the next item in the first queue and queue it to the second queue
queue $"string" to "queue" 	Queue every ASCII code, one after the other, to a queue
in "queue" do {code} 	For every value in the queue, dequeue it and execute some code. The dequeued value can be referenced with "i"
for # do {code} 	Repeat some code # times. The current loop number can be referenced with "i"
while "queue"=="queue" do {code} 	While the two queues are equal, execute some code
# + # 	Returns the sum of two integers
# - # 	Returns the difference of two integers
# * # 	Returns the product of two integers
# / # 	Returns the quotient of two integers
# % # 	Returns the remainder of two integers
A queue name beginning with # (as in #"main") refers to the length of the queue. This is the only way to store variables in Queueue.
Queueue has some special queue names that cannot be deleted. These are:
* main (main queue)
* empty (an empty queue; cannot be modified)
* garbage (queue is automatically cleared after every instruction)
* i (queue containing the current loop data in loops)
==Examples==
===Hello, world!===
 new "hello"
 queue $"Hello, world!" to "hello"
 queue "hello" to "main"
 output from "main"
===Truth machine===
 new "state"
 input to "state"
 new "one"
 queue $"1" to "one"
 while "state"=="one" do
 {
 queue "state" to "main"
 output from "main"
 }
 queue "state" to "main"
 output from "main"
===Fibonacci===
 new "n-2"
 new "n-1"
 new "n"
 queue 0 to "n-1"
 while "empty"=="empty"
 {
 queue #"n-2"+#"n-1" to "main"
 output from "main"
 for #"n-2"+#"n-1" do
 {
 queue 0 to "n"
 }
 transfer "n-2" to "garbage"
 transfer "n-1" to "n-2"
 transfer "n" to "n-1"
 }
Category:2022
Category:Queue-based
Category:Unimplemented
Category:Languages
QuickLang

Instructions start with a . and end with a ;.
The Hello World Program is:
 .out:"Hello, World";.end;
.out is the output, while .end ends the program.
Other instructions include:
 
structs 	info
.in 	take input
.if:...{...} 	if the instruction is 1, it does what is in the braces, if it's zero then it just ignores the braces
.loop:...{...}	same as if, just loops until zero
.add 	adds one
.sub 	subtracts one
@var 	variables begin with an @ symbol
truth-machine:
 @var = .in;
 .if:@var{.loop:@var{.out:@var;}}
 .out:@var;
 .end;
A+B Problem:
 @a = .in;
 @b = .in;
 @i = @b
 .loop:@i{
 .add:@a;
 .sub:@i;
 }
 .out:@a;
 .end;
Anything not starting with . or @ is a comment (just don't use ., ;, or @ in a comment)
Xkcd Number:
 .out:"4"; numbers also work
 .end; example: out:4
Category:LanguagesCategory:2024Category:Low-levelCategory:Unimplemented
Quid

In Quid, commands are made entirely of Latin conjugations, “being” verbs, prepositions and pronouns.
Each command has one number parameter (hereforth labeled N), and is repeated that many times.
There are 7 cells, which can either store a number or a letter.
If an error is encountered, the machine halts and outputs the value of the selected cell.
== Commands ==
Eum: output the value of cell N to the console
Adhuc: increase cell N’s value by 1 (returns an error if the value is a letter)
Erant: decrease cell N’s value by 1
Praeter: adds cell N’s value to the selected cell
Est: select cell N without any actions
Supra: if cell N has a larger value than the selected one, select it instead (returns an error if the value is a letter)
Ante: if cell N has a smaller value than the selected one, select it instead (returns an error if the value is a letter)
Tunc … post: repeat the commands inside until the program selects a cell with a value of 0, then jumps to post
Sum: Changes the selected cell’s value to that of cell N
Factus: Converts cell N’s value into a letter and replaces the original value with it (returns an error if the value is a letter)
Habet: The opposite of Factus. Converts cell N’s value into a digit and replaces the original with it (returns an error if the value is a digit)
Quid: At the start and end of programs (all text before/after quid is comments)
Per __ … Per: Instead of running the code, create a function so that whenever the text in the blank is typed, it will run that code. (returns an error if you call a name without having defined it)
== Examples: ==
==== “Hello World” ====
Outputs one at a time: H E L L O W O R L D
Quid
Per clear2
Tunc
Erant Erant
Est Est
Post
Per
Adhuc
Est
Praeter
Praeter
Praeter
Est Est
Sum
Factus Factus
Eum Eum
Habet Habet
clear2
Adhuc Adhuc
Adhuc Adhuc
Adhuc Adhuc
Factus Factus
Eum Eum
Habet Habet
clear2
Adhuc Adhuc
Adhuc Adhuc
Praeter Praeter
Praeter
Factus Factus
Eum Eum
Eum Eum
Habet Habet
Est Est Est
Sum Sum
Est Est Est Est
Sum Sum
Est Est Est Est Est Est
Sum Sum
clear2
Adhuc Adhuc Adhuc
Adhuc Adhuc Adhuc
Factus Factus Factus
Eum Eum Eum
Erant Erant Erant Erant
Est Est Est Est
Praeter Praeter Praeter Praeter
Adhuc Adhuc Adhuc Adhuc
Factus Factus Factus Factus
Eum Eum Eum Eum
Habet Habet Habet Habet
Eum Eum Eum
Habet Habet Habet
Erant Erant Erant
Erant Erant Erant
Est
Sum Sum Sum
Est Est Est Est Est
Adhuc Adhuc Adhuc Adhuc Adhuc
Adhuc Adhuc Adhuc Adhuc Adhuc
Praeter Praeter Praeter Praeter Praeter
Praeter Praeter Praeter Praeter Praeter
Adhuc Adhuc Adhuc Adhuc Adhuc
Praeter Praeter Praeter Praeter Praeter
Factus Factus Factus Factus Factus
Eum Eum Eum Eum Eum
Habet Habet Habet Habet
Factus Factus Factus Factus Factus Factus
Eum Eum Eum Eum Eum Eum
Habet Habet Habet Habet Habet
clear2
Adhuc Adhuc
Adhuc Adhuc
Est Est
Praeter Praeter
Factus Factus
Eum Eum
Quid
==== FizzBuzz ====
You know what this does
Quid
Per 3?
Tunc
Est Est
Sum
Erant Erant
Erant Erant
Erant Erant
Supra Supra Supra
Post
(please insert rest i ran out of time)
Category:Languages Category:Pseudonatural Category:Cell-based
Quiler

Quiler is a joke esoteric programming language created in 2013. User:Sgeo had an initial idea, User:ais523 worked out what would be the minimal possible programming language that implemented the idea and wrote the specification, and User:ehird named it.
The semantics of Quiler are simple: given any input program, a Quiler compiler ignores it and outputs a Quiler compiler that targets the same language that the original compiler did. As such, all possible input programs are Quiler compilers in Quiler; and all total programs in any language are Quiler compilers that target Quiler. Also, all quines are Quiler compilers written in, and targeting, the same language (although a Quiler compiler need not be a quine). As such, Quiler compilers are relatively easy to obtain.
Note that it is possible for a total program in a language other than Quiler to not be a Quiler compiler. Even if the infinite regress in the definition is interpreted in the most inclusive way, if a compiler A for language L written in language M that targets the same language M compiles a program B written in language L, which is a compiler for language M that targets a language N other than M, then as long as there is at least one legal program in N that could be output by B that is illegal in M, A is not a Quiler compiler. If the preceding sentence made your head hurt, we recommend trying to avoid cross-compiling cross-compilers. (And never looking at gcc's build system.)
A side effect of the above is that a Quiler interpreter is necessarily also a Quiler compiler. (And vice versa.)
==Example==
A Quiler compiler targeting Haskell:
#!/usr/bin/perl -w
use strict;
my $pref = <<'EOP'; my $haskell = <<'EOH'; my $core = <<'EOC';
#!/usr/bin/perl -w
use strict;
my $pref = <<'EOP'; my $haskell = <<'EOH'; my $core = <<'EOC';
EOP
main = putStr . program $ ("Haskell", program history) : history
program h = core ++ show core ++ "\n\nhistory = " ++ show h ++ "\n"
core = "main = putStr . program $ (\"Haskell\", program history) : history\n\nprogram h = core ++ show core ++ \"\\n\\nhistory = \" ++ show h ++ \"\\n\"\n\ncore = "
history = [("Perl","
EOH
chop $haskell; print $haskell;
my $perl = $pref x 2 . "EOP\n$haskell\nEOH\n${core}EOC\n$core";
$perl =~ s/(["\\])/\\$1/g;
$perl =~ s/\n/\\n/g;
print $perl . "\")]\n";
EOC
chop $haskell; print $haskell;
my $perl = $pref x 2 . "EOP\n$haskell\nEOH\n${core}EOC\n$core";
$perl =~ s/(["\\])/\\$1/g;
$perl =~ s/\n/\\n/g;
print $perl . "\")]\n";
Category:Joke languages
Category:Unusable for programming
Category:Implemented
Category:2013
Category: Languages
Quine

A quine, named after the philosopher W. V. O. Quine, is a program that prints its own source code. One of the typical challenges of any new esoteric programming language is to write a quine other than the null program in it.
Often a program that just performs access to its own source code (reading it either from memory or from a disk file) and prints it out is considered "cheating".
The language Muriel is based on the idea of quines.
==How to write quines==
Quines can be developed in any Turing-complete language which has the ability to freely create output in its own source alphabet (though the existence of quines does not imply Turing-completeness; also see User talk:Smjg for a previous discussion about "quineless" TC languages and what "freely create output" means). Despite all the mystery surrounding them, they are actually quite simple to develop. Here is an algorithm for doing so:
First we construct the function print which outputs its input. In most languages this is trivial. For example, in Javascript we have 
 console.log(input);
Now consider print(print), the program which passes the source code of print to print. For example
 input = "console.log(input);";
 console.log(input);
	
It is quite easy to construct print(print), so we'll go ahead and write a program that given the input of the source code of program t outputs a program that passes the source code to the function, which is like saying "say 'say'" or "shout 'shout'." We'll call that program quinify. A quick note: you'll sometimes run into issues with escape sequences when writing quines. This is not a theoretical problem, only a language specific one. In this case we're using String.fromCharCode(34) to represent double quotes to avoid the issue. Anyway, here's quinify in Javascript:
console.log('input = ' + String.fromCharCode(34) + input + String.fromCharCode(34) + ';' + String.fromCharCode(10) + input);
	
The final step is easy! Pass the source code of quinify to quinify. We have a quine.
input = "console.log('input = ' + String.fromCharCode(34) + input + String.fromCharCode(34) + ';' + String.fromCharCode(10) + input);";
console.log('input = ' + String.fromCharCode(34) + input + String.fromCharCode(34) + ';' + String.fromCharCode(10) + input);
	
Here it is minimized for those inclined (151 bytes)
i="console.log('i='+String.fromCharCode(34)+i+String.fromCharCode(34)+';'+i)";console.log('i='+String.fromCharCode(34)+i+String.fromCharCode(34)+';'+i)
Clearly the only challenge here is in writing quinify, which in many esolangs is non-trivial. Get to work!
==See also==
* Iterating quine
* Narcissist
* List of quines
* Error quine
==External resources==
* The Quine Page has a nice collection of quines in different languages.
* Quines (self-replicating programs) is excellent information about quines.
* A truly esoterical quine
* Quine on Wikipedia
* Quine on Rosetta Code
Category: Program forms
QuineFuck

QuineFuck is an esolang invented by User:None1.
==Syntax==
QuineFuck is brainfuck, but every character that is ignored in brainfuck prints itself
==Example Programs==
===Cat===
 ,[.,]
===Hello World===
 Hello World!
===Quine===
 Quine
===Quine 2===
 Fuck!
Category:Languages
Category:Brainfuck derivatives
Category:Unimplemented
Category:Turing complete
QuineLang

==== Background ====
(Created by User:KrystosTheOverlord)
This language's purpose is to make every program a quine! If you don't make a quine, then you have done it wrong!
==== Interesting Quirks ====
A connection of same characters are called a "chain". This includes the normal syntax, which each has to be with its own corresponding symbols. Any non reserved character will all be counted as a "chain"
 >>> //chain
 hello //chain
==== Symbols ====
Syntax	What they Do
$ 	prints "$" plus single character or chain
+ 	increment by one (by chain)
- 	decrement by one (by chain)
! 	runs output
: 	outputs current cell in ascii
, 	input
> 	increment cell counter
< 	decrement cell counter
[ 	if current cell is not equal to zero, then perform next character chain (includes $ as part of chain, but only one), otherwise skip to ]
] 	if current cell is zero, then go back to corresponding [
==== Examples ====
 $.
Outputs : $.
 $hello$.
Outputs : $hello$.
==== The Future ====
This language might be turing complete, but it is not proved.
Category:Languages
Category:Cell-based
QuinePig

QuinePig is a version of the language Pig, where every program is a quine.
==Usage==
QuinePig follows nearly the same syntax rules as Pig. You write the name of the text file you want to create, write PIG, then write the rest of the contents of the text file.
The difference is that QuinePig takes ALL of the code you wrote and puts it in the text file. Therefore, every QuinePig program is a Quine.
==Various Programs in QuinePig==
===Text File Named "Hello, World!"===
The following code creates a text file named "Hello, World!" and writes "Hello, World!PIG" to it:
 Hello, World!PIG
===Cat Program===
QuinePig cannot create the Cat program because it is output only.
===Quine===
Every QuinePig program is a Quine.
==Interpreter==
Written in Python.
def quinepig(code):
 assert type(code) is str, "ERROR: Code must be a string."
 assert "PIG" in code, 'ERROR: Code must contain "PIG".'
 file_name, _ = code.split("PIG", 1)
 file = open(file_name, "w")
 file.write(code)
 file.close()
==The Pig Series==
The Pig series is a a series of programming languages that are all based on Pig.
The languages are Pig, SickPig, DeadPig, and QuinePig.
Other languages based on Pig are DeafPig and ExtendedPig.
Category:Languages Category:Output only Category:Unusable for programming Category:Joke languages Category:Total Category:Implemented
Quine (programming language)

Quine is an esoteric programming language created by User:IAM. In it, everything is a quine. It is basically the same thing as Text.
==Hello world and quine==
This is a Hello, world! program and a quine:
 Hello, world!
==Implementation==
See also Cat Program.
==See also==
* Text, the exact same thing
Category:Languages Category:Joke languages Category:2007 Category:Implemented Category:Finite state automata Category:Total Category:Unusable for programming
Quinish

Quinish is an esolang where there are many quines.
==Syntax==
The only syntax: $...\, marks a comment. They can't be nested.
Any other characters prints itself.
==Examples==
Hello world:
 Hello, World!
Nope. intepreter:
 Nope.
APLWSI intepreter:
 $Anything can go here\
Quine:
 Any thing can go here:OPRFV|VFSOFSDC!@^#(*&^(^#@!^#@!(*&#!(*@!^(@*#
==Interpreter==
Written in JavaScript.
 s=>s.replace(/\$.*?\\/gs,"")
Category:Languages Category:Joke languages Category:Unusable for programming Category:Total Category:Low-level Category:Implemented Category:Output only