nyuuzyou/wikis huggingface dataset:
QuirkLang

= QuirkLang =
== Overview ==
QuirkLang is an esoteric programming language that thrives on quirks and randomness. Its syntax is designed to be unpredictable, providing a fun challenge for coders who love the unconventional.
== Basic Commands ==
* `@start` - Begin the program
* `@print` - Print command
* `@add` - Addition
* `@subtract` - Subtraction
* `@loop` - Loop
* `@end` - End the program
== Example Programs ==
=== Hello World ===
 
@start
@print "Hello, World!"
@end
 
=== Addition ===
 
@start
@print 5 @add 7
@end
 
=== Looping ===
 
@start
@loop 4
 @print "This is a loop"
@end
 
QuirkLang invites you to embrace the weird and wonderful world of coding. CodePhantom (talk)
Quite

A language made by Areallycoolusername. This is an attempt to make a useful language. 
== Specifics ==
This language so far, only supports printing and comments. It is implemented in C# as opposed to C++ which I always use. Here's the interpreter.
using System;
namespace Quite {
		
public class Program {
			
public static void Main(String[] args) {
	
string Qnput;
Qnput = Console.ReadLine();
	 	 
switch(Qnput) {
case "PrintV":
string jnput = Console.ReadLine();
Console.WriteLine(jnput);
break;
default:
Console.WriteLine("Quite the contrary to what we were expecting, my good fellow!");
break;
case "@":
break;
} 
 		
}
			
}
	
}
== Hello World Program ==
 @comments made using AT symbol.
PrintV @V points to the text below the command
Hello, world! @no quotes need. Entire line except comments read.
Category:2019
Category:Languages
Category:Unusable for programming
Quudo

Quudo (KOO-do) is an esoteric programming language by SwitchU42 (talk) that is very similar to assembly. It has 16 syscall instructions that can be controlled with arguments specified with the "movargs" function which are all variable references.
Floats only exist when you print them because.
Comments are between the left brace / right curly brace '{' and the right brace / right curly brace '}'
=Syscall commands=
 Note: these commands are the "syscallid" of the call function and the arguments (in the parenthesis) are provided by "movargs"
# print string/integer (data)
# receive input from stdin (data)
# exit program (code)
# add number (addend, addend, resultvar)
# subtract number (num1, num2, resultvar)
# multiply number (num1, num2, resultvar)
# divide number (num1, num2, resultvar)
# equals (first, second, resultvar)
# not equals (first, second, resultvar)
# greater than (first, second, resultvar)
# less than (first, second, resultvar)
# read file (filename, resultvar)
# write file (filename, datatowrite)
# delete file (filename)
# generate random number (remainder)
# system command (systemcmd)
# print ASCII character (char)
# logical and (op1, op2, res)
# logical not (op1, op2, res)
=Functions=
* call (syscallid)
* movargs (...args)
* run () runs the syscall
* rlab (labelid, condition) runs the "labelid" label. only runs the label if the condition argument is equal to 1
=Declarations=
 label (id) [
 functions
 ]
 {example label}
 &("Hello world!")
 &(1) {ALWAYS true} 
 label 1 [
 call(1)
 movargs(*0)
 run()
 {print hello world}
 ]
 rlab(1, *1)
==Truth machine==
 &(0)
 label 1 [
 call(1)
 movargs(*0)
 run()
 rlab(1, *0)
 ]
 call(2)
 movargs(*0)
 run()
 rlab(1, *0)
 call(1)
 movargs(*0)
 run()
|Implemented
=Download=
* Quudo-Linux executable
* Quudo-Windows executable
Quylthulg

Quylthulg is an esoteric programming language designed by Chris Pressey in 2008. It is a non-recursive pure functional language with a single control mechanism called foreach. In fact, it does also have a goto statement, but it may only occur inside data structures. It also features a macro processor (which is also non-recursive and which is intertwined somewhat with the rest of the language.)
==Syntax==
The majority of Quylthulg binary operations are expressed in "panfix" notation: the symbol indicating the operation precedes, follows, and is placed in-between the operands, as in:
 +1+2+
Variable names consist of (nearly) arbitrary text surrounded by $ symbols.
The syntax of the foreach construct is:
 foreach loop-var=list with accumulator=initial-value be expression else be expression
The foreach construct can double as an "if" and a "let".
==Example program==
 foreach $n$=:L:[1,2,3|goto$L$] with $a$=1 be +$a$+$n$+ else be abort
