nyuuzyou/wikis huggingface dataset:
Hidden in the picture

hidden in the picture is a steganographic language.
if you dont know what that means, the languages own name explains itself fairly well.
== commands ==
 0 +
 1 -
 2 <
 3 >
 4 [ while non0 loop
 5 ]
 6 {
 7 } while 0 loop
 8 = skip next command if cell is 0
 9 . output
 A ,
 B $ toggle between output modes ascii|letters(27=space)|numbers
 C x add 10
 D y subtract 10
 E w add 100
 F z subtract 50
the commands are executed pixel by pixel using the last character in their hexadecimal values
these are in the order the same way you would read an english text. left-to-right first priority, top-to-bottom last priority.
== hello world ==
i cant figure out how to add this to a picture, but this is how far i got:
step 1:
 x--.---.x---..+++.++x.----.y++.+++.y++++.y++.
step 2:
 C1191119C11199000900C911119D1191119D11119D119
Hieroglyphic

== Syntax ==
Hieroglyphic uses hieroglyphics to symbolize its code. Here are the symbols and their meanings.
Symbol	Command 	Gardiner Sign	Description 	Unicode	Glyph
I 	Increment current cell value 	M17 	 	U+131CB	𓇋
B 	Decrement current cell value 	D58 	 	U+130C0	𓃀
Q 	Write following character to current cell 	N29 	 	U+1320E	𓈎
H 	Copy value at current cell to STORE 	O4 	Reed shelter	U+13254	𓉔
P 	Decrement pointer location 	Q3 	 	U+132AA	𓊪
Š (SH)	Increment pointer location 	N37 	Pool 	U+13219	𓈙
N 	Add current cell value to number in STORE 	N35 	Waves 	U+13216	𓈖
R 	Print all letters and numbers 	D21 	 	U+1308B	𓂋
? 	Write space (ASCII 32) to current cell 	M3 	Branch 	U+131B1	𓆱
S 	Create a mark in the code labeled with the next character 	O34 	Door bolt 	U+13283	𓊃
Č (CH)	Go to mark with label of next character 	V13 	 	U+1337F	𓍿
T 	If current cell value matches value in STORE, go to mark with label of next character, else, the label of character after that	X1 	 	U+133CF	𓏏
D 	Print number 	D46 	Hand 	U+130A7	𓂧
W 	Get input 	G43 	 	U+13171	𓅱
G 	Write value in STORE to current cell (don't clear STORE) 	W11 	 	U+133BC	𓎼
X (KH)	Invert case of character in current cell 	AA1 	 	U+1340D	𓐍
== Examples ==
=== Cat ===
 WR
=== Hello world ===
 QHŠQEXŠQLXHŠGŠQOXŠ?ŠQWXŠQOXŠQRXŠGŠQDXŠR
==External resources==
* Wikipedia:Gardiner's sign list
* Wikipedia:Transliteration of Ancient Egyptian#Uniliteral signs
* Wikipedia:List of Egyptian hieroglyphs
Category:Languages
Hieroglyphics

:Not to be confused with Hieroglyphic.
Hieroglyphics is an esolang based on Ancient Egyptian hieroglyphics. It was formed basically by taking everything the Egyptians did and trying to turn it into code. As such, it may be a little confusing.
==Layout==
Hieroglyphics is somewhat unusual in that it is read from right to left, in the same way the Egyptians did (mostly). In addition, although some of my examples further down this page were given as if they were on one line, they should actually be written as quadrats, like this:
{TODO: Give example}
A code may use objects of the following type: literal values, expressions, functions, variables, tuples and lists. If it is ever unclear which is which, determinatives may be used, but the compiler will always attempt to infer from context. A quadrat may contain more than one type, or several objects of the same type, but no object may be split across several quadrats.
==Literals==
===Numbers===
The natural numbers in Hieroglyphics are formed by adding powers of 10. The character 0 represents 1, 1 represents 10, 2 represents 100, and so on up to 9. Thus 276 would be written as 000000111111122. The ! character on its own represents 0, and with other numerals represents a minus sign, for example 012! is -111. The letter r represents 1 divided by something. 1/32 would be 00111r. (The Egyptians used a mouth, which they also used as an "r" sound.)
Addition is done using the sign <, subtraction using > (they look like the Egyptian symbols turned round). You can represent unusual fractions this way: 2/7 would be 0000000011r<0000r.
The determinative is #.
===Strings===
Strings are given the determinative "
==Variables==
Variables always have 2 determinatives: the determinative of a literal in the same class, and the ? symbol. The name may be made from any non-whitespace UNICODE symbols.
To create or change a variable, type the symbol *, the value required, and the * again, then the variable name: *"Hello*"?foo. Variables and functions are local unless they are in a cartouche like these:
 |(?foo)
 
 |/###Important\
 |\ListOfFloats/
 
 | /Very\
 |/ Long \
 |\ Func /
 | \Name/
in which case they are global, and must have a cartouche every time they are referenced.
Category:Works-in-Progress
Higgledy Piggledy Processor

The Higgledy Piggledy (HP) Processor is an Esoteric Processor (or more than one, if one includes the Higgledy Piggledy GPU) designed by user:hppavilion1 of the Zodiac Working Group. It is designed to be an actual, real Esoteric Processor that, if one were so inclined, one could actually construct(though it will most likely only be run as a Virtual Machine).
Category:Concepts
HighFive

HighFive is an esoteric programming language by Ben Russell, which is loosely inspired by brainfuck.
== Specification ==
The HighFive command set goes as such:
:+: increase what's at the pointer, or if pointer = 7, get input.
:-: decrease what's at the pointer, including if pointer = 7.
:/: increase the pointer. If pointer goes past 7, reset it to 0.
:*: if the last value modified is not 0, relative jump:
:*Whatever's at the pointer, move Program Counter (PC) forward or backward that number of steps.
:.: output whatever's at the pointer.
::(That's a full stop. It doesn't show up well.)
Anything else is a comment.
=== What's at each pointer ===
*0: memory slot #0
*1: memory slot #1
*2: memory slot #2
*3: memory slot #3
*4: memory slot #4
*5: segment
*6: I/O address
*7: input
It's not too dissimilar to a CPU architecture.
=== I/O address list ===
*0: CON (keyboard / screen)
==== Proposed I/O ====
*Extra segment ('cos the memory's too low)
(Any more, just drop it in here.)
=== How the segments work ===
Just change slot #5. Values are shown in hex.
00: 000 001 002 003 004
01: 005 006 007 008 009
02: 00A 00B 00C 00D 00E
03: 00F 010 011 012 013
... ... ... ... ... ...
FE: 4F6 4F7 4F8 4F9 4FA
FF: 4FB 4FC 4FD 4FE 4FF
So you have 1280 bytes of RAM. If someone needs more then I'll rig up a mapper
over one of the I/O ports, else it'll stay as-is. Just one 8-bit value can
boost it up to 327680 bytes (320KB), which is more than Brainf*ck's 44000B (just under 43KB).
== Examples ==
HELLO:
 -----------------------------------////++++++++////
 /+++++++++/+++++++++++++/++++/-////*/
 ./---.+++++++..+++././/////+++++++++++++++./.+++.------.--------./+.
== External resources ==
*HighFive Interpreter, with mirror in the Esoteric File Archive (original file lost for some weird reason.)
**This has been PD'd. Disregard the license, and do whatever you want with it. --Ben Russell 05:37, 12 August 2008 (UTC)
Category:Languages
Category:Implemented
Category:Brainfuck derivatives
Category:Cell-based
Category:2006
Hippopotomonstrosesquipedalian

Hippopotomonstrosesquipedalian is a programming language based on two words:
* hippopotomonstrosesquipedalian
* pneumonoultramicroscopicsilicovolcanoconiosis
It is ridiculously tedious to program in as it requires 6,610 characters to display the string Hello, World! .
=== Hippopotomonstrosesquipedalian on GitHub ===
Category:Languages Category:Pseudonatural
History (programming language)

History is a joke programming language invented by User:A that depends on the History data structure, an esoteric data structure inspired by queues that cannot delete anything.
==The History data structure==
Its behavior is very simplar to a queue. There are 2 primary operations: UPDATE, and INSERT.
The following table explains them, and shows how to implement them in History.
op 	meaning
UPDATE X	Update the current number as X, and put the previous "current number" into history.
INSERT X	Insert the backmost item to the index between index X and index X+1 without deleting the backmost item.
TOP X 	Insert the top item to the index between X and X+1 without deleting the item.
ONSERT X	Put position X onto the top of the history without deleting the item.
==An example session of History==
HISTORY:
COMMAND: UPDATE 1
HISTORY:
 @UPDATE #1 is 1
COMMAND: UPDATE 2
HISTORY:
 @UPDATE #2 is 2
 @UPDATE #1 is 1
COMMAND: INSERT 2
HISTORY:
 @UPDATE #3 is 1
 @UPDATE #2 is 2
 @UPDATE #1 is 1
COMMAND: BYE
==Computational class==
It is not Turing-complete, of course. (It cannot execute an infinite loop, or even any sort of conditional statement.)
Category:Joke languages
Category:2019
Category:Unimplemented
Category:Languages
Category:No IO
Category:Total
Category:Unusable for programming
Hmm

this programming language is about questioning stuff
== asking ==
 ask [person] [question] - person gets set to question
 answer [person1] [person2] [answer] - if the person2 ever asks answer, it doesn't happen
 know [person1] [person2] - if person2 knows the answer that person1 asked, person1 forgets the answer
== Program ==
 ask guy "you suck"
 answer guy2 guy "you suck"
 know guy guy2
 ask guy "you suck" #happens because of line 3
Hny021

hny021 is a Turing-complete esoteric programming language invented by User:Hakerh400 in 2021. It is also the first language ever created in 2021.
== Overview ==
Source code consists of two arrays of natural numbers. Their length must be the same and they must contain at least one element. The first array is called A and the second array is called B.
We internally keep track of three variables:
* h - Initially 0
* n - Initially 2
* y - Initially 1
Perform these steps iteratively until y becomes zero, in which case the program halts:
# Let a be the element of A at index h
# Let b be the element of B at index h
# Increment h by 1 and if it becomes equal to the length of the arrays then reset it to 0
# Check if y is odd
# Perform integer division y by 2
# Perform integer division n by 2
# If y was odd then y = y + n * a and n = n * b
== Interpreters ==
Here is a simple interpreter in Python:
 A = [6, 1, 5]
 B = [8, 4, 8]
 
 h = 0
 n = 2
 y = 1
 
 while y:
 a = A[h]
 b = B[h]
 h = h + 1
 
 if h == len(A):
 h = 0
 
 odd = y & 1
 y = y // 2
 n = n // 2
 
 if odd:
 y = y + n * a
 n = n * b
Category:Languages
Category:Turing complete
Category:Implemented
Category:2021
Category:No_IO
Hodor

Hodor is the name of at least three esoteric languages:
* https://github.com/ValyrioCode/Hodor 
* http://www.hodor-lang.org/ (https://github.com/hummingbirdtech/hodor)
* https://github.com/Keith-S-Thompson/hodor
One of the first two might actually be named HODOR, this is unclear. None of them have a page on esowiki yet.
Category:Languages
Homespring

Homespring, alternatively HOtMEfSPRIbNG, is a high-level esoteric programming language created by Jeff Binder in 2003 with the express intention of being far higher level than anyone would ever reasonably need or want.
Programs define a map of data control segments through which data flows sequentially and deterministically, and all commands are based on a metaphor of salmon travelling upriver. Each datum is an object consisting of a character string called the "name" and a boolean called the "age" of the datum. Three classes of command can change the value of data (name or age), the behavior of each datum (this behavior can be fixed or vary based on each datum), and the whole of the map on which the data flow.
The name stands for Hatchery Oblivion through Marshy Energy from Snowmelt Powers Rapids Insulated but Not Great.
==External resources==
* Jeff Binder's Homespring page, including links to other implementations
* Perl implementation
* documentation
* The original implementation. Features documentation and example programs.
Category:Languages 
Category:High-level 
Category:Implemented
Category:Thematic
Category: 2003
Hopscotch

Hopscotch is a simple esoteric programming language made by User:Asa-z.
==Overview==
Hopscotch programs are made of the commands +><^/\*?@_ and integer literals. The commands are chained linearly, but integer literals and the ? can cause the instruction pointer to jump.
==Memory==
Hopscotch has a stack of theoretically unlimited length. Additionally, it has a register. Each command is passed the value on the register, and the value it returns is placed on a register. When the code jumps, the register may be affected. Hopscotch programs are executed according to an instruction pointer, which is incremented after each command, and can be further modified by certain commands.
==Code==
All characters except +><^/\*?@_0123456789- are ignored. 
Each command is one token long. Each of +><^/\*?@_ is a token individually, and successive 0123456789- are grouped into a single token. This token is interpreted as a single integer. Sequences such as 123-456 are illegal, as `123-456` is not a single integer. Sequential integers must be separated with _ or another command. 
Code is executed one command at a time, beginning with the first command and terminating if the instruction pointer points beyond or before the code.
==Commands==
There are ten commands and integer literals in Hopscotch.
Command	Name	Description
+ 	ADD 	Pops the top two items off the stack and then places the sum on the register.
> 	PUSH	Takes the value on the register and pushes it on the stack, leaving it unchanged.
< 	POP 	Pops the top value on the stack and sets the register to it.
^ 	PEAK	Reads the top value of the stack, without removing it, and places that value on the register.
/ 	OUT 	Writes the ascii character represented by the value on the register to std out, leaving the register unchanged.
\ 	IN 	reads one character from stdin and writes that value to the register
* 	MULT	pops two values from the stack and sets the register to the product.
? 	IF 	If the value in the register is set to a non-zero number, then the instruction pointer is incremented by one (in addition to the normal one). Regardless, the register remains unchanged.
@ 	ROT 	Pops the _nth_ item on the stack, and pushes it to the top, where _n_ is the value in the register. The register remains unchanged.
_ 	NOP 	No action is taken and the register is unchanged.
===Integer Literals===
An integer literal is a relative jump. The normal increment of one for the instruction pointer is replaced by an increment by the integer. 
If the token immediately before the destination of a jump is an integer literal, then the register is set to that value.
==Computational Class==
The creator believes that Hopscotch is Turing-Complete, as he believes that brainfuck can be implemented. There is no formal proof.
==Helpful hints==
To represent data, 3_nc works, where n is an integer literal to have the register set to it as command c is executed.
==External resources==
Spec and Work-In-Progress Implementation
Category:Languages
Category:2017
Hostile snakes

hostile snakes is an esolang created by User:Yayimhere. hostile snakes is a 2d self modifying esolang with ladders. dont worry about the name, its just an overcomplicated pun
== how it works ==
the pointer starts at the second column, second row, and moves around on ladders like this:
* if it is at the bottom move to top 
* same but reversed for top
* if somewhere between it will move up and move the ladder to the right
* they function the same sideways but rotated 90 degrees
it will move up the nearest ladder(right priority) on the y level of the pointer, but if theres none the pointer will be moved up. if there still are no ladders the program halts. if the program halts after modifying it will not halt and it will append the program to itself. the program will error if the pointer is one the edges of the program. a ladder is this:
 
 =\
 =|
 =|
 =|-- this is the ladder
 =|
 =|
 =/
yea. thats it
Category:Languages Category:Two-dimensional languages Category:2024
Hoverfly

hoverfly is an esoteric, Turing-complete and purely imperative language. The name may be translated, when speaking in another language.
hoverfly was intended to be a 'normal' language,
however, since I am new to parsing, I downgraded the syntax to the lowest
and it became an interesting concept to be an esoteric language.
The name is coming from an insect, that mimics a bee.
That's my favorite insect, btw.
In the future I still plan to write a serious version of hoverfly.
If that happens at some point, this article will still be about the fun version.
The language is almost ready, but the docs here are not very detailed. Please check out the guide/ folder in repository linked at the bottom for the full walkthrough.
==types==
* # number - integer
* ^ number - object
* & number - stream
* ! number - flag
number is an integer
==integer==
* # value <= - result in zero
* # value <= value - result is told value
#0 is command pointer, can be used for jump
==object==
* ^ value <= - empty object
* ^ value <= ^ value => value - pointing to another object
(in JS: global[value]=global[value][value])
* ^ value <= "string" - well, a string
* ^ value => value => value <= value - defining number value of object
(in JS: global[value][value][value] = value)
* # value <= ^ value => value - getting value of object
==stream==
File descriptors, must already be defined before interpretation.
Implementation-dependent. May be passed as argumnets, or whatelse.
Originally only 0, 1 and 2 defined for stdio.
Having only &? in the code must print all the streams and exit.
* # value <= & value - read bytewise
* & value <= # value - write bytewise
==flag==
* ! number
Act as a predefined jump points.
Values are put into the flags object before the interpreting. They can't be changed in runtime.
==value==
* #0 <= #0 + 1
(in JS: global[0]=global[0]+1)
Available operators: +, -, *, /, (, )
Division is made without a rest: 9 / 2 results in 4
0/0 produces 0, (something else)/0 produces exception
==import==
Now, there are also imports allowed.
They must have following form:
<= source:path
for source:
* base - code gets imported related to the working directory
* lib - code gets imported from lib/ folder in the root directory of hoverfly
path: will always be put a .fly at the end.
An import reads all the code from provided file
and executes it. Numbers object is private, so any computations can be performed in numbers object without overwriting main file's numbers object. Arguments can be passed to the import file via objects object. Typically the ^0 object.
==comments==
Single line comments only, start with ::
==examples==
Hello world:
 ^1 <= "Hello World!\n"
 #1 <= 0
 #2 <= ^1 => #1
 &1 <= #2
 #1 <= #1 + 1
 #0 <= #0 - #2 / #2 * 4
Truth machine:
 #0<=(49-&0)*3
 &1<=49
 #0<=0
Printing using lib:
 ^0 <= "Hoverfly is an insect <>"
 <= lib:io/puts
==interpreter==
Available in python: https://github.com/gXLg/hoverfly-eso
Category:Languages
Category:Implemented
Category:Turing complete
How to Make a call stack work

Here is a call stack in python, yayayayayay
== Code ==
 class Callstack(Linecounter):
 def __init__():
 this.callstack = []
 def push(code, lnum):
 this.callstack.push([code, lnum])
 def pop():
 super().linenum = this.callstack.pop()
 class Linecounter():
 def __init__():
 this.linenum = 0
 def increment(x):
 this.linenum += x
 cstack = new Callstack()
 linecount = new Linecounter()
 cstack.push("main", 0)
 linecount.increment(100)
 cstack.pop()[0] #linenum now is 0, and there is nothing in the callstack
How to learn this language

== Introduction ==
How to learn this language is a joke language. 
Actually, the name of the language is of infinity length. You can use "How to learn this language" to replace the "this language" in the name. So How to learn "How to learn this language", How to learn "How to learn 'How to learn this language'", etc. are all correct names for the language.
== Commands ==
There are 3 commands in the language.
i: input a string.
o: output the char on it's right. (Actually except for the char 'i' 'o' and 'q')
q: run the program. 
== Example ==
=== Hell0, w0rld! ===
 oHoeololo0o,o owo0orolodo!
=== 0 Interpreter ===
 io0
=== 6 Interpreter === 
 io6
=== Cat ===
 oi
Output input.
=== Output the name of the language (IN CAPITAL, Without the quotation mark) ===
 oHoOoWo oToOo oLoEoAoRoNq
First, output "How to learn". Then, output "How to learn". Then, output "How to learn". Then, output "How to learn"......
== Interpreter ==
=== C++ ===
#include <bits/stdc++.h>
using namespace std;
#define int long long
string code, input;
signed main() {
	getline(cin, code);
label:
	for (int i = 0; i < code.size(); i++) {
		if (code[i] == 'o') {
			if (code[i + 1] != 'i' && code[i + 1] != 'o' && code[i + 1] != 'q')
				cout << code[i + 1];
			if (code[i + 1] == 'i') {
				cin >> input;
				cout << input << endl;
			}
		}
		if (code[i] == 'q') {
			goto label;
		}
		if (code[i] == 'i' && code[i - 1] != 'o') {
			cin >> input; // actually this is no use
		}
	}
	return 0;
}
== See also ==
* Inputfish
Category:Languages Category:Implemented Category:Joke languages Category:Unusable for programming
Hq(-

Hq(- is a derivative of HQ9+ but weak.
* H prints "hi god"
* q prints the program's source code's first character's ascii value.
* ( prints the last line of 99 Bottles of beer.
* - adds ¹/∞ or in other words, zero
Yep. Basically does every BAD example program
==Interpreter==
Here is an interpreter written in Python 3.
try:
 f = open("code.hq")
 code = f.read()
 f.close()
except FileNotFoundError:
 print("Error: file 'code.hq' does not exist")
 exit(1)
acc = 0
for c in code:
 if c == "H":
 print("hi god")
 elif c == "q":
 print(ord(code[0]))
 elif c == "(":
 print("No bottles of beer on the wall.")
 elif c == "-":
 acc += 0
== Examples ==
=== Output the meaning of life ===
 *q
=== XKCD Random Number ===
 �q
Replace � with \x04.
Category:Languages Category:Joke languages Category:Total Category:Unusable for programming Category:Output only Category:Implemented
Hq9+8F

hq9+8F is hq9+ but different: by Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff (talk) 03:49, 4 August 2024 (UTC)
h retains the same.
q sets the accumulator to this code.
+ increments the accumulator by 2.
∞ prints "1" forever
f checks if A == 4 or 8, if yes halt. if 8, print "You Win!"
i sets accumulator to input
o output A
Numbers are multiplied by 22 and then 99 bottles of beer'd
Category:Languages Category:Unusable for programming Category:Joke languages