nyuuzyou/wikis huggingface dataset:
HA

:For other languages named Headache, see Headache.
HA is an esoteric programming language created by Peter Larsen in 2011. HA is short for: Headache, but as apparently headache was already taken as a name for a programming language I renamed it to the the shorter version HA.
HA is best described as an extended Befunge-like programming language, with alot of functionality added. The goal is to extend the concept with as many unique features as possible. For example you can set data/code on the 2D-tapes "in motion", you can run RegEx match/search/replace on code and data, you can have several IP's running in parallel in a kind of multithreaded way.
I will here try to describe all of the 500+ commands available (I am currently in the process of adding functionality)
Category:Languages
Category:2011
Category:Cell-based
Category:Two-dimensional languages
Category:Self-modifying
Category:Concurrent programming
HACKER LANG

__HACKER__LANG__ is a joke programming language created by User:Linker-Error. According to User:Linker-Error, it is intended to make you an "UlTiMaTe HaCkEr." It is, like all real hacking programs, programmed in only 1s and 0s,
also called "some fancy word that starts with 'bi' that I can't remember" by User:Linker-Error. It is a very simple programming language and is not Turing complete. User:Linker-Error stated that, 
"Because it looks simple, it has to do simple things just like Conway's Game of Life, any kind of cellular autamota, and boolean logic."
__HACKER__LANG__ consists of only two instructions (1s or 0s) with 1 printing "Hacker" and 0 printing "Hacker Stuff." If your program contains a 2, the interpreter will output random ASCII characters ranging from 128 to 253 until the interpreter is "physically restrained via military-grade tactics" otherwise known as closing your terminal window.
Category:2023 Category:Implemented Category:Unusable for programming Category:Output only Category:Joke languages Category:Thematic
HAHAHA

HAHAHA is a joke esolang by User:Yayimhere
== axioms(only way to do computation lol) ==
these are the axioms:
 fdhsatuivjsaiduagjfds
 gfvsgyutudtyureqwww
 >>>>>>>>>>>>>>>><>>
 (.).(.).(.).(n)=(.n)
 n[]≠[]
 n! = ⊥n
 AAAAAAAAAA⊥n≠⊤n
where n is an placeholder, and can be any string. theres also the program axiom:
 ;
 =====;===================
 ;
 ;⊤⊥p
where p is the program
Category:Unknown computational class Category:Joke languages Category:Languages Category:2024
HALT

HALT is a language designed for string processing which is currently under development.
== Overview ==
HALT takes instructions, each prepended with a line number. 
== Comments ==
A line beginning with a # will make that line a comment. A line beginning with ---, denotes a second pass, taking the output as input.
== Flow ==
HALT functions by keeping track of two main variables. HALT requires an input, it can even be a blank string. The pointer, and the instruction number. 
=== Pointer ===
The pointer stores the index that the program is at in the input string. When the pointer reaches -1 or reaches past the string's end, the program is halted. If ht pointer never reaches these parameters, the program will trapped in an infinite-loop
=== Instruction ===
The instruction number is the current instruction being executed. The instruction number, is specified by the number preceding the line.
== Functions ==
Name 	Arguments 	Description
Pointer 	Pointer 	Pointer
INCREMENT 	None 	Increments the pointer by 1
CONTINUE 	number 	Increments the pointer by n
SET 	number 	Sets pointer to the specific value
Flow 	Flow 	Flow
HALT 	None 	The HALT function stops the program (sets pointer to -1). The output is printed to STDOUT
NEXT 	None 	Sets pointer to the specific value
GOTO 	number 	Goes to instruction number n
Output Stack	Output Stack 	Output Stack
STORE 	number 	Pushes character in string at pointer offset by n, to the output stack
TYPE 	string 	Pushes string to output stack
KEEP 	number 	Pushes character in string at pointer to output stack in index n
Other 	Other 	Other
IF 	string, number[, ELSE, number]	If the characters, from the pointer are string. Goto line n1. Optionally, if ELSE exists as a third argument. If the expression instead evaluates to false Goto line n2
GET 	int, number[, ELSE, number] 	IF(char at index n1 in output stack, n2, ELSE, n3)
== Examples ==
=== Hello World ===
 1 TYPE "Hello, World!"; HALT;