==Computational class==
Although the foreach mechanism can only traverse a list, cyclic lists can be created using gotos. Quylthulg should therefore be Turing-complete; for instance, it should be possible to express the state-transition diagram of a Turing machine as a cyclic list which is foreach'ed over, and the tape of the Turing machine as a pair of lists passed into the accumulator of the foreach. However, this has never been formally proved.
==External resources==
* 
* 
Category:Languages
Category:Implemented
Category:2008
QwertyScript

==Description==
QwertyScript is a ridiculous scripting language where the only commands are letters of QWERTYUIOP.
==How It Works==
Everything that is not qwertyuiop/QWERTYUIOP is ignored by the interpreter.
variables work in an integer stack, you can push and pop and modify the elements.
==Instructions==
Q: push a number 0 through 9 to the stack by putting a letter Q through P directly after
example: QT - push 4 to stack
W: remove top element from stack
E: print the top element of the stack as a number
R: print the ascii value of the top element of the stack
T: add and remove the two top elements of the stack, leaving only the sum
Y: subtract the top element from the second top element, leaving only the difference
U: multiply the top two elements and leave the product
I: divide the second top element by the top element and leave the quotient
O: divide the top two elements and leave the remainder
P: duplicate the top element
==Examples==
An example of a QwertyScript that prints "Hello World!\n" to the command line:
QOQPUR
QPQPUQPTQYQUTTR
QITRR
QRTR
QYQUTYQUQUUYQEIR
QRUQPYR
QTQUUTR
QRTR
QUYR
QOYR
QOQOUQRTYR
QRYQRIR
==How To Use==
The interpreter can be found on the QwertyScript Github Page
Category:Languages Category:Implemented Category:Stack-based Category:Total
Qwerty Reverse Polish Notation