=== Reversing Input ===
 1 KEEP 0; INCREMENT;
=== Escaping Quotes ===
1 IF '"' 2 ELSE 7;
2 STORE 0; INCREMENT; IF "\\" 3 ELSE 4;
3 INCREMENT; GOTO 2;
4 IF '"' 5 ELSE 6;
5 HALT;
6 GOTO 2;
7 IF "'" 9 ELSE 8;
8 INCREMENT; GOTO 1;
9 STORE 0; INCREMENT; IF "\\" 10 ELSE 11;
10 INCREMENT; GOTO 9;
11 IF "'" 6 ELSE 12;
12 GOTO 9;
== Interpreters ==
* Official Online Interpreter 
Category:Languages
HAN

HAN is an interpreted, single-type esoteric programming language created by User:Aryantech123. It was created to act as a syntax for many smaller projects involving computer architecture.
It is a simple language, with 3 basic types of commands and uses strict prefix notation. Only floating point variables are supported.
==Language structure==
Each program is made up of commands, separated by newline characters. Indentation is strictly not allowed, and neither are blank lines. Programs are, thus, always a solid list of instructions.
Commands are made up of tokens, which are separated by spaces. Overall, in HAN 1.3 patch 2, there are 3 basic types of commands- variable, algebra, and control.
Commands are structures similar to sentances.
In general command follow the following syntax-
 command arg1 seperator arg2 separator arg3
Here, command is the command, arg1, arg2, arg3 are the arguments, and seperator are used to space everything out.
===Variables===
Variables are initialized at the time of declaration. They are declared using the let command. 
Variable names can include nearly every ASCII character except for spaces
In code, variables are always referred to by placing $ before their name.
Example: A variable A is declared by let A is 10 and refers to as pr $A
==Commands==
The current commands in the language:
Command	General syntax 	Description
pr 	pr sometext 	Prints sometext. Can also print variables, bu placing $varname
let 	let varname is value 	Declares a variable varname, and initializes its value. Variables are always floating point.
set 	set $varname to value 	Sets value of variable varname
add 	add $v1 is $v2 and $v3	Adds v2 and v3, and stores result in v1. add can be replaced by sub, mul, div, or mod for other operations.
skipif 	skipif $a <= $b n 	If a <= b, it skips the next n lines. Any comparison operator can be used.
doif 	doif $a <= $b n 	SImmilar to skipif, except executes the next n lines if condition is true.
goto 	goto lineno 	Jumps to a given line. Lines are indexed from 1.
end 	end 	Ends the program. Mandatory.
==Examples==
Hello world
pr Hello, world!
end
Infinite loop
pr Forever!
goto 1
end
Times table
let a is 1
let n is 7
let t is 0
doif $a < 11 4
mul $t is $a and $n
pr $t
add $a is $a and 1
goto 4
end
==External links==
Interpreters in both Rust and Python
Category:Implemented
Category:Output only
Category:High-level
Category:Languages
Category:2020
HASSL

HASSL (Hexadecimal, ASCII, Symbolic, and Stack-Based Language) is a stack-based esoteric programming language created in 2023 by Ethan T. Stanger.
== Language summary ==
HASSL programs begin by defining a number of states. These states can be any of the single hexadecimal digits (0-9, A-F), and can be written anywhere in the program. Execution starts with the first 0 found in the program, and from there on commands are run one character at a time.
 A complete list of the commands in HASSL
Command 	Action
0-9, A-F	Define a state
$ 	Select a state
& 	Go to the selected state
^ 	Push a value to the selected stack
v 	Pop a value from the selected stack
+ 	Add the top two values of the selected stack
- 	Subtract the top two values of the selected stack
< 	Select the left stack and hex digit
> 	Select the right stack and hex digit
* 	Increment the selected hex digit
. 	Reset the selected hex digit to 0
~ 	Set both hex digits to a random value
?, ! 	Conditionals
p 	Print an ASCII character
n 	Print a hexadecimal number
g 	Get a line of user input
# 	Get the size of the selected stack
@ 	Terminate the program
Category:2022 Category:Stack-based Category:Unknown computational class Category:Implemented
HBL

== Halting Binary Logic ==
HBL can also refer to Half-byte lisp.
HBL is a theoretical esoteric language that uses whether or not a subprogram halts to represent memory, A halting program is a 0, an unhalting program is a 1. HBL’s memory structure is a random access ‘tape’, and each ‘bit’ stores a single program. The tape can contain infinitely many values, similar to a Turing machine. HBL is believed to be Turing complete, and thus can simulate any other language.
Basic Instructions:
* [ is the start of a loop, HBL loops are infinite with the only exit being break conditions.
* ] is the end of a loop, like pretty much all languages, loops can be nested.
* ! is the set command, and takes one argument: a program, ended by a ). it writes the program it is given to the currently selected cell.
* ? is a conditional break, exits the current loop if the current cell is a ‘1’, otherwise does nothing.
* ; is a simple break, exits the current loop no matter what.
* > is the move right command, moves the pointer by +1
* < is the move left command, moves the pointer by -1
With these instructions, most logic is possible, including addition, subtraction, and other logic. Most logic is easily done using rule tables, for example, a AND gate could be (I think):
 [[?>>![;]][?<![])]?[?>>![;]][?<![])]?![])]
All programs have their own pointer on the tape, preventing a control struggle from programs accessing the tape. Threading is also possible, by reserving spots on the tape for subprograms to run, however, status on programs would require secondary spots on the tape, to tell if the program has halted yet or not. An interesting paradox caused by the way the language works also exists, it is possible to make a program that halts if and only if it doesn't halt (theoretically, pointed out by ais523), an example being ![?])[?] . There is a high probability that there are multiple other paradoxical situations possible.
===Boolfuck translation===
Notice: due to the nature of this programming language, it is extremely difficult to prove this, and all you have is the word of this document.
+ = [[?![])>![])<;]>?<![;])>![;])]
> = >
< = <
[ = [[[?![])>![])<;]>?<![;])>![;])<;]? <amount of moves to return to original cell>[[?![])>![])<;]>?<![;])>![;])] <matching bracket>
] = ]
There are minor diffrences and quirks to iron out, but it is plenty possible to translate boolfuck, a Turing Complete language, to HBL, proving HBL turing complete.
Category: Languages
Category: Unknown computational class
Category: Unimplemented
Category: Uncomputable
HECKSUM!

this is a temporary page. if by some miracle you found it before its finished, congrats, but please do not delete it.
HECKSUM! is an esoteric programming language created by User:AnotherTakenName and User:Linker-Error inspired by Malbolge. HECKSUM! operates by hashing ASCII strings with a small but equally random hashing algorithm that outputs groups of 37 bits dubbed "Kirbies" by User:Linker-Error. Based on properties of the program such as its length, two characters will be randomly selected to be excluded from the program, and every occurence of one of those two characters will combine into an 8-bit binary integer (with one character acting as a 1 and the other as a 0). This binary integer will then be used to define the required length of each string. The required length of each string is either multiplied by two or left unchanged based on the iteration of the Kolakoski Sequence equal to its position in the program, meaning the first string would be the set length, the second string would be the set length*2, the third would be the set length*2 as well, etc.
== Running a HECKSUM! Program ==
HECKSUM! is a JIT compiled language, meaning that the program will be immediately before it is run. It compiles to TVM directly from source code and
HELOWOR

HELOWOR is an esolang made by emelchenko.
All of its commands are related to "Hello World!".
== Commands ==
Hlo: prints "Hello World!".
olH: prints "Hello World!" reversed.
HHl: prints "Hello Hello!".
WWr: prints "World World!".
WHl: prints "World Hello!".
== Links ==
Interpreter in Swift.
== See also ==
* HWorld
Category:Languages Category:Implemented Category:Output only Category:Unusable for programming Category:Total
HI9+