Qwerty Reverse Polish Notation is a Reverse Polish notation calculator that is designed to be generally Turing-complete. In Qwerty Reverse Polish Notation (QRPN), almost all opcodes (except literals, references, labels and variables) are as small as 1 keystroke. The opcodes are separated by space (" ").
==Quick Reference==
 
 +--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
 | ~ not | ! pop | @ getn | # putn | $ swap | % mod | ^ pow | & and | * mul | ( dec | ) inc | _ neg | + add |
 | ` xor | 1 ---- | 2 ---- | 3 ---- | 4 ---- | 5 ---- | 6 ---- | 7 ---- | 8 ---- | 9 ---- | 0 ---- | - sub | = eq |
 +--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------+--------+--------+
 | Q | W | E 10^x | R root | T atan | Y | U | I | O | P | { shl | } shr | | or |
 | q | w | e exp | r sqrt | t tan | y | u | i | o | p | [ flr | ] ceil | \ roun |
 +--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------+--------+--------+
 | A | S asin | D | F | G | H | J | K | L log | : dup | " |########|########|
 | a abs | s sin | d | f | g | h | j | k | l ln | ; | ' |########|########|
 +--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------+--------+--------+
 | Z | X | C acos | V | B | N | M max | < lt | > gt | ? rand |########|########|########|
 | z | x exit | c cos | v | b bool | n | m min | , getc | . putc | / div |########|########|########|
 +--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
==Turing-Complete?==
Brainfuck programs can be transformed into Qwerty RPN by using the array technique above. Here is the basic procedure of translating Brainfuck to Qwerty RPN.
The variable i tracks the program counter. The header of the code is therefore 0=i, which initializes it.
* - and +: Get the value, increase or decrease it, and write back: $i $$ ( $i =$ or $i $$ ) $i =$
* < and >: Simply decrease or increase the variable I: $i ( =i or $i ) =i
* Loops ([BODY]): Loops are transformed into goto labels, and the condition is the current memory cell. Let L be a unique label: >L BODY $i $$ <L
* I/O: , and .: , transforms into , $i =$, and . transforms into $i $$ .
See 99 bottles of beer example, translated from BF.
==Examples==
Ask user to input 2 numbers, and print its sum.
 
 @ @ + #
 
Digital root calculator
 
 1 @ 1 - + 9 %
Locals-based factorial
 
 @ =value // value = input_number();
 1 =result // result = 1;
 $value =i // i = value;
 >loop // loop:
 $result $i * =result // result *= i;
 $i ( =i $i // i --;
 <loop // if ($i) { goto loop; }
 $result // return result;
 
without comments:
 
 @ =value 1 =result $value =i >loop $result $i * =result $i ( =i $i <loop $result
==External resources==
* Perl Implementation
* Official page
Category:2009
Category:Stack-based
Category:Implemented
Category:Languages
Category:Turing complete
Qwertypy

Qwertypy is an esoteric Python clone created by User:Saka where every letter or number is turned into a number.
Since it's just a Python clone, it's probably not worth mentioning details.
== How to Turn Python Code to Qwertypy Code ==
1. Make the code 1 line. For example (Truth Machine):
 a=raw_input()\nif a=="0":\n\tprint("0")\nelif a=="1":\n\twhile True:\n\t\tprint("1")
2. Change every character to the index of said character in this string:
 qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM0123456789~!@#$%^&*()_+-=[]{}\|;:,./<>? 
(Space at the end)
If the character is not in the "encoding string", leave it.
3. Separate each "encrypted" character with an underscore (_).
The result for the Truth Machine example above would be
 10_76_7_24_9_6_4_71_72_81_24_7_13_96_10_76_76_"_52_"_84_81_24_81_4_9_3_7_24_4_71_"_52_"_72_81_24_2_18_7_13_123_10_76_76_"_53_"_84_81_24_81_4_1_15_7_18_2_112_30_3_6_2_84_81_24_81_4_81_4_9_3_7_24_4_71_"_53_"_72
Or, you could use this script to encode
import random as r
char = ""
def encode(string):
 re = ""
 for i in range(0,len(string)):
 k = 0
 if string[i] == " ":
 k = r.randrange(92,150)
 elif string[i] not in char:
 re = re + string[i] + "_"
 else:
 while string[i] != char[k]:
 k += 1
 if k != 0:
 re = re + str(k) + "_"
 return re[:-1]
char = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM0123456789~!@#$%^&*()_+-=[]{}\|;:,./<>? "
s = input("String to encode? ")
print(encode(s))
== Interpreters ==
===Python:===
def decode(string):
 re = ""
 slist = string.split("_")
 for i in range(0,len(slist)):
 if slist[i][0] in "0123456789":
 if int(slist[i]) > 92:
 re = re + " "
 else:
 re = re + char[int(slist[i])]
 elif slist[i] not in char:
 re = re + slist[i]
 return re
char = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM0123456789~!@#$%^&*()_+-=[]{}\|;:,./<>? "
code = input()
c = (decode(code))
c = c.encode('ascii').decode('unicode-escape')
exec(c)
Category:Languages
Category:Turing_complete
Category:2018
Category:Implemented
Qwertyuiopasdfghjklzxcvbnm

Qwertyuiopasdfghjklzxcvbnm or QAZ for short is an esolang designed by Infinitehexagon to be very very cursed as possible. It has 17 accumulators with unbounded cells.
Category:2024Category:Languages
 Caption text
Command	Meaning
QWERTY 	Increment a random accumulator by 19 and move the cell pointer 25 times.
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Example	Example
Qwhy

Qwhy is a fungeoid esolang by User:BoundedBeans that aims to be different than other fungeoids, while also being weird.
==Playfield==
The default playfield is laid out as in Funge-98, but it doesn't expand infinitely. The number of lines specified in the program is the total default length, though this can be expanded during execution. The longest line is the width of every line, and this cannot be expanded. 
Upon reaching the edge of the playfield, the instruction pointer will jump to the nearest J instruction from the point before it went off the playfield.
The playfield can be self-modified, but only by removing the top line or appending a line to the bottom.
The instruction pointer can only move diagonally. It starts at the top right and moves southeast.
The playfield uses 16-bit unsigned integers as its contents, and the Unicode values are what matters to the instruction performed. However, only plain 7-bit ASCII characters may actually be specified, the rest must be created through adding lines.
==Queue==
Instead of having a stack, Qwhy has a queue. The queue can hold 16-bit unsigned integers.
==Instructions==
1	Enqueue a 1.
+	Dequeue x and y, enqueue x + y.
-	Dequeue x and y, enqueue x - y.
*	Dequeue x and y, enqueue x * y.
/	Dequeue x and y, enqueue x / y.
$	Dequeue x.
:	Dequeue x, enqueue x twice.
\	Dequeue x and y, enqueue y and x.
;	Dequeue x, enqueue x.
r	Change the direction to northwest.
7	Change the direction to northeast.
L	Change the direction to southwest.
j	Change the direction to southeast.
%	Skip the next instruction.
x	Go in a random diagonal direction.
X	Dequeue x, if nonzero, go northwest, if zero, go southeast.
t	Dequeue x, if nonzero, go southwest, if zero, go northeast.
G	Dequeue x and y, enqueue the number at that position. Note that the numbers accessed will move up one y coordinate if you remove lines.
P	Dequeue n numbers, where n is the width of the lines. Add a new line to the in-memory code with that as the contents.
#	Remove the top line from the in-memory code.
[	Dequeue numbers until a zero is encountered, inserting them into a list. Use that list as an ID for an iris, the Qwhy version of Funge-98's fingerprint feature. This overloads commands 65500 to 65535. This means you will have to add lines dynamically to even use these instructions at all. There is no iris stack, meaning you cannot have overloading like you can with fingerprints. Also, you cannot unload an iris, it stays forever unless you load a different iris.
]	Dequeue x, print it as a Unicode character.
{	Enqueue the Unicode value of a character of input.
_	Halt.
Note that, much like a bishop in chess, it's impossible for the instruction pointer to move on half of the cells. This makes them a great place to store data by self-modification, since they'll never mess any code up no matter how close they are to it.
==Examples==
===Print "HI"===
 1 j
 1 7 *
 * + :
 : ; ]
 * 1 1
 : : +
 * r ]
 7 _
Category:Two-dimensional languages
Category:Languages
Category:2022
Category:Queue-based
Category:Unimplemented
Qwote

Qwote is an esoteric programming language created by User: Areallycoolusername. The only valid commands are single and double quotes. The language is binary, so 0s are double quotes and 1s are single quotes. You can print anything by just typing the thing you want to print, but the characters must be in quotes or the program won't work. 
== Hello World Program ==
" ' " " ' " " " " ' ' " " ' " ' " ' ' " ' ' " " " ' ' " ' ' " " " ' ' " ' ' ' ' " " ' " ' ' " " " " ' " " " " " " ' ' ' " ' ' ' " ' ' " ' ' ' ' " ' ' ' " " ' " " ' ' " ' ' " " "" " ' " " " " ' " " " " ' spaces included for clarity and are ignored by code. 
== Implementation(s) ==
There are multiple implementations in the talk page.
Category:Languages Category:Total Category:Unusable for programming Category:Implemented
Q′′

Q′′ is P′′ but it's different. uses a finite number of cells and a finite number of symbol. it was created by User:Yayimhere for no reason at all
== syntax ==
* R, λ, W, U, and T are words in Q′′, which written in mathematical logic is: \Sigma=\left\{\text{R,λ,W,U,T}\right\}
* if p and q is a words in Q′′ then pq is a word in Q′′
* if q is a word in Q′′ then [q] is a word in Q′′
* only words derivable from these rules are words in Q′′ which can be written in mathematical logic: \text{p,q}\in\Sigma^{\ast}\supset\text{pq}\in\Sigma^{\ast}\vee\text{q}\in\Sigma^{\ast}\supset[q]\in\Sigma^{\ast}
in BNF: <word> ::= R|W|λ|T|<word><word>|[<word>]
== semantics ==
* {a0, a1, a2,... a10} is the tape-alphabet of a Turing machine with a 10 cell tape where each cell is a stack, a0 being the blank symbol.
* R means move the tape-head leftward one cell wrapping around if at edge.
* λ means replace the top symbol of the stack ai with aAbs(11 mod i + i mod 11) where the result must be modular base 10(so if i>10 then i=0+the overflow. so if i = 20 then i = 10 since it overflows by 10 and if i=12 then i = 2) then move the tape-head
rightward one cell.
* W move the top of the stack to the bottom
* T pop the top of the stack
* [q] iterate q until the top of the stack is equal to a0 or if the stack is empty
* U copy the top of the stack
Category:Languages Category:Cell-based Category:Stack-based
R++

R++ is an esoteric programming language created by User:Cleverxia.
==Syntax==
defined in BNF: (... is any string)
code := statement | statement code
ichar := "A"|"B"|"C"|"D"|"E"|"F"|"G"|"H"|"I"|"J"|"K"|"L"|"M"|"N"|"O"|"P"|"Q"|"R"|"S"|"T"|"U"|"V"|"W"|"X"|"Y"|"Z"|"_"|"a"|"b"|"c"|"d"|"e"|"f"|"g"|"h"|"i"|"j"|"k"|"l"|"m"|"n"|"o"|"p"|"q"|"r"|"s"|"t"|"u"|"v"|"w"|"x"|"y"|"z"|"!"|"$"|"#"
nchar := "0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9"
identifier := nchar | identifier (ichar | nchar)
label_ := ";" identifier
var := "@" identifier
string := "'" ... "'"
statement := (definition | assignment | label | goto | if | input | output | while) ":"
if := "if " expression " then " ("{" code "}" | " do " statement)
while := "while " expression ("{" code "}" | " do " statement)
goto := "goto " label_
label := "define " label_
voalist := (var|assignment) | (var|assignment) "," voalist
definition := "define" voalist
assignment := var "=" expression
op := "<"|">"|"/"|"+"
expression := string | var | "(" expression ")" | expression op expression | "%" expression
input := "input " var
output := "output " expression|"print " expression
the '<' operator: a < b means "1" if a is lexical...ic smaller than b else "0".
the '%' operator: %a means "1" if a is an empty string else "".
the '/' operator: a / b means:
* split a with seperator "&". call the resulting array c.
* replace all c[0]'s in b with c[1] and return it.
the '+' operator: a + b means a concated with b.
the '>' operator: a > b take a splitted by b and returns the last result.
if and while loops/dos the block inside if/while the provided string isn't empty.
==Examples==
===Hello, World!===
 print 'Hello, World!':
===Cat===
 define @a:while '1'{input @1:print @1:}:
===Truth-machine===
 define @a,@b:input @a:@b=@a:
 while @b>'0'{print @a:}:print @a:
Category:High-level Category:2024 Category:String-rewriting paradigm Category:Unimplemented
Category:Unknown computational class
Category: Languages
R.e.s.

r.e.s. is the creator of Bitwise Cyclic Tag. They participated in this wiki as User:r.e.s. from 2005 to 2010, then had brief activity spikes in 2013, 2015, and 2017, but have been inactive since.
Category:People
A considerable amount of r.e.s. files were apparently lost around the time when geocities disappeared. Some were later recovered and can be found .
RAMDISP

RAMDISP is an esolang made by User:Otesunki (talk).
==Instructions==
Function 	Description
P[vfff...] 	Pipe: Starts with the value v, passes it to each function, and sets the new value to the value returned from the function call. Ignores all further arguments passed to it.
D[fff...] 	Disperse: Passes all arguments passed to it to each function in order.
;[aaa...] 	Output: Outputs all arguments as strings to the console.
I[f[aaa...]] 	Ignore: Forces the function to execute with the arguments specified. Ignores all further arguments passed to it.
S[[f[aaa...]]b]	Swap: Forces the function inside to curry backwards instead of forwards, inner function recieves args baaa...
R[v] 	Range: Creates a range from 1-v (inclusive)
A[a] 	Anti: Reverses the array, and all items of the array.
M[fa] 	Map: For each item in the array, calls the function with the item as an argument.
~[v] 	Negate: Negates the value from v to -v.
-[ab] 	Subtract: Subtracts b from a.
+[ab] 	Add: Adds b from a.
*[ab] 	Multiply: Multiplies b with a.
/[ab] 	Divide: Divides a by b, rounds down to the nearest integer.
%[ab] 	Modulo: Divides a by b, and returns the remainder
==Arithmetic with arrays==
Numbers are represented by nested arrays, so 0 is [], 1 is , 2 is [[[]]], etc...
The code
 [*[[][[]]]]
calculates 2*3, and returns it.
==Code examples==
===Hello World===
 [;[Hello, World!]]
===Truth Machine===
 [P[:~R[M[I[;1]]][I[;0]]]]
===99 Bottles of beer===
 [P[[[[[[[[[[]]]]]]]]][*[[[[[[[[[[[]]]]]]]]]]]][S[-1]]RA[M[D[[S[; bottles of beer on the wall!
 
 ]][S[; bottles of beer on the wall,
 ]][S[; bottles of beer!
 Take one down, pass it around,
 ]]]]][I[;No more bottles of beer on the wall!
 
 No more bottles of beer on the wall,
 No more bottles of beer!
 Go to the store and buy some more,
 99 bottles of beer on the wall!]]]]
==Interpreters==
RAMDISP on GitHub
Category:Languages Category:Functional paradigm Category: Unknown computational class Category:Usability unknown Category:Implemented
RAM machine

A RAM machine, or Random Access Machine, is a computational model designed to analyze algorithm complexity.
It has an infinite number of registers, numbered R[0], R[1], R[2], ...
The model assumes constant time for reading, writing, and computational operations. Some of these operations include:
* R[i] <- c
* R[i] <- R[j]
* R[i] <- R[R[j]]
* R[R[i]] <- R[j]
* R[i] <- R[j] + R[k]
* R[i] <- R[j] - R[k]
* IF R[i] = 0 GOTO lbl 
* IF R[i] > 0 GOTO lbl 
* GOTO lbl
* STOP
Category:Computational models