HI9+ is a derivative of HQ9+ created by User:Rdococ. Rather than having a quine command, rdococ thought it would be more useful if there was an interpreter command that printed the source code of the interpreter. Thus, the I.
== Overview ==
Take this quote from HQ9+:
::Although the language is not of serious interest by itself, it can be useful to implement HQ9+ in a new esoteric programming language, since doing so proves that all the tasks above, except the quine, are possible.
HI9+ fixes this egregious oversight in the design of HQ9+, so that an implementation of HI9+ in a new esoteric programming language proves that all the tasks are possible, including the quine.
== Instructions ==
* H prints the message hello, world
* I prints the interpreter's source code. (If the code is compiled, it simply prints I can't bel1eve 1t's not qu1ne! instead.)
* 9 prints the lyrics to "99 bottles of beer."
* + increases the accumulator.
Instructions are case-insensitive as in HQ9+. Invalid instructions are no-ops.
== Quines ==
HI9+ can be thought of as having infinite variants depending on the interpreter's source code. Each variant may have different conditions for quining.
* The empty program is always a quine.
* As in HQ9+, hello, world is a quine.
* If the interpreter's source code contains one I and no other valid HI9+ instructions, the same code will produce a quine in HI9+.
* I can't bel1eve 1t's not qu1ne! is, ironically, a quine if a compiler is used instead of an interpreter.
* If the interpreter's source code is IQ, then IQ is a valid quine in both that variant of HI9+, and in HQ9+.
Category:Joke languages
Category:Unusable for programming
Category:Languages
Category:Output only
Category:Unimplemented
HQ+

HQ+ is a version of HQ9+ without the "9" command, because the creator of this language User:Brain Boy 53 thinks that 99 bottles of beer is annoying.
==Commands==
H or h prints Hello, World!
Q or q prints the program's source code.
+ increments the accumulator.
All other characters are ignored.
==Example Programs==
===Hello, World!===
 h
===Quine===
 q
==="Really cool and fun program!!!11!!!11!"===
 hQhQ++qHhHq+QqQhHqQ+
==External Resources==
HQ+ interpreter in python
Category:Joke languages Category:2024 Category:Implemented Category:Languages Category:Output only Category:Total Category:Unusable for programming
HQ9++

HQ9++ was written by David Morgan-Mar. It is an object-oriented extension of the HQ9+ joke language by Cliff L. Biffle. It adds the following instruction:
* ++: Increment the accumulator twice, and instantiate an object of a new sub class of the generic super class. Due to the best principles of object hiding, this object cannot be accessed in any way.
== See also ==
* HQ9+
* HQ9+-
* FHQ9+-
==External resources==
* HQ9++ homepage
* Java interpreter
* Online HQ9++ interpreter in Javascript
* HQ9++ Interpreter in Liberty BASIC
Category:Joke languages
Category:Unusable for programming
Category:Languages
Category:Output only
Category:Implemented
Category:High-level
Category:Object-oriented paradigm
Category: 2003
HQ9+-

An extension of HQ9++ with the - operator added for debugging purposes, by Melikamp.
- behaves differently based on what character(s) it follows:
* start of file: syntax error
* H: I/O error
* Q: infinite recurse
* 9: infinite loop
* -: decrement the accumulator
* + by itself: 1/0
* ++: virtual exception ("which itself is a method of an object of a new subclass of the generic superclass. In line with the best data-hiding principles, there is no way to intercept this exception.")
== See also ==
* HQ9+
* HQ9++
* FHQ9+-
==External resources==
* Specification and implementation by Melikamp
Category:Joke languages
Category:Unusable for programming
Category:Languages
Category:Object-oriented paradigm
Category:Implemented
Category:Output only
HQ9+2D

HQ9+2D is an extension of HQ9+ by Kenner Gordon. It has an instruction pointer which starts at the first byte of the program, moving east. It has the following commands:
Command 	Description
H 	Print "Hello, world!"
Q 	Print the source code of the program.
9 	Print the lyrics to "99 Bottles of Beer on the Wall".
Increment the instruction counter.	
> 	Move east.
< 	Move west.
^ 	Move north.
v 	Move south.
==Interpreters==
Python 3 interpreter:
def run_HQ9p2D(code_string: str, textfile = False):
 code = []
 direction = '>'
 instruction_counter = 0
 if textfile:
 temp = ''
 for line in open(code_string, 'r'):
 temp += line
 code.append(line.strip('\n'))
 code_string = temp
 else:
 code = code_string.split('\n')
 code_width = max([len(line) for line in code])
 pointer = (0,0)
 while 0 <= pointer[0] < len(code) and 0 <= pointer[1] < code_width:
 south = pointer[0]
 east = pointer[1]
 if east >= len(code[south]) or code[south][east] not in 'HQ9+^v<>':
 pass
 else:
 char = code[south][east]
 if char in '^v<>':
 direction = char
 elif char == 'H':
 print('Hello, world!')
 elif char == 'Q':
 print(code_string)
 elif char == '9':
 for i in range(99, 2, -1):
 print(f'{i} bottles of beer on the wall,\n'
 f'{i} bottles of beer!\n'
 f"Take one down, pass it around,\n"
 f"{i-1} bottles of beer on the wall!")
 print("2 bottles of beer on the wall\n"
 "2 bottles of beer!\n"
 "Take one down, pass it around\n"
 "1 bottle of beer on the wall!\n"
 "1 bottle of beer on the wall,\n"
 "1 bottle of beer!\n"
 "Take one down, pass it around,\n"
 "No bottles of beer on the wall!")
 elif char == '+':
 instruction_counter += 1
 if direction == '>':
 pointer = (pointer[0],pointer[1]+1)
 elif direction == 'v':
 pointer = (pointer[0]+1,pointer[1])
 elif direction == '<':
 pointer = (pointer[0],pointer[1]-1)
 else:
 pointer = (pointer[0]-1,pointer[1])
Category:Joke languages
Category:Implemented
Category:Two-dimensional languages
Category:2009
Category: Languages
HQ9+B

HQ9+B is an ℒ-complete extention to the joke language HQ9+, created by User:Oleg in 2009. The language has one additonal command:
* B: read input and execute as a brainfuck program.
To allow input to a brainfuck program the input must be delimited by '!' sign, i.e. dbfi dialect.
Category:Joke languages
Category:2009
Category:Languages
HQ9+F

HQ9+F – HQ9+ + functions. Unlike HQ9+, it has three additional commands:{, } – brackets in which the function body is located;> – imports the library.Unlike HQ9+, it is a Turing–complete language, because libraries can be written in any programming language
==Examples==
3{
 HHH
}
Q3
+3
==Interpretator==
While no:(
Category:Languages
Category:Functional paradigm
Category:Turing complete
HQ9+ C Function Interface

An esolang created by User:Oshaboy in 2022. After creating the same SDL2 demo in many different programming languages (COBOL, Awk, C-INTERCAL, Funge-98 and APL) using their C Function Interface.
So why not make the same demo in HQ9+? Well, because HQ9+ doesn't have a C Function Interface. But it is trivial to modify HQ9+ to allow that. 
= Commands =
H Q 9 and + are copied verbatim from HQ9+. 
S is a "binding" that creates an SDL2 window and renderer and draws random lines in random colors on the screen. Once the window is quit the code resumes. 
= C Interface =
But wait, there's more.
What about Calling HQ9+ code from C. Well, I've created a header and library to do just that. 
There is 1 typedef, 7 methods and 5 defines. 
=== Types ===
HQ9P_State is a structure that contains all the data required by HQ9+. This allows you to create many different HQ9+ functions and execute each in its own environment. Due to data hiding best practices the structure contents are undefined (so you can't just read the accumulator using C code). 
=== Methods ===
 
* HQ9P_State * HQ9P_Initialize(char *): Create a new HQ9P state. The code has to be passed to it for the q function
* void HQ9P_destroy(HQ9P_State *): Destructor. 
* void HQ9P_parse_char(HQ9P_State * state,char c): takes a char and runs it as an HQ9+ Command. 
* void HQ9P_parse_next_char(HQ9P_State * state): takes the next char of the source code and runs it.
* char * HQ9P_parse_char_buf( char * buf, size_t n, HQ9P_State * state,char c): This allows you to put the output of an HQ9+ Command in a buffer. 
* char * HQ9P_parse_next_char_buf(char * buf, size_t n, HQ9P_State * state): You get the gist
* int HQ9P_is_at_end(HQ9P_State * state): Returns 1 if at the end of the code and 0 otherwise. 
=== Defines === 
The defines are "H" "Q" "N" "P" and "S". each one calling the equivalent HQ9+ Command. The scope used is the last one created by HQ9P_Initialize.
= Implementation =
https://github.com/oshaboy/HQ9--CFI
Category:Implemented
Category:Joke languages
Category:Unusable for programming
Category:Languages
HQ9+~

HQ9+~ is an extension of HQ9+- by User:EZ132. It is Turing-complete. All valid HQ9+- programs are valid in HQ9+~, and will produce the same output.
There are five (six if you include -) valid characters: H, Q, 9, +, -, and ~. The behaviors of H, Q, 9, +, and - are mostly inherited from HQ9+-. There are a few new behaviors:
* If a H is followed by a tilde, it will print out the text of FizzBuzz up to the current value of the accumulator.
* If Q is followed by a tilde, it will run the Truth-machine.
* If an 9 is followed by a tilde, it will create and run a new Universal Turing machine. In line with the best data-hiding principles, there is no way to access the output of this Turing machine.
* If a + is followed by a tilde, it will get input from the user. In line with the best data-hiding principles, there is no way to access the input.
== See also ==
* HQ9+
* HQ9++
* HQ9+-
* HQ9F+
Category:Joke languagesCategory:Unusable for programmingCategory:Languages
HQ99+LUFTBALLONS

HQ99+LUFTBALLONS is an HQ9+-derivative made by Tetrapyronia. It uses balloons to build the code. The accumulator is initally 0 and the stack is initally empty. The second-last line is a looping sequence of HQ99+LUFTBALLONS.
== Commands ==
 H: print "Hello, World!"
 Q: print source code
 9: print lyrics of 99 Luftballons
 +: add 1 to accumulator
 L: drop down 1 line
 U: print Unicode character corresponding to accumulator value (control characters are printed as spaces)
 F: print (accumulator value)!
 T: halt
 B: if accumulator = 1, jump up 1 line
 A: add top 2 stack items, no-op if <2 stack items
 O: output accumulator
 N: Add input to accumulator
 S: swap top 2 stack items
 <newline>: print '/n'
== Balloons ==
Every commands comes paired with a balloon. An example program: (adds 1 to accumulator)
 =========
 oooo ooo
 ||||o|||o
 |||||||||
 HQ99+LUFT
 =========
Once the program starts, all balloons float up until they hit the ceiling (=s):
 =========
 ooooooooo
 |||||||||
 ||||+|||T
 HQ99 LUF
 =========
All |o=(space) are removed to get:
 +T
 HQ99LUF
== Example Programs ==
Hello, World!
 =
 o
 |
 H
 =
Truth-machine
 ========================================
 ooooo oo oooo oooooo o oooooooooooooo
 o|||||o||o|||| |||||| |oo||||||||||||||
 ||||||||||||||o||||||o|||||||||||||||||o
 ||||||||||||||||||||||||||||||||||||||||
 HQ99+LUFTBALLONSHQ99+LUFTBALLONSHQ99+LUF
 ========================================
==See also==
* HQ9+
Category:Languages Category:Unknown computational class Category:2021 Category:Unimplemented